def initial_ipeps(self): dim = (self.d, ) + (self.chi, ) * self.nVirtual if self.iniWay is 'random': tensor = tm.symmetrical_rand_peps_tensor(self.d, self.chi, self.nVirtual) if self.stateType is 'mixed': bond = (self.d0, self.d0) + (self.chi, ) * self.nVirtual tensor = tensor.reshape(bond) ind = (1, 0) + tuple(range(2, self.nVirtual + 2)) tensor = (tensor + tensor.transpose(ind)) / 2 bond = (self.d, ) + (self.chi, ) * self.nVirtual tensor = tensor.reshape(bond) for n in range(0, self.nTensor): self.tensors[n] = tensor.copy() elif self.iniWay is 'ones': for n in range(0, self.nTensor): self.tensors[n] = np.ones(dim) elif self.iniWay is 'id': if self.stateType is 'mixed': if self._is_debug: if abs(self.d0**2 - self.d) > 1e-10: bf.print_error('For mixed state, d should be as d0^2. ' 'Check self.d or self.stateType') for n in range(0, self.nTensor): self.tensors[n] = np.eye( self.d0).reshape((self.d, ) + (1, ) * self.nVirtual) else: bf.print_error('Initial way "id" is only for thermal states')
def decision_mps(para=None): if para is None: para = pm.parameters_decision_mps() a = TNmachineLearning.DecisionTensorNetwork( para['dataset'], 2, para['chi'], 'mps', para['classes'], para['numbers'], if_reducing_samples=para['if_reducing_samples']) a.images2vecs_test_samples(para['classes']) print(a.vLabel) for n in range(0, a.length): bf.print_sep() print('Calculating the %i-th tensor' % n) a.update_tensor_decision_mps_svd(n) # a.update_tensor_decision_mps_svd_threshold_algo(n) # a.update_tensor_decision_mps_gradient_algo(n) a.update_v_ctr_train(n) a.calculate_intermediate_accuracy_train(n) if a.remaining_samples_train.__len__() == 0: print('All samples are classified correctly. Training stopped.') break print('The current accuracy = %g' % a.intermediate_accuracy_train[n]) print('Entanglement: ' + str(a.lm[n].reshape(1, -1))) if para['if_reducing_samples']: print('Number of remaining samples: ' + str(a.remaining_samples_train.__len__()))
def show_image(self, n): # n can be a number or an image if type(n) is int: l_side = int(np.sqrt(self.length)) bf.plot_surf(np.arange(0, l_side), np.arange(0, l_side), self.images[:, n].reshape(l_side, l_side)) else: l_side = n.shape[0] bf.plot_surf(np.arange(0, l_side), np.arange(0, l_side), n)
def __init__(self, lattice, chi, state_type='pure', spin='half', ini_way='random', operators=None, is_symme_env=True, is_debug=False): PepsBasic.__init__(self) """ Order of bonds: (phys, virtual, virtual, ...) Lattices: 'honeycomb0' lattice: n-th virtual bond, n-th lambda 0,lm0 1,lm1 \ / - 2,lm2 - / \ 1,lm1 0,lm0 """ self.lattice = lattice self.stateType = state_type # pure or mixed self.spin = spin self.d0 = from_spin2phys_dim(spin) self.chi = chi self.nTensor = 0 self.nLm = 0 self.nVirtual = 0 self.pos_lm = list() self.lm_ten_bond = None self.iniWay = ini_way self._is_debug = is_debug if self.stateType is 'mixed': self.d = self.d0**2 else: self.d = self.d0 self.initial_lattice() self.tensors = bf.empty_list(self.nTensor) self.lm = bf.empty_list(self.nLm) self.initial_ipeps() self.initial_lm() if operators is None: op_half = spin_operators(spin) self.operators = [ op_half['id'], op_half['sx'], op_half['sy'], op_half['sz'], op_half['su'], op_half['sd'] ] else: self.operators = operators # Below is for tree DMRG self.is_symme_env = is_symme_env self.env = None self.model_related = dict()
def check_consistency(self): if self.dataInfo['NumTotalTrain'] != sum(self.dataInfo['nClassNum']): bf.print_error('The total number in the dataset is NOT consistent ' 'with the sum of the samples of all classes') for n in range(0, self.dataInfo['NumClass']): start = self.dataInfo['nStart'][n] end = start + self.dataInfo['nClassNum'][n] tmp = self.labels[start:end] if not np.prod(tmp == tmp[0]): bf.print_error('In the ' + str(tmp[0]) + '-th labels, not all labels are ' + str(tmp[0])) print(bf.arg_find_array(tmp != tmp[0]))
def rho_one_body_simple(self, which_t): if which_t is 'all': rho = bf.empty_list(self.nTensor) for nt in range(0, self.nTensor): rho[nt] = self.rho_one_body_simple_nt_tensor(nt) elif type(which_t) is int: rho = self.rho_one_body_simple_nt_tensor(which_t) else: rho = bf.empty_list(len(which_t)) n = 0 for nt in which_t: rho[n] = self.rho_one_body_simple_nt_tensor(nt) n += 1 return rho
def rho_two_body_simple(self, which_lm): if which_lm is 'all': rho = bf.empty_list(self.nLm) for n_lm in range(0, self.nLm): rho[n_lm] = self.rho_two_body_nlm_simple(n_lm) elif type(which_lm) is int: rho = self.rho_two_body_nlm_simple(which_lm) else: rho = bf.empty_list(len(which_lm)) n = 0 for n_lm in which_lm: rho[n] = self.rho_two_body_nlm_simple(n_lm) n += 1 return rho
def initial_lm(self): lm = np.random.rand(self.chi, ) lm /= np.linalg.norm(lm) if self.iniWay is 'random': for n in range(0, self.nLm): self.lm[n] = lm.copy() elif self.iniWay is 'ones': for n in range(0, self.nLm): self.tensors[n] = np.ones((self.chi, )) / (self.chi**0.5) elif self.iniWay is 'id': if self.stateType is 'mixed': for n in range(0, self.nLm): self.lm[n] = np.ones(1, ) else: bf.print_error('Initial way "id" is only for thermal states')
def gtnc(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] = copy.deepcopy(para_tot) paras[n]['class'] = int(para_tot['classes'][n]) paras[n]['chi'] = para_tot['chi'][n] paras[n]['theta'] = para_tot['theta'] paras[n]['save_exp'] = save_exp_gtn_one_class(paras[n]) classifiers = bf.empty_list(n_class) for n in range(0, n_class): print_dict(paras[n]) data = para_tot['data_path'] + 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, 'a') else: print('Training the MPS of ' + str(para_tot['classes'][n])) classifiers[n] = gtn_one_class(paras[n])[0] # if para_tot['if_save']: # save_pr('../data_tnml/gcmpm/', paras[n]['save_exp'], # [classifiers[n]], ['classifier']) # classifiers[n].mps.check_orthogonality_by_tensors(tol=1e-12) # ==================== Testing accuracy ==================== print('Calculating the testing accuracy') b = TNmachineLearning.MachineLearningFeatureMap(para_tot['d']) b.load_data(data_path='..\\..\\..\\MNIST\\', file_sample='t10k-images.idx3-ubyte', file_label='t10k-labels.idx1-ubyte', is_normalize=True) b.select_samples(para_tot['classes']) if classifiers[0].is_dct: b.dct(shift=para_tot['shift'], factor=para_tot['factor']) b.images2vecs(para_tot['theta'] * np.pi / 2) fid = bf.empty_list(n_class) for n in range(0, n_class): fid[n] = b.compute_fidelities(classifiers[n].mps.mps) max_fid = np.argmin(np.hstack(fid), axis=1) predict = np.zeros(max_fid.shape, dtype=int) for n in range(0, n_class): predict += (max_fid == n) * int(para_tot['classes'][n]) # plot(predict) # plot(b.labels) accuracy = np.sum(predict == b.labels, dtype=float) / b.numVecSample print(accuracy)
def find_pos_of_lm(self): self.lm_ten_bond = np.zeros((self.nLm, 2, 2), dtype=int) for n_lm in range(0, self.nLm): n_found = 0 for n in range(0, self.nTensor): if n_lm in self.pos_lm[n]: self.lm_ten_bond[n_lm, n_found, 0] = n self.lm_ten_bond[n_lm, n_found, 1] = self.pos_lm[n].index(n_lm) n_found += 1 if n_found == 2: break if self._is_debug and n_found < 2: bf.print_error( 'In "find_pos_of_one_lm", n_found is ony %g. It should 2' % n_found)
def initialize_env(self): self.env = bf.empty_list(self.nVirtual) tmp = np.random.randn(self.chi, self.d0**2, self.chi) tmp = (tmp + tmp.transpose([2, 1, 0])) / 2 tmp /= np.linalg.norm(tmp.reshape(-1, )) for n in range(0, self.nVirtual): self.env[n] = tmp.copy()
def read_mps(load,): load_path = load['path'] load_exp = load['exp'] if load['Is_continue']: data = bf.load_pr(load_path+load_exp+'_.pr') else: data = bf.load_pr(load_path+load_exp+'.pr') print(load_path+load_exp+'.pr') A = data['A'] n = len(A.mps) dims=[1] for i in range(n-1): dims.append(A.mps[i].shape[2]) dims.append(1) return A.mps, dims
def __init__(self, data, parity=0): self.parity = parity if type(data) is dict: self.data = data one_data = data['00'] self.ndim = one_data.ndim self.shape = [one_data.shape[n] * 2 for n in range(0, self.ndim)] else: self.ndim = data.ndim self.shape = list(data.shape) self.data = dict() self.normal_to_z2(data) for n in range(0, self.ndim): if self.shape[n] % 2 == 1: bf.print_error( 'DimError: for a Z2 tensor, all bond dimensions should be even' )
def one_bond_so_transformation(self, nt1, vb1, nt2, vb2): # Super-orthogonal transformation on one virtual bond # vb does NOT count the physical bond if self._is_debug: if self.pos_lm[nt1][vb1] != self.pos_lm[nt2][vb2]: bf.print_error( 'In one_bond_so_transformation, the two virtual bonds must' 'correspond to the same lambda') m1 = self.bond_env_matrix_simple(nt1, vb1) m2 = self.bond_env_matrix_simple(nt2, vb2) flag = False if self._is_debug: _lm = self.lm[self.pos_lm[nt1][vb1]].copy() flag = (self.chi == self.tensors[nt1].shape[vb1 + 1]) u1, u2, self.lm[self.pos_lm[nt1] [vb1]] = tm.transformation_from_env_mats( m1, m2, self.lm[self.pos_lm[nt1][vb1]], self.chi, norm_way=1)[:3] if self._is_debug and flag: _tmp = u1.dot(np.diag(self.lm[self.pos_lm[nt1][vb1]])).dot(u2.T) err = np.linalg.norm(tm.off_diagonal_mat(_tmp).reshape(-1, )) if err > 1e-10: print( 'Warning of the transformations from environment: not diagonal (%g)' % err) _tmp = np.diag(_tmp) _tmp = _tmp / np.linalg.norm(_tmp) err = np.linalg.norm(_tmp - self.lm[self.pos_lm[nt1][vb1]]) if err > 1e-10: print( 'Warning of the transformations from environment: not recover lm (%g)' % err) print(self.lm[self.pos_lm[nt1][vb1]]) self.tensors[nt1] = tm.absorb_matrix2tensor(self.tensors[nt1], u1, vb1 + 1) self.tensors[nt2] = tm.absorb_matrix2tensor(self.tensors[nt2], u2, vb2 + 1) self.tensors[nt1] /= max(abs(self.tensors[nt1].reshape(-1, 1))) self.tensors[nt2] /= max(abs(self.tensors[nt2].reshape(-1, 1))) # self.lm[self.pos_lm[nt1][vb1]] = tm.normalize_tensor(self.lm[self.pos_lm[nt1][vb1]])[0] return m1, m2
def images2vecs(self, classes, numbers, how='random'): self.vec_classes = classes num_class = classes.__len__() ntot = 0 if numbers is None: numbers = ['all'] * num_class for n in range(0, num_class): if numbers[n] is 'all': ntot += self.dataInfo['nClassNum'][n] else: ntot += min(numbers[n], self.dataInfo['nClassNum'][n]) self.numVecSample = ntot self.LabelNow = np.zeros((ntot,), dtype=int) self.tmp = np.zeros((self.length, ntot)) n_now = 0 for n in range(0, num_class): if numbers[n] is 'all': start = self.dataInfo['nStart'][n] end = start + self.dataInfo['nClassNum'][n] self.tmp[:, n_now:self.dataInfo['nClassNum'][n]] = self.images[:, start:end] self.LabelNow[n_now:self.dataInfo['nClassNum'][n]] = self.labels[start:end] n_now += self.dataInfo['nClassNum'][n] else: n_sample = numbers[n] start = self.dataInfo['nStart'][classes[n]] if n_sample >= self.dataInfo['nClassNum'][classes[n]]: rand_p = range(start, self.dataInfo['nClassNum'][classes[n]] + start) elif how is 'random': rand_p = np.random.permutation(self.dataInfo['nClassNum'][classes[n]])[ :n_sample] + start elif how is 'first': rand_p = range(start, n_sample + start) else: rand_p = range(self.dataInfo['nClassNum'][classes[n]] - n_sample + start, self.dataInfo['nClassNum'][classes[n]] + start) for ns in rand_p: self.tmp[:, n_now] = self.images[:, ns] self.LabelNow[n_now] = self.labels[ns] n_now += 1 self.multiple_images2vecs() self.clear_tmp_data() if is_debug and n_now != ntot: bf.print_error('In images2vecs_train_samples: total number of vectorized ' 'images NOT consistent')
def initial_lattice(self): # pos_lm[nt][nb]=x denotes the x-th lm locates at the nb-th bond of the nt-th tensor if self.lattice is 'honeycomb0': self.nTensor = 2 self.nLm = 3 self.nVirtual = 3 # means for the 0-the tensor, it is the 0, 1, and 2-th lm on the three virtual bonds self.pos_lm = [[], []] self.pos_lm[0] = [0, 1, 2] self.pos_lm[1] = [0, 1, 2] elif self.lattice is 'honeycombTreeDMRG': # for tree DMRG of honeycomb lattice; the TN is square (one tensor with two spins) self.nTensor = 5 self.nVirtual = 4 self.d = self.d0**2 else: bf.print_error('Incorrect input of the lattice') self.find_pos_of_lm()
def __init__(self, dataset='mnist', data_path='..\\..\\..\\MNIST\\', file_sample='train-images.idx3-ubyte', file_label='train-labels.idx1-ubyte', is_normalize=True, par_pool=None): # MNIST files for training: 'train-images.idx3-ubyte', 'train-labels.idx1-ubyte' # MNIST files for testing: 't10k-images.idx3-ubyte', 't10k-labels.idx1-ubyte' self.dataset = dataset self.dataInfo = dict() self.images = bf.decode_idx3_ubyte(path.join(data_path, file_sample)) self.labels = bf.decode_idx1_ubyte(path.join(data_path, file_label)) self.length = self.images.shape[0] if is_normalize: self.images /= 256 self.analyse_dataset() self.tmp = None self.nPool = par_pool self.parPool = None if is_debug: self.check_consistency()
def get_model_related_tree_dmrg(self, jx, jy, jz, hx, hz, tau=1e-6): if 'h2phys' not in self.model_related: self.model_related['h2phys'] = hamiltonian_heisenberg( self.spin, jx, jy, jz, hx, hz) self.model_related['h2_gate'] = expm(-tau / 2 * self.model_related['h2phys']) if 'tensor_gate' not in self.model_related: self.model_related['tensor_gate'] = hamiltonian2gate_tensors( self.model_related['h2phys'], tau) if 'hbath' not in self.model_related: self.model_related['hbath'] = bf.empty_list(self.nVirtual)
def load_data(self, data_path=None, file_sample=None, file_label=None, is_normalize=None): # MNIST files for training: 'train-images.idx3-ubyte', 'train-labels.idx1-ubyte' # MNIST files for testing: 't10k-images.idx3-ubyte', 't10k-labels.idx1-ubyte' if data_path is None: data_path = self.data_path if file_label is not None: self.data_samples = path.join(data_path, file_sample) if self.is_there_labels: self.data_labels = path.join(data_path, file_label) if not (is_normalize is None): self.is_normalize_data = is_normalize self.images = bf.decode_idx3_ubyte(self.data_samples) if self.is_there_labels: self.labels = bf.decode_idx1_ubyte(self.data_labels) self.length = self.images.shape[0] if self.is_normalize_data: self.images /= (254 * (self.images.max() > 2) + 1)
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 update_by_given_effective_ops(psi, ops, bonds): indexes = bf.empty_list(1 + bonds.__len__()) indexes[0] = list(range(psi.ndim)) x = 1 for n in range(psi.ndim): if n in bonds: indexes[0][n] = x indexes[bonds.index(n) + 1] = [-n - 1, x] x += 1 else: indexes[0][n] = -n - 1 return tm.cont([psi] + ops, indexes)
def show_image(self, n, title_way='which_class'): # n can be a number or an image if type(n) is int: l_side = int(np.sqrt(self.length)) bf.show_multiple_images_v1( [self.images[:, n].reshape(l_side, l_side)], titles=[n]) elif type(n) is np.ndarray: bf.show_multiple_images_v1([n]) else: l_side = int(np.sqrt(self.length)) num = n.__len__() n_now = 0 while num > 0.5: dn = min(num, 100) if title_way is 'which_sample': titles = [x for x in n[n_now:n_now + dn]] elif title_way is 'which_class': titles = [int(self.labels[x]) for x in n[n_now:n_now + dn]] else: titles = None # bf.show_multiple_images_v0( # [self.images[:, x].reshape(l_side, l_side) for x in n[n_now:n_now + dn]], # gap=0) bf.show_multiple_images_v1([ self.images[:, x].reshape(l_side, l_side) for x in n[n_now:n_now + dn] ], titles=titles) n_now += dn num -= dn
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)
def initialize_virtual_vecs_train(self, way='contract'): self.norms = np.ones((self.length, self.numVecSample)) self.vecsLeft = bf.empty_list(self.length) self.vecsRight = bf.empty_list(self.length) if way is 'random': for n in range(0, self.length): self.vecsLeft[n] = np.random.randn(self.mps.virtual_dim[n], self.numVecSample) self.vecsRight[n] = np.random.randn( self.mps.virtual_dim[n + 1], self.numVecSample) elif way is 'ones': for n in range(0, self.length): self.vecsLeft[n] = np.ones( (self.mps.virtual_dim[n], self.numVecSample)) self.vecsRight[n] = np.ones( (self.mps.virtual_dim[n + 1], self.numVecSample)) else: self.vecsRight[self.length - 1] = np.ones( (self.mps.virtual_dim[self.length], self.numVecSample)) self.update_virtual_vecs_train_all_tensors('right') self.vecsLeft[0] = np.ones( (self.mps.virtual_dim[0], self.numVecSample))
def initial_lattice(self): # pos_lm[nt][nb]=x denotes the x-th lm locates at the nb-th bond of the nt-th tensor if self.lattice is 'honeycomb0': self.nTensor = 2 self.nLm = 3 self.nVirtual = 3 # self.pos_lm[x] means for the x-th tensor, it is the 0, 1, and 2-th lm on the three virtual bonds self.pos_lm = [[], []] self.pos_lm[0] = [0, 1, 2] self.pos_lm[1] = [0, 1, 2] elif self.lattice is 'honeycombTreeDMRG': # for tree DMRG of honeycomb lattice; the TN is square (one tensor with two spins) self.nTensor = 5 self.nVirtual = 4 self.d = self.d0**2 elif self.lattice in ['kagome', 'husimi']: self.nTensor = 2 # use symmetrical environment: only one orthogonal tensor self.nVirtual = 3 self.d = self.d0 self.stateType = 'pure' else: bf.print_error('Incorrect input of the lattice') self.find_pos_of_lm()
def rho_two_body_nlm_simple(self, n_lm): nt1 = self.lm_ten_bond[n_lm, 0, 0] vb1 = self.lm_ten_bond[n_lm, 0, 1] nt2 = self.lm_ten_bond[n_lm, 1, 0] vb2 = self.lm_ten_bond[n_lm, 1, 1] if self._is_debug: if n_lm != self.pos_lm[nt2][vb2]: bf.print_error( 'In rho_two_body_simple, the two virtual bonds must' 'correspond to the same lambda') bonds = list(range(0, self.nVirtual)) bonds.remove(vb1) tmp1 = self.absorb_lm(nt1, False, bonds) tmp2 = self.absorb_lm(nt2, False, 'all') if self.stateType is 'pure': bonds = list(range(1, self.nVirtual + 1)) bonds.remove(vb1 + 1) tmp1 = np.tensordot(tmp1.conj(), tmp1, (bonds, bonds)) bonds = list(range(1, self.nVirtual + 1)) bonds.remove(vb2 + 1) tmp2 = np.tensordot(tmp2.conj(), tmp2, (bonds, bonds)) elif self.stateType is 'mixed': s = tmp1.shape bonds = list(range(1, self.nVirtual + 2)) bonds.remove(vb1 + 2) tmp1 = tmp1.reshape((self.d0, self.d0) + s[1:]) tmp1 = np.tensordot(tmp1.conj(), tmp1, (bonds, bonds)) s = tmp2.shape bonds = list(range(1, self.nVirtual + 2)) bonds.remove(vb2 + 2) tmp2 = tmp2.reshape((self.d0, self.d0) + s[1:]) tmp2 = np.tensordot(tmp2.conj(), tmp2, (bonds, bonds)) rho = tm.cont([tmp1, tmp2], [[-1, 1, -3, 2], [-2, 1, -4, 2]]) rho = rho.reshape(self.d0 * self.d0, self.d0 * self.d0) rho = (rho + rho.conj().T) / 2 rho /= np.trace(rho) return rho
def observe_by_features(self, features, pos): if len(pos) == self.length: bf.print_error( 'Input features cannot be as many as the total features') features = np.array(features).reshape(-1, 1) features = self.map_to_vectors(features).squeeze() data_mps = self.mps.wrap_data() mps = MPS(self.length, self.d, self.chi) mps.refresh_mps_properties(data_mps) for n in range(np.array(pos).size): mps.mps[pos[n]] = np.tensordot(mps.mps[pos[n]], features[:, n], [[1], [0]]) pos = np.sort(pos) for n in pos[::-1]: if n > 0: mps.mps[n - 1] = np.tensordot(mps.mps[n - 1], mps.mps[n], [[mps.mps[n - 1].ndim - 1], [0]]) else: mps.mps[n + 1] = np.tensordot(mps.mps[n], mps.mps[n + 1], [[1], [0]]) mps.mps.__delitem__(n) mps.refresh_mps_properties() mps.correct_orthogonal_center(0, normalize=True) return mps
def analyse_dataset(self): # Total number of samples self.dataInfo['NumTotalTrain'] = self.labels.__len__() # Order the samples and labels order = np.argsort(self.labels) self.images = bf.sort_vecs(self.images, order, which=1) self.labels = np.array(sorted(self.labels)) # Total number of classes self.dataInfo['NumClass'] = int(self.labels[-1] + 1) # Detailed information self.dataInfo['nStart'] = np.zeros((self.dataInfo['NumClass'], ), dtype=int) self.dataInfo['nClassNum'] = np.zeros((self.dataInfo['NumClass'],), dtype=int) self.dataInfo['nStart'][0] = 0 for n in range(1, self.dataInfo['NumClass']): x = tm.arg_find_array(self.labels[self.dataInfo['nStart'][n-1] + 1:] == n, 1, 'first') self.dataInfo['nClassNum'][n-1] = x + 1 self.dataInfo['nStart'][n] = x + self.dataInfo['nStart'][n-1] + 1 self.dataInfo['nClassNum'][-1] = \ self.dataInfo['NumTotalTrain'] - self.dataInfo['nStart'][-1]
def __init__(self, dataset='mnist'): self.dataset = dataset self.dataInfo = dict() self.is_normalize_data = True self.is_there_labels = True # For generative tasks, no labels are needed self.data_samples = '' self.data_labels = '' self.images = np.zeros(0) self.labels = np.zeros(0, dtype=int) self.length = -1 self.img_size = [0, 0] self.is_dct = False self.dct_info = dict() self.is_label_added = False self.project_path = bf.project_path() self.data_path = None self.identify_dataset() self.tmp = None if is_debug: self.check_consistency()
def initialize_virtual_vecs_train(self): self.vecsLeft = bf.empty_list(self.length, list()) self.vecsRight = bf.empty_list(self.length, list()) for n in range(0, self.length): self.vecsLeft[n] = np.ones((self.mps.virtual_dim[n], self.numVecSample)) self.vecsRight[n] = np.ones((self.mps.virtual_dim[n+1], self.numVecSample))