def run_bench(num_iter, s, k):
wrld = ctf.comm()
M = ctf.random.random((s,s))
X = ctf.random.random((k,s))
[U,S,VT] = ctf.svd(M)
S = np.arange(0,s)+1
M = ctf.dot(U*S,U.T())
te = ctf.timer_epoch("BENCHMARK: SPD SOLVE")
te.begin()
times = []
for i in range(num_iter):
t0 = time.time()
X = ctf.solve_spd(M,X)
times.append(time.time()-t0)
te.end()
if ctf.comm().rank() == 0:
print("ctf.solve_spd average time:",np.sum(times)/num_iter,"sec")
print("ctf.solve_spd iteration timings:",times)
te = ctf.timer_epoch("BENCHMARK: Manual Cholesky+TRSM SPD SOLVE")
te.begin()
times = []
for i in range(num_iter):
t0 = time.time()
L = ctf.cholesky(M)
X = ctf.solve_tri(M,X,from_left=False)
times.append(time.time()-t0)
te.end()
if ctf.comm().rank() == 0:
print("ctf.cholesky+solve_tri average time:",np.sum(times)/num_iter,"sec")
print("ctf.cholesky+solve_tri iteration timings:",times)
def ccd(tenpy, T_in, T, O, X, reg_als, num_iter_als, tol, csv_file):
opt = ccd_Completer(tenpy, T_in, O, X)
#if T_in.sp == True:
# nnz_tot = T_in.nnz_tot
#else:
# nnz_tot = ctf.sum(omega)
if tenpy.name() == 'ctf':
nnz_tot = T_in.nnz_tot
else:
nnz_tot = np.sum(O)
t_ccd = ctf.timer_epoch("ccd")
regu = reg_als
tenpy.printf("--------------------------------ccd-----------------------")
start = time.time()
# T_in = backend.einsum('ijk,ijk->ijk',T,O)
it = 0
time_all = 0
if csv_file is not None:
csv_writer = csv.writer(csv_file,
delimiter=',',
quotechar='|',
quoting=csv.QUOTE_MINIMAL)
for i in range(num_iter_als):
it += 1
s = time.time()
t_ccd.begin()
X = opt.step(regu)
t_ccd.end()
e = time.time()
time_all += e - s
M = tenpy.TTTP(O, X)
ctf.Sparse_add(M, T_in, beta=-1)
rmse = tenpy.vecnorm(M) / (nnz_tot)**0.5
M.set_zero()
if tenpy.is_master_proc():
tenpy.printf("After " + str(it) + " iterations,")
tenpy.printf("RMSE is", rmse)
#print("Full Tensor Objective",(tenpy.norm(tenpy.einsum('ir,jr,kr->ijk',X[0],X[1],X[2])-T)))
if csv_file is not None:
csv_writer.writerow([i, time_all, rmse, i, 'CCD'])
csv_file.flush()
if rmse < tol:
tenpy.printf("Ending algo due to tolerance")
break
end = time.time()
tenpy.printf('ccd time taken is ', end - start)
return X
def run_als(args):
# Set up CSV logging
csv_path = join(results_dir, arg_defs.get_file_prefix(args) + '.csv')
is_new_log = not Path(csv_path).exists()
csv_file = open(csv_path, 'a')
csv_writer = csv.writer(csv_file,
delimiter=',',
quotechar='|',
quoting=csv.QUOTE_MINIMAL)
profiler.do_profile(args.profile)
if args.backend == "numpy":
import backend.numpy_ext as tenpy
elif args.backend == "ctf":
import backend.ctf_ext as tenpy
import ctf
tepoch = ctf.timer_epoch("ALS")
tepoch.begin()
if tenpy.is_master_proc():
for arg in vars(args):
print(arg + ':', getattr(args, arg))
if is_new_log:
csv_writer.writerow([
'iterations', 'time', 'residual', 'fitness', 'flag_dt',
'fitness_diff'
])
tenpy.seed(args.seed)
if args.decomposition == "CP":
return run_als_cpd(args, tenpy, csv_file)
elif args.decomposition == "Tucker":
return run_als_tucker(args, tenpy, csv_file)
elif args.decomposition == "Tucker_simulate":
return run_als_tucker_simulate(args, tenpy, csv_file)
elif args.decomposition == "CP_simulate":
return run_als_cp_simulate(args, tenpy, csv_file)
def run_als(args):
ret_list = []
if args.backend == 'numpy':
import backend.numpy_ext as tenpy
elif args.backend == 'ctf':
import backend.ctf_ext as tenpy
flag_dt = True
R = args.R
s = args.s
res_calc_freq = args.res_calc_freq
csv_path = join(results_dir, get_file_prefix(args) + '.csv')
is_new_log = not Path(csv_path).exists()
csv_file = open(csv_path, 'a')
csv_writer = csv.writer(csv_file,
delimiter=',',
quotechar='|',
quoting=csv.QUOTE_MINIMAL)
if tenpy.is_master_proc():
for arg in vars(args):
print(arg + ':', getattr(args, arg))
if is_new_log:
csv_writer.writerow([
'iterations', 'time', 'residual', 'fitness', 'flag_dt',
'fitness_diff'
])
tenpy.seed(args.seed)
if args.tensor == 'random':
X = tenpy.random((R, s))
Y = tenpy.random((R, s))
Z = tenpy.random((R, s))
T = khatri_rao_product_chain(tenpy, [X, Y, Z])
elif args.tensor == 'random_col':
T = synthetic_tensors.init_const_collinearity_tensor(tenpy,
s,
3,
R,
col=args.col,
seed=args.seed)
elif args.tensor == 'scf':
filename = f'saved-tensors/scf_{args.num_molecule}_mol.npy'
if not os.path.exists(filename):
T = real_tensors.get_scf_tensor(args.num_molecule)
with open(filename, 'wb') as f:
np.save(f, T)
print(f"file {filename} saved.")
assert 0
with open(filename, 'rb') as f:
T = np.load(f)
if tenpy.name() == 'ctf':
T = tenpy.from_nparray(T)
elif args.tensor == "graph":
T = real_tensors.graph_state_5_party(tenpy)
tenpy.printf(f"The shape of the input tensor is: {T.shape}")
X = tenpy.random((R, T.shape[0])) + 1j * tenpy.random((R, T.shape[0]))
Y = tenpy.random((R, T.shape[1])) + 1j * tenpy.random((R, T.shape[1]))
Z = tenpy.random((R, T.shape[2])) + 1j * tenpy.random((R, T.shape[2]))
optimizer_list = {
'DT-quad': quad_als_optimizer(tenpy, T, X, Y),
'PP-quad': quad_pp_optimizer(tenpy, T, X, Y, args),
'DT': als_optimizer(tenpy, T, X, Y, Z, args),
'PP': als_pp_optimizer(tenpy, T, X, Y, Z, args),
}
optimizer = optimizer_list[args.method]
normT = tenpy.vecnorm(T)
time_all = 0.
fitness_old = 0.
if args.backend == 'ctf':
import backend.ctf_ext as tenpy
import ctf
tepoch = ctf.timer_epoch("ALS")
tepoch.begin()
for i in range(args.num_iter):
if args.method == 'PP-quad' or args.method == 'DT-quad':
t0 = time.time()
if args.method == 'PP-quad':
X, Y, pp_restart = optimizer.step()
flag_dt = not pp_restart
else:
X, Y = optimizer.step()
t1 = time.time()
tenpy.printf(f"[ {i} ] Sweep took {t1 - t0} seconds")
time_all += t1 - t0
if (i % res_calc_freq == 0 or i == args.num_iter - 1
or not flag_dt):
res = get_residual(tenpy, optimizer.mttkrp_last_mode,
[X, Y, Y], normT)
fitness = 1 - res / normT
fitness_diff = abs(fitness - fitness_old)
fitness_old = fitness
if tenpy.is_master_proc():
ret_list.append(
[i, time_all, res, fitness, flag_dt, fitness_diff])
print(
f"[ {i} ] Residual is {res}, fitness is: {fitness}, fitness diff is: {fitness_diff}"
)
if csv_file is not None:
csv_writer.writerow(
[i, time_all, res, fitness, flag_dt, fitness_diff])
csv_file.flush()
# check the fitness difference
if (i % res_calc_freq == 0):
if abs(fitness_diff) <= args.stopping_tol * res_calc_freq:
return ret_list, optimizer.num_iters_map, optimizer.time_map, optimizer.pp_init_iter
elif args.method == 'PP' or args.method == 'DT':
t0 = time.time()
if args.method == 'PP':
X, Y, Z, pp_restart = optimizer.step()
flag_dt = not pp_restart
else:
X, Y, Z = optimizer.step()
t1 = time.time()
tenpy.printf(f"[ {i} ] Sweep took {t1 - t0} seconds")
time_all += t1 - t0
if (i % res_calc_freq == 0 or i == args.num_iter - 1
or not flag_dt):
res = tenpy.norm(
T - tenpy.einsum("ka,kb,kc->abc", X, Y, Z)
) #get_residual(tenpy, optimizer.mttkrp_last_mode, [X, Y, Z], normT)
fitness = 1 - res / normT
fitness_diff = abs(fitness - fitness_old)
fitness_old = fitness
if tenpy.is_master_proc():
ret_list.append(
[i, time_all, res, fitness, flag_dt, fitness_diff])
print(
f"[ {i} ] Residual is {res}, fitness is: {fitness}, fitness diff is: {fitness_diff}, timeall is: {time_all}"
)
if csv_file is not None:
csv_writer.writerow(
[i, time_all, res, fitness, flag_dt, fitness_diff])
csv_file.flush()
# check the fitness difference
if (i % res_calc_freq == 0):
if abs(fitness_diff) <= args.stopping_tol * res_calc_freq:
print("timeall", time_all)
return ret_list, optimizer.num_iters_map, optimizer.time_map, optimizer.pp_init_iter
print("timeall", time_all)
if args.backend == "ctf":
tepoch.end()
return ret_list, optimizer.num_iters_map, optimizer.time_map, optimizer.pp_init_iter
ham = return_op(Nx, Ny, sym=None, backend=backend)
else:
ham = return_op(Nx, Ny, sym='Z2', backend=backend)
# Create PEPS
peps = PEPS(Nx,
Ny,
d,
D,
chi,
Zn=Zn,
chi_norm=10,
chi_op=10,
backend=backend,
normalize=False)
# Setup Profiling
profile_fname = 'calc_norm_stats_Nx{}_Ny{}_d{}_D{}_chi{}_Zn{}_{}'.format(
Nx, Ny, d, D, chi, Zn, backend)
if backend == 'ctf':
from ctf import timer_epoch
te = timer_epoch('1')
te.begin()
t0 = time.time()
# Evaluate Operator
cProfile.run('val = peps.calc_norm(chi=chi)', profile_fname)
tf = time.time()
# Print Results
if backend == 'ctf': te.end()
print(tf - t0)
def getPCPGN(tenpy, T_in, T, O, X, reg_GN, num_iter_GN,tol,csv_file):
opt = Poisson_CP_GN_Completer(tenpy, T_in, O, X)
if tenpy.name() == 'ctf':
nnz_tot = T_in.nnz_tot
else:
nnz_tot = np.sum(O)
regu = reg_GN
tenpy.printf("--------------------------------Poisson GN WIth CG-----------------------------")
t_ALS = ctf.timer_epoch("Poisson_GN")
start= time.time()
# T_in = backend.einsum('ijk,ijk->ijk',T,O)
it = 0
time_all = 0
P = T_in.copy()
ctf.Sparse_log(P)
ctf.Sparse_mul(P,T_in)
ctf.Sparse_add(P,T_in,beta=-1)
val2 = ctf.sum(P)
#val2 = ctf.sum(subtract_sparse(elementwise_prod(T_in,elementwise_log(T_in)),T_in))
M = tenpy.TTTP(O,X)
#val = ctf.sum(subtract_sparse(ctf.exp(M),elementwise_prod(T_in,M) ))
P = M.copy()
ctf.Sparse_mul(P,T_in)
ctf.Sparse_exp(M)
#rmse_lsq = tenpy.vecnorm(T_in-M)/(nnz_tot)**0.5
#tenpy.printf("least square RMSE is",rmse_lsq)
ctf.Sparse_add(M,P,beta=-1)
val = ctf.sum(M)
P.set_zero()
M.set_zero()
rmse = (val+val2)/nnz_tot
P.set_zero()
if tenpy.is_master_proc():
tenpy.printf("After " + str(it) + " iterations,")
tenpy.printf("RMSE is",rmse)
if csv_file is not None:
csv_writer = csv.writer(
csv_file, delimiter=',', quotechar='|', quoting=csv.QUOTE_MINIMAL)
for i in range(num_iter_GN):
it+=1
s = time.time()
t_ALS.begin()
X = opt.step(regu)
t_ALS.end()
e = time.time()
time_all+= e- s
#rmse = tenpy.vecnorm(tenpy.TTTP(O,[U,V,W])-T_in)/(nnz_tot)**0.5
M = tenpy.TTTP(O,X)
#val = ctf.sum(subtract_sparse(ctf.exp(M),elementwise_prod(T_in,M) ))
P = M.copy()
ctf.Sparse_mul(P,T_in)
ctf.Sparse_exp(M)
#rmse_lsq = tenpy.vecnorm(T_in-M)/(nnz_tot)**0.5
#tenpy.printf("least square RMSE is",rmse_lsq)
ctf.Sparse_add(M,P,beta=-1)
val = ctf.sum(M)
P.set_zero()
M.set_zero()
rmse = (val+val2)/nnz_tot
regu = regu/2
if tenpy.is_master_proc():
tenpy.printf("After " + str(it) + " iterations,")
tenpy.printf("RMSE is",rmse)
#print("Full Tensor Objective",(tenpy.norm(tenpy.einsum('ir,jr,kr->ijk',U,V,W)-T)))
if csv_file is not None:
csv_writer.writerow([i,time_all , rmse, i,'PGN'])
csv_file.flush()
if abs(rmse) < tol:
tenpy.printf("Ending algo due to tolerance")
break
end= time.time()
end= time.time()
tenpy.printf('Poisson_GN time taken is ',end - start)
return X
fact = args.varying_fact
lower = args.lower
upper = args.upper
diag = args.diag
Arm = args.arm
c = args.c
tau = args.tau
arm_iters=args.arm_iters
if tlib == "numpy":
import backend.numpy_ext as tenpy
elif tlib == "ctf":
import backend.ctf_ext as tenpy
import ctf
tepoch = ctf.timer_epoch("ALS")
tepoch.begin();
if tenpy.is_master_proc():
# print the arguments
for arg in vars(args) :
print( arg+':', getattr(args, arg))
# initialize the csv file
if is_new_log:
csv_writer.writerow([
'iterations', 'time', 'residual', 'fitness'
])
tenpy.seed(args.seed)
if args.load_tensor is not '':
def sgd_poisson(tenpy, T_in, T, O, U, V, W, reg_als, I, J, K, R, num_iter_als,
tol, csv_file):
step_size = 0.03
opt = Poisson_sgd_Completer(tenpy, T_in, O, [U, V, W], step_size)
#if T_in.sp == True:
# nnz_tot = T_in.nnz_tot
#else:
# nnz_tot = ctf.sum(omega)
if tenpy.name() == 'ctf':
nnz_tot = T_in.nnz_tot
else:
nnz_tot = np.sum(O)
t_ALS = ctf.timer_epoch("poisson_sgd")
regu = reg_als
tenpy.printf(
"--------------------------------Poisson_sgd-----------------------")
start = time.time()
# T_in = backend.einsum('ijk,ijk->ijk',T,O)
it = 0
time_all = 0
#val2 = ctf.sum(subtract_sparse(elementwise_prod(T_in,elementwise_log(T_in)),T_in))
P = T_in.copy()
ctf.Sparse_log(P)
ctf.Sparse_mul(P, T_in)
ctf.Sparse_add(P, T_in, beta=-1)
val2 = ctf.sum(P)
P.set_zero()
if csv_file is not None:
csv_writer = csv.writer(csv_file,
delimiter=',',
quotechar='|',
quoting=csv.QUOTE_MINIMAL)
for i in range(num_iter_als):
it += 1
s = time.time()
#t_ALS.begin()
[U, V, W] = opt.step(regu)
#t_ALS.end()
e = time.time()
time_all += e - s
#rmse = tenpy.vecnorm(tenpy.TTTP(O,[U,V,W])-T_in)/(nnz_tot)**0.5
if it % 20 == 0:
M = tenpy.TTTP(O, [U, V, W])
#val = ctf.sum(subtract_sparse(ctf.exp(M),elementwise_prod(T_in,M) ))
P = M.copy()
ctf.Sparse_mul(P, T_in)
ctf.Sparse_exp(M)
ctf.Sparse_add(M, P, beta=-1)
val = ctf.sum(M)
P.set_zero()
M.set_zero()
rmse = (val + val2) / nnz_tot
if tenpy.is_master_proc():
tenpy.printf("After " + str(it) + " iterations, and time is",
time_all)
tenpy.printf("RMSE is", rmse)
#print("Full Tensor Objective",(tenpy.norm(tenpy.einsum('ir,jr,kr->ijk',U,V,W)-T)))
if csv_file is not None:
csv_writer.writerow([i, time_all, rmse, i, 'PALS'])
csv_file.flush()
if abs(rmse) < tol:
tenpy.printf("Ending algo due to tolerance")
break
end = time.time()
tenpy.printf('Poisson sgd time taken is ', end - start)
return [U, V, W]
def getALS_CG(T,
U,
V,
W,
regParam,
omega,
I,
J,
K,
r,
block_size,
num_iter=100,
err_thresh=.001,
time_limit=600,
use_implicit=True):
if use_implicit == True:
t_ALS_CG = ctf.timer_epoch("als_CG_implicit")
if ctf.comm().rank() == 0:
print(
"--------------------------------ALS with implicit CG------------------------"
)
else:
t_ALS_CG = ctf.timer_epoch("als_CG_explicit")
if ctf.comm().rank() == 0:
print(
"--------------------------------ALS with explicit CG------------------------"
)
if T.sp == True:
nnz_tot = T.nnz_tot
else:
nnz_tot = ctf.sum(omega)
t_ALS_CG.begin()
it = 0
if block_size <= 0:
block_size = max(I, J, K)
t_init_error_norm = ctf.timer("ALS_init_error_tensor_norm")
t_init_error_norm.start()
t0 = time.time()
E = ctf.tensor((I, J, K), sp=T.sp)
#E.i("ijk") << T.i("ijk") - omega.i("ijk")*U.i("iu")*V.i("ju")*W.i("ku")
E.i("ijk") << T.i("ijk") - ctf.TTTP(omega, [U, V, W]).i("ijk")
t1 = time.time()
curr_err_norm = ctf.vecnorm(E) + (ctf.vecnorm(U) + ctf.vecnorm(V) +
ctf.vecnorm(W)) * regParam
t2 = time.time()
t_init_error_norm.stop()
if ctf.comm().rank() == 0 and status_prints == True:
print('ctf.TTTP() takes {}'.format(t1 - t0))
print('ctf.vecnorm {}'.format(t2 - t1))
t_before_loop = time.time()
t_obj_calc = 0.
ctf.random.seed(42)
while True:
t_upd_cg = ctf.timer("ALS_upd_cg")
t_upd_cg.start()
U = updateFactor(T, U, V, W, regParam, omega, I, J, K, r, block_size,
"U", use_implicit)
V = updateFactor(T, U, V, W, regParam, omega, I, J, K, r, block_size,
"V", use_implicit)
W = updateFactor(T, U, V, W, regParam, omega, I, J, K, r, block_size,
"W", use_implicit)
duration = time.time() - t_before_loop - t_obj_calc
t_b_obj = time.time()
E.set_zero()
#E.i("ijk") << T.i("ijk") - omega.i("ijk")*U.i("iu")*V.i("ju")*W.i("ku")
E.i("ijk") << T.i("ijk") - ctf.TTTP(omega, [U, V, W]).i("ijk")
diff_norm = ctf.vecnorm(E)
RMSE = diff_norm / (nnz_tot**.5)
next_err_norm = diff_norm + (ctf.vecnorm(U) + ctf.vecnorm(V) +
ctf.vecnorm(W)) * regParam
t_obj_calc += time.time() - t_b_obj
t_upd_cg.stop()
it += 1
if ctf.comm().rank() == 0:
#print("Last residual:",curr_err_norm,"New residual",next_err_norm)
print('Objective after', duration, 'seconds (', it,
'iterations) is: {}'.format(next_err_norm))
print('RMSE after', duration, 'seconds (', it,
'iterations) is: {}'.format(RMSE))
if abs(curr_err_norm - next_err_norm
) < err_thresh or it >= num_iter or duration > time_limit:
break
curr_err_norm = next_err_norm
t_ALS_CG.end()
duration = time.time() - t_before_loop - t_obj_calc
if glob_comm.rank() == 0:
print('ALS (implicit =', use_implicit,
') time per sweep: {}'.format(duration / it))
def run_CCD(T,U,V,W,omega,regParam,num_iter,time_limit,objective_frequency,use_MTTKRP=True):
U_vec_list = []
V_vec_list = []
W_vec_list = []
r = U.shape[1]
for f in range(r):
U_vec_list.append(U[:,f])
V_vec_list.append(V[:,f])
W_vec_list.append(W[:,f])
# print(T)
# T.write_to_file('tensor_out.txt')
# assert(T.sp == 1)
ite = 0
objectives = []
t_before_loop = time.time()
t_obj_calc = 0.
t_CCD = ctf.timer_epoch("ccd_CCD")
t_CCD.begin()
while True:
t_iR_upd = ctf.timer("ccd_init_R_upd")
t_iR_upd.start()
t0 = time.time()
R = ctf.copy(T)
t1 = time.time()
# R -= ctf.einsum('ijk, ir, jr, kr -> ijk', omega, U, V, W)
R -= ctf.TTTP(omega, [U,V,W])
t2 = time.time()
# R += ctf.einsum('ijk, i, j, k -> ijk', omega, U[:,0], V[:,0], W[:,0])
R += ctf.TTTP(omega, [U[:,0], V[:,0], W[:,0]])
t3 = time.time()
t_iR_upd.stop()
t_b_obj = time.time()
if ite % objective_frequency == 0:
duration = time.time() - t_before_loop - t_obj_calc
[objective, RMSE] = get_objective(T,U,V,W,omega,regParam)
objectives.append(objective)
if glob_comm.rank() == 0:
print('Objective after',duration,'seconds (',ite,'iterations) is: {}'.format(objective))
print('RMSE after',duration,'seconds (',ite,'iterations) is: {}'.format(RMSE))
t_obj_calc += time.time() - t_b_obj
if glob_comm.rank() == 0 and status_prints == True:
print('ctf.copy() takes {}'.format(t1-t0))
print('ctf.TTTP() takes {}'.format(t2-t1))
print('ctf.TTTP() takes {}'.format(t3-t2))
for f in range(r):
# update U[:,f]
if glob_comm.rank() == 0 and status_prints == True:
print('updating U[:,{}]'.format(f))
t0 = time.time()
if use_MTTKRP:
alphas = ctf.tensor(R.shape[0])
#ctf.einsum('ijk -> i', ctf.TTTP(R, [None, V_vec_list[f], W_vec_list[f]]),out=alphas)
ctf.MTTKRP(R, [alphas, V_vec_list[f], W_vec_list[f]], 0)
else:
alphas = ctf.einsum('ijk, j, k -> i', R, V_vec_list[f], W_vec_list[f])
t1 = time.time()
if use_MTTKRP:
betas = ctf.tensor(R.shape[0])
#ctf.einsum('ijk -> i', ctf.TTTP(omega, [None, V_vec_list[f]*V_vec_list[f], W_vec_list[f]*W_vec_list[f]]),out=betas)
ctf.MTTKRP(omega, [betas, V_vec_list[f]*V_vec_list[f], W_vec_list[f]*W_vec_list[f]], 0)
else:
betas = ctf.einsum('ijk, j, j, k, k -> i', omega, V_vec_list[f], V_vec_list[f], W_vec_list[f], W_vec_list[f])
t2 = time.time()
U_vec_list[f] = alphas / (regParam + betas)
U[:,f] = U_vec_list[f]
if glob_comm.rank() == 0 and status_prints == True:
print('ctf.einsum() takes {}'.format(t1-t0))
print('ctf.einsum() takes {}'.format(t2-t1))
# update V[:,f]
if glob_comm.rank() == 0 and status_prints == True:
print('updating V[:,{}]'.format(f))
if use_MTTKRP:
alphas = ctf.tensor(R.shape[1])
#ctf.einsum('ijk -> j', ctf.TTTP(R, [U_vec_list[f], None, W_vec_list[f]]),out=alphas)
ctf.MTTKRP(R, [U_vec_list[f], alphas, W_vec_list[f]], 1)
else:
alphas = ctf.einsum('ijk, i, k -> j', R, U_vec_list[f], W_vec_list[f])
if use_MTTKRP:
betas = ctf.tensor(R.shape[1])
#ctf.einsum('ijk -> j', ctf.TTTP(omega, [U_vec_list[f]*U_vec_list[f], None, W_vec_list[f]*W_vec_list[f]]),out=betas)
ctf.MTTKRP(omega, [U_vec_list[f]*U_vec_list[f], betas, W_vec_list[f]*W_vec_list[f]], 1)
else:
betas = ctf.einsum('ijk, i, i, k, k -> j', omega, U_vec_list[f], U_vec_list[f], W_vec_list[f], W_vec_list[f])
V_vec_list[f] = alphas / (regParam + betas)
V[:,f] = V_vec_list[f]
if glob_comm.rank() == 0 and status_prints == True:
print('updating W[:,{}]'.format(f))
if use_MTTKRP:
alphas = ctf.tensor(R.shape[2])
#ctf.einsum('ijk -> k', ctf.TTTP(R, [U_vec_list[f], V_vec_list[f], None]),out=alphas)
ctf.MTTKRP(R, [U_vec_list[f], V_vec_list[f], alphas], 2)
else:
alphas = ctf.einsum('ijk, i, j -> k', R, U_vec_list[f], V_vec_list[f])
if use_MTTKRP:
betas = ctf.tensor(R.shape[2])
#ctf.einsum('ijk -> k', ctf.TTTP(omega, [U_vec_list[f]*U_vec_list[f], V_vec_list[f]*V_vec_list[f], None]),out=betas)
ctf.MTTKRP(omega, [U_vec_list[f]*U_vec_list[f], V_vec_list[f]*V_vec_list[f], betas], 2)
else:
betas = ctf.einsum('ijk, i, i, j, j -> k', omega, U_vec_list[f], U_vec_list[f], V_vec_list[f], V_vec_list[f])
W_vec_list[f] = alphas / (regParam + betas)
W[:,f] = W_vec_list[f]
t_tttp = ctf.timer("ccd_TTTP")
t_tttp.start()
R -= ctf.TTTP(omega, [U_vec_list[f], V_vec_list[f], W_vec_list[f]])
if f+1 < r:
R += ctf.TTTP(omega, [U_vec_list[f+1], V_vec_list[f+1], W_vec_list[f+1]])
t_tttp.stop()
t_iR_upd.stop()
ite += 1
if ite == num_iter or time.time() - t_before_loop - t_obj_calc > time_limit:
break
t_CCD.end()
duration = time.time() - t_before_loop - t_obj_calc
[objective, RMSE] = get_objective(T,U,V,W,omega,regParam)
if glob_comm.rank() == 0:
print('CCD amortized seconds per sweep: {}'.format(duration/ite))
print('Time/CCD Iteration: {}'.format(duration/ite))
print('Objective after',duration,'seconds (',ite,'iterations) is: {}'.format(objective))
print('RMSE after',duration,'seconds (',ite,'iterations) is: {}'.format(RMSE))
