def test_kernel(binary_matrix, result): r"""Test that _kernel returns the correct result.""" # get the kernel from the gaussian elimination. pivots = (binary_matrix.T != 0).argmax(axis=0) nonpivots = np.setdiff1d(range(len(binary_matrix[0])), pivots) kernel = [] for col in nonpivots: col_vector = binary_matrix[:, col] null_vector = np.zeros((binary_matrix.shape[1]), dtype=int) null_vector[col] = 1 for i in pivots: first_entry = np.where(binary_matrix[:, i] == 1)[0][0] if col_vector[first_entry] == 1: null_vector[i] = 1 kernel.append(null_vector.tolist()) # get the nullspace from the _kernel function. nullspace = _kernel(binary_matrix) for nullvec in kernel: assert nullvec in nullspace.tolist() assert (nullspace == result).all()
def optimal_sector(qubit_op, generators, active_electrons): r"""Get the optimal sector which contains the ground state. To obtain the optimal sector, we need to choose the right eigenvalues for the symmetry generators :math:`\bm{\tau}`. We can do so by using the following relation between the Pauli-Z qubit operator and the occupation number under a Jordan-Wigner transform. .. math:: \sigma_{i}^{z} = I - 2a_{i}^{\dagger}a_{i} According to this relation, the occupied and unoccupied fermionic modes correspond to the -1 and +1 eigenvalues of the Pauli-Z operator, respectively. Since all of the generators :math:`\bm{\tau}` consist only of :math:`I` and Pauli-Z operators, the correct eigenvalue for each :math:`\tau` operator can be simply obtained by applying it on the reference Hartree-Fock (HF) state, and looking at the overlap between the wires on which the Pauli-Z operators act and the wires that correspond to occupied orbitals in the HF state. Args: qubit_op (Hamiltonian): Hamiltonian for which symmetries are being generated to perform tapering generators (list[Hamiltonian]): list of symmetry generators for the Hamiltonian active_electrons (int): The number of active electrons in the system for generating the Hartree-Fock bitstring Returns: list[int]: eigenvalues corresponding to the optimal sector which contains the ground state **Example** >>> symbols = ['H', 'H'] >>> geometry = np.array([[0., 0., -0.66140414], [0., 0., 0.66140414]]) >>> mol = qml.hf.Molecule(symbols, geometry) >>> H = qml.hf.generate_hamiltonian(mol)(geometry) >>> generators, paulix_ops = qml.hf.generate_symmetries(H, len(H.wires)) >>> qml.hf.optimal_sector(H, generators, 2) [1, -1, -1] """ if active_electrons < 1: raise ValueError( f"The number of active electrons must be greater than zero;" f"got 'electrons'={active_electrons}") num_orbitals = len(qubit_op.wires) if active_electrons > num_orbitals: raise ValueError( f"Number of active orbitals cannot be smaller than number of active electrons;" f" got 'orbitals'={num_orbitals} < 'electrons'={active_electrons}." ) hf_str = np.where(np.arange(num_orbitals) < active_electrons, 1, 0) perm = [] for tau in generators: symmstr = np.array( [1 if wire in tau.ops[0].wires else 0 for wire in qubit_op.wires]) coeff = -1 if numpy.logical_xor.reduce( numpy.logical_and(symmstr, hf_str)) else 1 perm.append(coeff) return perm
def get_cell_centers(cells): """Get average coordinates per cell Args: cells (ndarray<int>): Cells as computed by `get_cells` Returns: centers (dict): Map from cell labels to mean coordinates of cells """ centers = {} for _id in np.unique(cells): wheres = np.where(cells == _id) centers[_id] = np.array( [np.mean(where.astype(float)) for where in wheres]) return centers
def predict(self, features): """Predicts certain obervations. Args: features (array):observations to be predicted Returns: preds: float or int prediction of the model """ model_output = np.array( [self.neural_network(self.var, features=x_) for x_ in features]) if self.type_problem == "classification": return np.where(model_output > 0., 1, 0) elif self.type_problem == "multiclassification": soft_outputs = np.exp(model_output) / \ np.sum(np.exp(model_output), axis=1)[:, None] return np.argmax(soft_outputs, axis=1) return model_output
def get_cell_label_pos(cells): """Get proper label position per cell Args: cells (ndarray<int>): Cells as computed by `get_cells` Returns: label_pos (dict): Map from cell labels to label coordinates for cells """ label_pos = get_cell_centers(cells) ids = label_pos.keys() for _id in ids: center = label_pos[_id] x, y = map(int, np.round(center)) if cells[x, y] != _id: where = np.where(cells == _id) dists = [(coord, np.linalg.norm(center - coord, 2)) for coord in zip(where[0], where[1])] label_pos[_id] = min(dists, key=lambda x: x[1])[0] return label_pos
def _group_operations(tape): """Divide all operations of a tape into trainable operations and blocks of untrainable operations after each trainable one.""" # Extract tape operations list ops = tape.operations # Find the indices of trainable operations in the tape operations list trainables = np.where([qml.operation.is_trainable(op) for op in ops])[0] # Add the indices incremented by one to the trainable indices split_ids = list(chain.from_iterable([idx, idx + 1] for idx in trainables)) # Split at trainable and incremented indices to get groups after trainable # operations and single trainable operations (in alternating order) all_groups = np.split(ops, split_ids) # Collect trainable operations and groups after trainable operations # the first set of non-trainable ops are the ops "after the -1st" trainable op group_after_trainable_op = dict(enumerate(all_groups[::2], start=-1)) trainable_operations = list(chain.from_iterable(all_groups[1::2])) return trainable_operations, group_after_trainable_op
def where(condition, x, y): return np.where(condition, *AutogradBox.unbox_list([x, y]))
for j in range(10): ax = plt.subplot(gs[0, j]) plt.imshow(X_test[j], cmap=plt.get_cmap('gray')) ax.axis("off") ax = plt.subplot(gs[1, j]) plt.imshow(X_test[5 + j], cmap=plt.get_cmap('gray')) ax.axis("off") plt.show() # + # Create a single set with coordinates for zero images ## perform once to populate the list ## number of pixels to sample from each image samples_per_image = 3 ## threshold greyscale on [0,1] x_0, x_1 = np.where(train_X0[0] >= 0.95) ## sample $size datapoints from this image sample_indices = np.random.randint(low=0, high=len(x_0), size=samples_per_image) ## add the coordinates to our dataset zero_samples = [x_0[sample_indices], x_1[sample_indices]] ## fill the remained in the list with this loop for i in range(1, 500): ## threshold x_0, x_1 = np.where(train_X0[i] >= 0.95) ## sample $size datapoints from this image sample_indices = np.random.randint(low=0, high=len(x_0), size=samples_per_image) ## add the coordinates to out dataset
# + tags=[] num_wires = 5 use_trained_params = False sub_filename = f'data/noisy_sim/sub_kernel_matrices_Checkerboard_{"" if use_trained_params else "un"}trained.dill' filename = f'data/noisy_sim/kernel_matrices_Checkerboard_{"" if use_trained_params else "un"}trained.dill' # - # # Checkerboard dataset # + tags=[] np.random.seed(43) X_train, y_train, X_test, y_test = checkerboard(30, 30, 4, 4) print("The training data is as follows:") plt.scatter(X_train[np.where(y_train == 1)[0],0], X_train[np.where(y_train == 1)[0],1], color="b", marker=".", label="train, 1") plt.scatter(X_train[np.where(y_train == -1)[0],0], X_train[np.where(y_train == -1)[0],1], color="r", marker=".", label="train, -1") print("The test data is as follows:") plt.scatter(X_test[np.where(y_train == 1)[0],0], X_test[np.where(y_train == 1)[0],1], color="b", marker="x", label="test, 1") plt.scatter(X_test[np.where(y_train == -1)[0],0], X_test[np.where(y_train == -1)[0],1], color="r", marker="x", label="test, -1") plt.ylim([0, 1]) plt.xlim([0, 1]) plt.legend() X = X_train opt_param = np.tensor([[[ 6.22961793, 6.1909463 , 6.24821366, 1.88800397, 1.6515437 ], [-3.50578116, 2.87429701, -0.55558014, -2.97461847, 4.3646466 ]], [[ 4.59893525, -0.01877453, 4.86909045, 1.61046237, 4.3342154 ], [ 6.54969706, 0.76974914, 6.13216135, 3.19770538, 0.35820405]], [[-0.06825097, 5.46138114, -0.38685812, 2.62531926, 5.94363286],
def plot(X, y, log, name="", density=23): import matplotlib.pyplot as plt from matplotlib.backends.backend_pdf import PdfPages # data = [(i, step["batch_cost"]) for i, step in enumerate(log)] # data = list(zip(*data)) # plt.figure(figsize=(11, 11)) # plt.plot(*data) # plt.title(f"Learning curve") # plt.xlabel("Learning step") # plt.ylabel("Batch loss") # plt.savefig("learning_curve.pdf") # plt.close() # exit(-1) with PdfPages(f"{name}.pdf") as pdf: for i, step in enumerate(log): theta = step["theta"] plt.figure(figsize=(8, 8)) extent = X[:, 0].min(), X[:, 0].max(), X[:, 1].min(), X[:, 1].max() extent = 0, np.pi, 0, np.pi xx = np.linspace(*extent[0:2], density) yy = np.linspace(*extent[2:4], density) xx, yy = np.meshgrid(xx, yy) Xfull = np.c_[xx.ravel(), yy.ravel()] # Xfull = np.random.rand(density**2,2)*np.pi # View probabilities: scores_full = np.array([circuit(theta, x=x) for x in Xfull]) vmin, vmax = -1, 1 scores = np.array([circuit(theta, x=x) for x in X]) y_pred = sgn(scores) print(metrics.confusion_matrix(y, y_pred)) accuracy = metrics.accuracy_score(y, y_pred) plt.title(f"Classification score, accuracy={accuracy:1.2f} ") plt.xlabel("feature 1") plt.ylabel("feature 2") imshow_handle = plt.contourf(xx, yy, scores_full.reshape( (density, density)), vmin=vmin, vmax=vmax, cmap='seismic') plt.xticks(np.linspace(0, np.pi, 5)) plt.yticks(np.linspace(0, np.pi, 5)) for cls_val, cls_col in {0: 'b', 1: 'r'}.items(): # get row indexes for samples with this class row_ix = np.where(y == cls_val) # create scatter of these samples plt.scatter(X[row_ix, 0], X[row_ix, 1], cmap='seismic', c=cls_col, lw=1, edgecolor='k') ax = plt.axes([0.91, 0.1, 0.02, 0.8]) plt.colorbar(imshow_handle, cax=ax, orientation='vertical') plt.clim(-1, 1) pdf.savefig() plt.close()
key=pipeline_sorting_key) for pipeline in unfilt_all_pipelines: this_pipe_df = same_pipeline(na_is_neg_df, pipeline) # Filter out group 1 if all(this_pipe_df.q >= zero): groups[1].append(pipeline) continue # Check in which group a pipeline belongs per number of shots. group_features = [] for shots in all_shots: this_df = same_shots(this_pipe_df, shots) # Check whether all negative entries are in one group from the first base noise rate onwards neg_ids = np.where(this_df.q < zero)[0] neg_is_contiguous = np.allclose(neg_ids, list(range(len(neg_ids)))) # Check whether all non-negative entries are in one group from the first base noise rate onwards nonneg_ids = np.where(this_df.q >= zero)[0] nonneg_is_contiguous = np.allclose(nonneg_ids, list(range(len(nonneg_ids)))) # Sort into group, based on data for this shots number if nonneg_is_contiguous and len(nonneg_ids) > 0: group_features.append(2) elif neg_is_contiguous: group_features.append(3) else: group_features.append(4) # Conclude the group for the pipeline based on all group features per number of shots