def prepare_bath_hamilts(para):
print('Starting iDMRG for the entanglement bath')
bath_data = opath.join(para['bath_path'], para['bath_exp'])
if para['if_load_bath'] and opath.isfile(bath_data):
print('Bath data found. Load the bath.')
bath, ob0, hamilt = load_pr(bath_data, ['A', 'ob0', 'hamilt'])
else:
print('Bath data not found. Calculate bath by iDMRG.')
hamilt = hamiltonian_heisenberg(para['spin'], para['jxy'], para['jxy'],
para['jz'], para['hx'] / 2,
para['hz'] / 2)
bath, ob0 = dmrg_infinite_size(para, hamilt=hamilt)[:2]
save_pr(para['bath_path'], para['bath_exp'], [bath, ob0, hamilt],
['A', 'ob0', 'hamilt'])
if (bath.is_symme_env is True) and (bath.dmrg_type is 'mpo'):
bath.env[1] = bath.env[0]
print('Preparing the physical-bath Hamiltonians')
qes = QES_1D(para['d'], para['chi'], para['d'] * para['d'], para['l_phys'],
para['tau'])
if bath.dmrg_type is 'mpo':
qes.obtain_physical_gate_tensors(hamilt)
qes.obtain_bath_h(bath.env, 'both')
else:
qes.obtain_bath_h_by_effective_ops_1d(bath.bath_op_onsite,
bath.effective_ops,
bath.hamilt_index)
hamilts = [hamilt] + qes.hamilt_bath
return hamilts, bath, ob0
def get_sequence(gtn, num_f, param, order_way):
if order_way is 'SequencedMeasure':
order_file = os.path.join(param['data_path'],
'Order_' + param['save_exp'])
if os.path.isfile(order_file):
order = load_pr(order_file, 'order')
else:
order = gtn.mps.markov_measurement(if_restore=True)[0]
save_pr(param['data_path'], 'Order_' + param['save_exp'], [order],
['order'])
order_now = copy.copy(order[:num_f])
elif order_way is 'MaxSEE':
ent = gtn.mps.calculate_onsite_reduced_density_matrix()[0]
order = np.argsort(ent)[::-1]
order_now = copy.copy(order[:num_f])
elif order_way is 'Variance':
tmp = TNmachineLearning.MachineLearningFeatureMap(
param['d'], param['dataset'])
tmp.load_data()
tmp.select_samples([param['class']])
variance = tmp.variance_pixels()
order = np.argsort(variance)[::-1]
order_now = copy.copy(order[:num_f])
elif order_way is 'RandomMeasure':
order = np.random.permutation(gtn.length)
order_now = copy.copy(order[:num_f])
else:
order = None
order_now = None
return order, order_now
def get_marked_imgs(gtn, imgs_test, num_f, sample, param, order_way):
if order_way is 'SequencedMeasure':
order_file = os.path.join(param['data_path'], 'Order_' + param['save_exp'])
if os.path.isfile(order_file):
order = load_pr(order_file, 'order')
else:
order = gtn.mps.markov_measurement(if_restore=True)[0]
save_pr(para['data_path'], 'Order_' + para['save_exp'], [order], ['order'])
order_now = copy.copy(order.reshape(-1,)[:num_f])
elif order_way is 'MaxSEE':
ent = gtn.mps.calculate_onsite_reduced_density_matrix()[0]
order = np.argsort(ent)[::-1]
order_now = copy.copy(order.reshape(-1,)[:num_f])
elif order_way is 'Variance':
tmp = TNmachineLearning.MachineLearningFeatureMap(param['d'], param['dataset'])
tmp.load_data()
tmp.select_samples([param['class']])
variance = tmp.variance_pixels()
order = np.argsort(variance)[::-1]
order_now = copy.copy(order.reshape(-1,)[:num_f])
elif order_way is 'RandomMeasure':
order = np.random.permutation(gtn.length)
order_now = copy.copy(order.reshape(-1,)[:num_f])
else:
order = None
order_now = None
img_part = imgs_test.images.copy()[order_now, sample]
img_new = gtn.generate_features(img_part, pos=order_now, f_max=1, f_min=0,
is_display=False, way=generate_way)
img_new = img_new.reshape(imgs_test.img_size)
marked_img = imgs_test.mark_pixels_on_full_image(img_new, order_now)
return imgs_test.images[:, sample].reshape(imgs_test.img_size), img_new, marked_img, order
def gcmpm_one_class(para=None):
if para is None:
para = pm.parameters_gcmpm_one_class()
para['save_exp'] = save_exp_gcmpm_one_class(para)
if para['parallel'] is True:
par_pool = para['n_nodes']
else:
par_pool = None
if para['if_load'] and os.path.isfile(para['save_exp']):
a = bf.load_pr(os.path.join(para['data_path'], para['save_exp']), 'a')
else:
a = TNmachineLearning.MachineLearningMPS(para['d'], para['chi'], para['dataset'],
par_pool=par_pool)
a.images2vecs([para['class']], [100])
a.initialize_virtual_vecs_train()
a.update_virtual_vecs_train('all', 'all', 'both')
a.mps.correct_orthogonal_center(0, normalize=True)
a.mps.mps[0] /= np.linalg.norm(a.mps.mps[0].reshape(-1, ))
mps0 = a.mps.mps.copy()
for t in range(0, para['sweep_time']):
# from left to right
if para['if_print_detail']:
print('At the ' + str(t) + '-th sweep, from left to right')
for nt in range(0, a.length):
a.update_tensor_gradient(nt, para['step'])
if nt != a.length-1:
a.update_virtual_vecs_train('all', nt, 'left')
# from left to right
print('At the ' + str(t) + '-th sweep, from right to left')
for nt in range(a.length-1, -1, -1):
a.update_tensor_gradient(nt, para['step'])
if nt != 0:
a.update_virtual_vecs_train('all', nt, 'right')
if t > para['check_time0'] and ((t+1) % para['check_time'] == 0
or t+1 == para['sweep_time']):
fid = ln_fidelity_per_site(mps0, a.mps.mps)
if fid < (para['step'] * para['ratio_step_tol']):
print('After ' + str(t+1) + ' sweeps: fid = %g' % fid)
para['step'] *= para['step_ratio']
elif t+1 == para['sweep_time']:
print('After all ' + str(t+1) + ' sweeps finished, fid = %g. '
'Consider to increase the sweep times.' % fid)
else:
print('After ' + str(t+1) + ' sweeps, fid = %g.' % fid)
mps0 = a.mps.mps.copy()
if para['step'] < para['step_min']:
print('Now step = ' + str(para['step']) + ' is sufficiently small. Break the loop')
break
else:
print('Now step = ' + str(para['step']))
if para['if_save']:
save_pr(para['data_path'], para['save_exp'], [a, para], ['a', 'para'])
return a, para
def gcmpm(para_tot=None):
print('Preparing parameters')
if para_tot is None:
para_tot = pm.parameters_gcmpm()
n_class = len(para_tot['classes'])
paras = bf.empty_list(n_class)
for n in range(0, n_class):
paras[n] = para_tot.copy()
paras[n]['class'] = para_tot['classes'][n]
paras[n]['chi'] = para_tot['chi'][n]
paras[n]['save_exp'] = save_exp_gcmpm_one_class(paras[n])
classifiers = bf.empty_list(n_class)
for n in range(0, n_class):
data = '../data_tnml/gcmpm/' + paras[n]['save_exp']
if para_tot['if_load'] and os.path.isfile(data):
print('The classifier already exists. Load directly')
classifiers[n] = load_pr(data, 'classifier')
else:
print('Training the MPS of ' + str(para_tot['classes'][n]))
classifiers[n] = gcmpm_one_class(paras[n])[0]
if para_tot['if_save']:
save_pr('../data_tnml/gcmpm/', paras[n]['save_exp'],
[classifiers[n]], ['classifier'])
# Testing accuracy
print('Calculating the testing accuracy')
labels = para_tot['classes']
b = TNmachineLearning.MachineLearningFeatureMap('MNIST', para_tot['d'],
file_sample='t10k-images.idx3-ubyte',
file_label='t10k-labels.idx1-ubyte')
b.images2vecs(para_tot['classes'], ['all', 'all'])
fid = np.zeros((n_class, ))
num_wrong = 0
for ni in range(0, b.numVecSample):
for n in range(0, n_class):
fid[n] = b.fidelity_mps_image(classifiers[n].mps.mps, ni)
n_max = int(np.argmax(fid))
if labels[n_max] != b.LabelNow[ni]:
num_wrong += 1
accuracy = num_wrong/b.numVecSample
print(accuracy)
print('Train the generative TN')
a, para_gtn = gtn_one_class(para)
if var_name is 'which_class':
b.load_data(data_path='..\\..\\..\\MNIST\\' + para['dataset'] + '\\',
file_sample='t10k-images.idx3-ubyte',
file_label='t10k-labels.idx1-ubyte', is_normalize=True)
b.select_samples([para['class']])
if select_way is 'SequencedMeasure':
print('Calculate the sequence of the measurements')
order_file = os.path.join(para['data_path'], 'Order_'+para['save_exp'])
if (not is_order_calculated) and os.path.isfile(order_file):
order = load_pr(order_file, 'order')
else:
order = a.mps.markov_measurement(if_restore=True)[0]
save_pr(para['data_path'], 'Order_'+para['save_exp'], [order], ['order'])
order_now = copy.copy(order.reshape(-1, )[:num_features])
is_order_calculated = True
elif select_way is 'MaxSEE':
if not is_order_calculated:
ent = a.mps.calculate_onsite_reduced_density_matrix()[0]
order = np.argsort(ent)[::-1]
is_order_calculated = True
order_now = copy.copy(order.reshape(-1, )[:num_features])
elif select_way is 'Variance':
if not is_order_calculated:
variance = b.variance_pixels()
order = np.argsort(variance)[::-1]
is_order_calculated = True
order_now = copy.copy(order.reshape(-1, )[:num_features])
else:
nj = len(j)
nh = len(h)
for n1 in range(0, nj):
for n2 in range(0, nh):
para['jz'] = j[n1]
para['hz'] = h[n2]
para = pm.make_consistent_parameter_dmrg(para)
# Run DMRG
if path.isfile(
path.join(para['data_path'], para['data_exp'] + '.pr')):
print('Load existing data ...')
a = load_pr(
path.join(para['data_path'], para['data_exp'] + '.pr'),
'a')
else:
print('Start DMRG calculation ...')
ob, a, info, para = dmrg.dmrg_finite_size(para)
save_pr(para['data_path'], para['data_exp'] + '.pr',
(ob, a, info, para), ('ob', 'a', 'info', 'para'))
print('The entanglement gap is ' +
str((a.lm[n_mid][0] - a.lm[n_mid][1]) / a.lm[n_mid][0]))
if (a.lm[n_mid][0] - a.lm[n_mid][1]) / a.lm[n_mid][0] < tol:
exp_image = 'Phase1_' + para['data_exp']
else:
exp_image = 'Phase2_' + para['data_exp']
state = a.full_coefficients_mps()
image = Qubism.state2image(state * 256, para['d'], is_rescale=True)
# image = Image.fromarray(image.astype(np.uint8))
image = Qubism.image2rgb(image, if_rescale_1=False)
image.save(path.join(para['image_path'], exp_image + '.jpg'))
def qes_1d_ed(para=None):
if para is None:
para = parameter_qes_by_ed()
print('Starting iDMRG for the entanglement bath')
bath_data = opath.join(para['bath_path'], para['bath_exp'])
if para['if_load_bath'] and opath.isfile(bath_data):
print('Bath data found. Load the bath.')
bath, ob0, hamilt = load_pr(bath_data, ['A', 'ob0', 'hamilt'])
else:
print('Bath data not found. Calculate bath by iDMRG.')
hamilt = hamiltonian_heisenberg(para['spin'], para['jxy'], para['jxy'],
para['jz'], para['hx'] / 2,
para['hz'] / 2)
bath, ob0 = dmrg_infinite_size(para, hamilt=hamilt)[:2]
save_pr(para['bath_path'], para['bath_exp'], [bath, ob0, hamilt],
['A', 'ob0', 'hamilt'])
if (bath.is_symme_env is True) and (bath.dmrg_type is 'mpo'):
bath.env[1] = bath.env[0]
print('Preparing the physical-bath Hamiltonians')
qes = QES_1D(para['d'], para['chi'], para['d'] * para['d'], para['l_phys'],
para['tau'])
if bath.dmrg_type is 'mpo':
qes.obtain_physical_gate_tensors(hamilt)
qes.obtain_bath_h(bath.env, 'both')
else:
qes.obtain_bath_h_by_effective_ops_1d(bath.bath_op_onsite,
bath.effective_ops,
bath.hamilt_index)
print('Starting ED for the entanglement bath')
dims = [para['d'] for _ in range(para['l_phys'])]
dims = [para['chi']] + dims + [para['chi']]
hamilts = [hamilt] + qes.hamilt_bath
ob = dict()
solver = EDbasic(dims)
heff = LinearOp((solver.dim_tot, solver.dim_tot),
lambda x: solver.project_all_hamilt(
x, hamilts, para['tau'], para['couplings']))
ob['e_eig'], solver.v = eigs(heff,
k=1,
which='LM',
v0=solver.v.reshape(-1, ).copy())
solver.is_vec = True
ob['e_eig'] = (1 - ob['e_eig']) / para['tau']
ob['mx'], ob['mz'] = solver.observe_magnetizations(para['phys_sites'])
ob['eb'] = solver.observe_bond_energies(
hamilt, para['positions_h2'][1:para['num_h2'] - 1, :])
ob['lm'] = solver.calculate_entanglement()
ob['ent'] = entanglement_entropy(ob['lm'])
ob['e_site'] = sum(ob['eb']) / (para['l_phys'] - 1)
ob['corr_xx'] = solver.observe_correlations(para['pos4corr'],
para['op'][1])
ob['corr_zz'] = solver.observe_correlations(para['pos4corr'],
para['op'][3])
for n in range(para['pos4corr'].shape[0]):
p1 = para['pos4corr'][n, 0] - 1
p2 = para['pos4corr'][n, 1] - 1
ob['corr_xx'][n] -= ob['mx'][p1] * ob['mx'][p2]
ob['corr_zz'][n] -= ob['mz'][p1] * ob['mz'][p2]
return bath, solver, ob0, ob
def quantum_jpeg(para_tot=None):
if para_tot is None:
para_tot = parameters_qjpg()
print('Preparing image')
exp = expression_save(para_tot)
exp = os.path.join(para_tot['data_path'], exp)
if os.path.isfile(exp) and para_tot['if_load']:
a, generator = load_pr(exp, ['a', 'mps'])
else:
a = qjpg(file=para_tot['file'],
b_size=para_tot['block_size'],
is_grey=True)
a.cut2blocks()
a.dct_blocks()
a.pre_process_data_before_ml(which=2)
para = parameters_gtn_one_class()
para['chi'] = para_tot['chi']
para['dataset'] = 'custom'
para['if_save'] = False
para['if_load'] = False
para['dct'] = False
generator = None
if 'real' in para_tot['tasks']:
print('Train in the real space')
for n in range(para_tot['reorder_time']):
generator = gtn_one_class(para=para,
images=a.blocks.squeeze())[0]
if n != (para_tot['reorder_time'] - 1):
order = generator.mps.markov_measurement(
if_restore=False)[0]
# ent = generator.mps.calculate_single_entropy()[0]
# order = np.argsort(ent)[::-1]
a.reorder_features(order, which=0)
if 'freq' in para_tot['tasks']:
for n in range(para_tot['reorder_time']):
print('Train in the frequency space： reorder time = ' + str(n))
generator = gtn_one_class(para=para,
images=a.blocks_dct.squeeze())[0]
if n != (para_tot['reorder_time'] - 1):
order = generator.mps.markov_measurement(
if_restore=False)[0]
# ent = generator.mps.calculate_single_entropy()[0]
# order = np.argsort(ent)[::-1]
a.reorder_features(order, which=1)
save_pr(para_tot['data_path'], exp, [a, generator, para_tot],
['a', 'mps', 'para_tot'])
# a.show_image()
if 'recover' in para_tot['tasks']:
blocks = a.encode_with_cutoff_dct(para_tot['pixel_cutoff'])
image_gtn1 = decode_with_generative_mps(blocks, generator)
image_cutoff = decode_with_cutoff_dct(blocks)
blocks_jpg = a.encode_standard_jpeg(para_tot['pixel_cutoff'])
image_jpg = decode_jpeg(blocks_jpg)
io.imsave('../data_QJPG/before.jpg', a.image.squeeze())
io.imsave('../data_QJPG/0cut.jpg', image_cutoff.squeeze())
io.imsave('../data_QJPG/1JPGway.jpg', image_jpg.squeeze())
io.imsave('../data_QJPG/2GTNway.jpg', image_gtn1.squeeze())
p1 = psnr(a.image0, image_jpg)
p2 = psnr(a.image0, image_cutoff)
p3 = psnr(a.image0, image_gtn1)
print('The PSNRs for jpg, cut-off, and gtn are %g, %g, and %g' %
(p1, p2, p3))
para_dmps['num_layers'] = 1
para_dmps['chi_overlap'] = 256
para_dmps['theta'] = 0
para_dmps['num_theta'] = 1
for n in range(num_len):
print('var_para = ' + str(length[n]))
para_dmrg['l'] = int(length[n])
para_dmrg = Pm.make_consistent_parameter_dmrg(para_dmrg)
if path.isfile(path.join(para_dmrg['data_path'], para_dmrg['data_exp'] + '.pr')):
print('Load existing MPS data ...')
a, ob = load_pr(path.join(para_dmrg['data_path'], para_dmrg['data_exp'] + '.pr'), ['a', 'ob'])
else:
ob, a, info, para_dmrg = dmrg_finite_size(para_dmrg)
save_pr(para_dmrg['data_path'], para_dmrg['data_exp'] + '.pr', (ob, a, info, para_dmrg),
('ob', 'a', 'info', 'para'))
print('Energy per site = ' + str(ob['e_per_site']))
a.calculate_entanglement_spectrum()
a.calculate_entanglement_entropy()
ent0_mid[n] = a.ent[round(a.length/2)]
fid_ini[n] = a.fidelity_log_to_product_state()
# print('Mid entanglement entropy and fid0 = %.12g, %.12g' % (ent0_mid, fid_ini))
save_path = path.join(para_dmrg['project_path'], 'data_dMPS/')
save_exp = 'UMPO_layer' + str(para_dmps['num_layers']) + para_dmrg['data_exp'] + '.pr'
if path.isfile(path.join(save_path, save_exp)):
print('Load existing MPO data ...')
mpo, fid_tmp = load_pr(path.join(save_path, save_exp), ['mpo', 'fid'])
else:
fid_tmp, _, _, mpo, _ = deep_mps_qubit(a, para_dmps)
def gtn_one_class(para=None, images=None, labels=None):
if 'to_black_and_white' not in para:
para['to_black_and_white'] = False
if para is None:
para = pm.parameters_gtn_one_class()
para['save_exp'] = save_exp_gtn_one_class(para)
if para['if_load'] and os.path.isfile(
os.path.join(para['data_path'], para['save_exp'])):
a = bf.load_pr(os.path.join(para['data_path'], para['save_exp']), 'a')
else:
a = TNmachineLearning.MachineLearningMPS(para['d'], para['chi'],
para['dataset'])
if para['dataset'] is 'custom':
a.input_data(copy.deepcopy(images), copy.deepcopy(labels))
else:
a.load_data()
if a.is_there_labels:
a.select_samples([para['class']])
if para['to_black_and_white']:
a.to_black_and_white()
if para['dct'] is True:
a.dct(shift=para['shift'], factor=para['factor'])
a.images2vecs(theta_max=para['theta'] * np.pi / 2)
a.initial_mps(center=0, ini_way='1')
a.initialize_virtual_vecs_train()
a.mps.correct_orthogonal_center(0)
a.update_tensor_gradient(0, para['step'])
nll0 = a.compute_nll()
step = copy.deepcopy(para['step'])
print('Iniitially, NLL = ' + str(nll0))
for t in range(0, para['sweep_time']):
# from left to right
if para['if_print_detail']:
print('At the ' + str(t + 1) + '-th sweep, from left to right')
t0 = time.time()
tt0 = time.clock()
for nt in range(0, a.length):
a.mps.correct_orthogonal_center(nt)
if nt != 0:
a.update_virtual_vecs_train(nt - 1, 'left')
a.update_tensor_gradient(nt, step)
# from right to left
if para['if_print_detail']:
print('At the ' + str(t + 1) + '-th sweep, from right to left')
for nt in range(a.length - 1, -1, -1):
a.mps.correct_orthogonal_center(nt)
if nt != a.length - 1:
a.update_virtual_vecs_train(nt + 1, 'right')
a.update_tensor_gradient(nt, step)
if para['if_print_detail']:
print('Wall time cost for one loop: %s' % (time.time() - t0))
print('CPU time cost for one loop: %s' % (time.clock() - tt0))
if t > (para['check_time0'] - 2) and (
(t + 1) % para['check_time'] == 0
or t + 1 == para['sweep_time']):
nll = a.compute_nll()
print('NLL = ' + str(nll))
# fid = fidelity_per_site(mps0, a.mps.mps)
fid = abs(nll - nll0) / nll0
if fid < (step * para['step_ratio']):
print('After ' + str(t + 1) + ' sweeps: fid = %g' % fid)
step *= para['step_ratio']
# mps0 = copy.deepcopy(a.mps.mps)
nll0 = nll
elif t + 1 == para['sweep_time']:
print('After all ' + str(t + 1) +
' sweeps finished, fid = %g. '
'Consider to increase the sweep times.' % fid)
else:
print('After ' + str(t + 1) + ' sweeps, fid = %g.' % fid)
# mps0 = copy.deepcopy(a.mps.mps)
nll0 = nll
if step < para['step_min']:
print('Now step = ' + str(step) +
' is sufficiently small. Break the loop')
break
else:
print('Now step = ' + str(step))
a.clear_before_save()
if para['if_save']:
save_pr(para['data_path'], para['save_exp'], [a, para],
['a', 'para'])
return a, para
def labeled_gtn(para):
if para is None:
para = pm.parameters_labeled_gtn()
para['save_exp'] = save_exp_labeled_gtn(para)
if para['parallel'] is True:
par_pool = para['n_nodes']
else:
par_pool = None
# Preparing testing dataset
b = TNmachineLearning.MachineLearningFeatureMap(
para['d'],
file_sample='t10k-images.idx3-ubyte',
file_label='t10k-labels.idx1-ubyte')
b.load_data()
b.select_samples(para['classes'])
b.add_labels_to_images()
b.images2vecs(para['theta'])
data_file = os.path.join(para['data_path'], para['save_exp'])
if para['if_load'] and os.path.isfile(data_file):
print('Data exist. Load directly.')
a = bf.load_pr(data_file, 'a')
else:
a = TNmachineLearning.MachineLearningMPS(para['d'],
para['chi'],
para['dataset'],
par_pool=par_pool)
a.load_data()
a.select_samples(para['classes'])
a.add_labels_to_images()
a.images2vecs(para['theta'] * np.pi / 2)
a.initial_mps()
a.mps.correct_orthogonal_center(0, normalize=True)
a.initialize_virtual_vecs_train()
a.update_virtual_vecs_train_all_tensors('both')
accuracy0 = 0
for t in range(0, para['sweep_time']):
# from left to right
for nt in range(0, a.length):
a.update_tensor_gradient(nt, para['step'])
if nt != a.length - 1:
a.update_virtual_vecs_train(nt, 'left')
# from left to right
for nt in range(a.length - 1, -1, -1):
a.update_tensor_gradient(nt, para['step'])
if nt != 0:
a.update_virtual_vecs_train(nt, 'right')
if t > para['check_time0'] and ((t + 1) % para['check_time'] == 0
or t + 1 == para['sweep_time']):
b.input_mps(a.mps)
accuracy = b.calculate_accuracy()
print('After the ' + str(t) +
'-th sweep, the testing accuracy = ' + str(accuracy))
if abs(accuracy - accuracy0) < (para['step'] *
para['ratio_step_tol']):
para['step'] *= para['step_ratio']
accuracy0 = accuracy
print('Converged. Reduce the gradient step to ' +
str(para['step']))
elif t + 1 == para['sweep_time']:
print('After all ' + str(t + 1) +
' sweeps finished, not converged. '
'Consider to increase the sweep times.')
else:
accuracy0 = accuracy
if para['step'] < para['step_min']:
print('Now step = ' + str(para['step']) +
' is sufficiently small. Break the loop')
break
else:
print('Now step = ' + str(para['step']))
a.clear_before_save()
if para['if_save']:
save_pr(para['data_path'], para['save_exp'], [a, para],
['a', 'para'])
accuracy = b.calculate_accuracy()
print('The final testing accuracy = ' + str(accuracy))
return a, para
para['hz'], para['chi']) + para['bound_cond']
para['index1'] = np.mat(np.arange(0, para['l']))
para['index1'] = np.vstack((para['index1'], 6 * np.ones((1, para['l'])))).T.astype(int)
para['index2'] = hm.interactions_position2full_index_heisenberg_two_body(para['positions_h2'])
para['coeff1'] = np.ones((para['l'], 1))
para['coeff2'] = np.ones((para['positions_h2'].shape[0]*3, 1))
for n in range(0, para['positions_h2'].shape[0]):
para['coeff2'][n * 3, 0] = para['jxy']
para['coeff2'][n * 3 + 1, 0] = para['jxy']
para['coeff2'][n * 3 + 2, 0] = para['jz']
else:
from library.Parameters import generate_parameters_dmrg
para = generate_parameters_dmrg()
data_full_name = para['data_path'] + para['data_exp'] + '.pr'
save_pr('.\\para_dmrg\\', '_para.pr', (para,), ('para',))
print('The parameter have been saved as ' + colored('.\\para_dmrg\_para.pr', 'green'))
print_sep('Start DMRG simulation')
if is_load_data and o_path.isfile(data_full_name) and (para['lattice'] in ('chain', 'square')):
print('The data exists in ' + para['data_path'].rstrip("\\") + '. Load directly...')
ob, A = load_pr(data_full_name, ('ob', 'A'))
else:
ob, A, info, para = dmrg_finite_size(para)
save_pr(para['data_path'], para['data_exp'] + '.pr', (ob, A, info, para), ('ob', 'A', 'info', 'para'))
print('The data have been saved in ' + colored(para['data_path'].rstrip("\\"), 'green'))
print_sep('DMRG simulation finished')
if is_from_input:
end_plot = False
while not end_plot:
