def circuit(w): qml.RX(w[np.unravel_index(0, s)], 0) # b[0] qml.RX(w[np.unravel_index(1, s)], 1) # b[1] qml.RX(w[np.unravel_index(2, s)], 2) # ... qml.RX(w[np.unravel_index(3, s)], 3) qml.RX(w[np.unravel_index(4, s)], 4) qml.RX(w[np.unravel_index(5, s)], 5) qml.RX(w[np.unravel_index(6, s)], 6) qml.RX(w[np.unravel_index(7, s)], 7) return tuple(qml.expval.PauliZ(idx) for idx in range(len(b)))
def circuit(w): qml.RX(w[np.unravel_index(0, s)], wires=0) # b[0] qml.RX(w[np.unravel_index(1, s)], wires=1) # b[1] qml.RX(w[np.unravel_index(2, s)], wires=2) # ... qml.RX(w[np.unravel_index(3, s)], wires=3) qml.RX(w[np.unravel_index(4, s)], wires=4) qml.RX(w[np.unravel_index(5, s)], wires=5) qml.RX(w[np.unravel_index(6, s)], wires=6) qml.RX(w[np.unravel_index(7, s)], wires=7) return tuple(qml.expval(qml.PauliZ(idx)) for idx in range(len(b)))
def _fit_pixel_center(morph, center, window=None): cy, cx = np.int(center[0]), np.int(center[1]) if window is None: window = slice(cy - 2, cy + 3), slice(cx - 2, cx + 3) _morph = morph[window] yx0 = np.array([window[0].start, window[1].start]) return tuple(np.unravel_index(np.argmax(_morph), _morph.shape) + yx0)
def uncentered_operator(X, func, center=None, fill=None, **kwargs): """Only apply the operator on a centered patch In some cases, for example symmetry, an operator might not make sense outside of a centered box. This operator only updates the portion of `X` inside the centered region. Parameters ---------- X: array The parameter to update. func: `function` The function (or operator) to apply to `X`. center: tuple The location of the center of the sub-region to apply `func` to `X`. `fill`: `float` The value to fill the region outside of centered `sub-region`, for example `0`. If `fill` is `None` then only the subregion is updated and the rest of `X` remains unchanged. """ if center is None: py, px = np.unravel_index(np.argmax(X), X.shape) else: py, px = center cy, cx = np.array(X.shape) // 2 if py == cy and px == cx: return func(X, **kwargs) dy = int(2 * (py - cy)) dx = int(2 * (px - cx)) if not X.shape[0] % 2: dy += 1 if not X.shape[1] % 2: dx += 1 if dx < 0: xslice = slice(None, dx) else: xslice = slice(dx, None) if dy < 0: yslice = slice(None, dy) else: yslice = slice(dy, None) if fill is not None: _X = np.ones(X.shape, X.dtype) * fill _X[yslice, xslice] = func(X[yslice, xslice], **kwargs) X[:] = _X else: X[yslice, xslice] = func(X[yslice, xslice], **kwargs) return X
def flatten_nested_list_of_2d_arrays(this_list): current_el = this_list.copy() shp = tuple(()) while isinstance(current_el, list): shp = shp + (len(current_el), ) current_el = current_el[0] nflat = np.prod(shp) n0, n1 = current_el.shape to_return = np.zeros((n0, n1 * nflat)) for iflat in range(nflat): imulti = np.unravel_index(iflat, shp) to_return[:, iflat * n1:(iflat + 1) * n1] = access_nested_list_element( this_list, imulti) return to_return
def compute_tr_siginv2_sig1(stim_deriv,noise,pc_list): # pc_list a list of PCs of the covariance matrix, each a tuple of (sigma,normed vector) tot = 0 this_ncelltypes = len(pc_list[0][0]) for iel in range(stim_deriv.shape[1]): iS,iT,icelltype = np.unravel_index(iel,(nS,nT,this_ncelltypes)) sigma2 = np.sum(stim_deriv[:,iel]**2) #print_labeled('sigma2',sigma2) if sigma2>0 and not pc_list[iS][iT][icelltype] is None: inner_prod = np.sum([pc[0]**2*np.sqrt(sigma2)*inner_product_(stim_deriv[:,iel],pc[1]) for pc in pc_list[iS][iT][icelltype]]) else: inner_prod = 0 tot = tot - 1/noise/(noise + sigma2)*inner_prod #.sum() return tot
def __init__(self, vec, other_vec, whole, otherwhole, actInd, **kwargs): actInd = (int(actInd[0]), int(actInd[1])) DistanceMat = np.array([[distance(i, j) for j in otherwhole] for i in whole]) # print("Mindistance:", np.min(DistanceMat)) # print("len(whole),len(otherwhole)",len(whole),len(otherwhole)) insectPT = np.nonzero( DistanceMat < INTERSECTLIM) # The index of the intersection point try: insectPT = (insectPT[0][0], insectPT[1][0]) except IndexError: # the case where is no pair of points fall in the threshold, find the least distance point instead insectPT = np.unravel_index(np.argmin(DistanceMat, axis=None), DistanceMat.shape) egopath = whole[actInd[0]:insectPT[0]] otherpath = otherwhole[actInd[1]:insectPT[1]] # path a None in is just to call the lambda function egoPTs = np.sum( (self._distance(self._diff(lambda x: egopath[:, 0]), self._diff(lambda y: egopath[:, 1])))(None)) otherPTs = np.sum( self._distance(self._diff(lambda x: otherpath[:, 0]), self._diff(lambda y: otherpath[:, 1]))(None)) otherDistance = self._cumsum( self._distance( self._diff(lambda x: otherwhole[actInd[1]:, 0]), self._diff(lambda y: otherwhole[actInd[1]:, 1])))(None) self.other_vec = other_vec self.whole = whole self.otherwhole = otherwhole self.actInd = actInd self.insectPT = insectPT self.egoPTs = egoPTs self.otherPTs = otherPTs self.otherDistance = otherDistance super().__init__(vec, other_vec, whole=whole, otherwhole=otherwhole, actInd=actInd, intersectInd=insectPT, intersectPTs=(self.egoPTs, self.otherPTs), otherDist=otherDistance, **kwargs)
def getRadialMonotonicWeights(shape, useNearest=True, minGradient=1, center=None): """Create the weights used for the Radial Monotonicity Operator This version of the radial monotonicity operator selects all of the pixels closer to the peak for each pixel and weights their flux based on their alignment with a vector from the pixel to the peak. In order to quickly create this using sparse matrices, its construction is a bit opaque. """ if center is None: center = ((shape[0] - 1) // 2, (shape[1] - 1) // 2) name = "RadialMonotonicWeights" key = tuple(shape) + tuple(center) + (useNearest, minGradient) try: cosNorm = Cache.check(name, key) except KeyError: # Center on the center pixel py, px = int(center[0]), int(center[1]) # Calculate the distance between each pixel and the peak x = np.arange(shape[1]) y = np.arange(shape[0]) X, Y = np.meshgrid(x, y) X = X - px Y = Y - py distance = np.sqrt(X**2 + Y**2) # Find each pixels neighbors further from the peak and mark them as invalid # (to be removed later) distArr, mask = diagonalizeArray(distance, dtype=np.float64) relativeDist = (distance.flatten()[:, None] - distArr.T).T invalidPix = relativeDist <= 0 # Calculate the angle between each pixel and the x axis, relative to the peak position # (also avoid dividing by zero and set the tan(infinity) pixel values to pi/2 manually) inf = X == 0 tX = X.copy() tX[inf] = 1 angles = np.arctan2(-Y, -tX) angles[inf & (Y != 0)] = 0.5 * np.pi * np.sign(angles[inf & (Y != 0)]) # Calcualte the angle between each pixel and it's neighbors xArr, m = diagonalizeArray(X) yArr, m = diagonalizeArray(Y) dx = (xArr.T - X.flatten()[:, None]).T dy = (yArr.T - Y.flatten()[:, None]).T # Avoid dividing by zero and set the tan(infinity) pixel values to pi/2 manually inf = dx == 0 dx[inf] = 1 relativeAngles = np.arctan2(dy, dx) relativeAngles[inf & (dy != 0)] = 0.5 * np.pi * np.sign( relativeAngles[inf & (dy != 0)]) # Find the difference between each pixels angle with the peak # and the relative angles to its neighbors, and take the # cos to find its neighbors weight dAngles = (angles.flatten()[:, None] - relativeAngles.T).T cosWeight = np.cos(dAngles) # Mask edge pixels, array elements outside the operator (for offdiagonal bands with < N elements), # and neighbors further from the peak than the reference pixel cosWeight[invalidPix] = 0 cosWeight[mask] = 0 if useNearest: # Only use a single pixel most in line with peak cosNorm = np.zeros_like(cosWeight) columnIndices = np.arange(cosWeight.shape[1]) maxIndices = np.argmax(cosWeight, axis=0) indices = maxIndices * cosNorm.shape[1] + columnIndices indices = np.unravel_index(indices, cosNorm.shape) cosNorm[indices] = minGradient # Remove the reference for the peak pixel cosNorm[:, px + py * shape[1]] = 0 else: # Normalize the cos weights for each pixel normalize = np.sum(cosWeight, axis=0) normalize[normalize == 0] = 1 cosNorm = (cosWeight.T / normalize[:, None]).T cosNorm[mask] = 0 Cache.set(name, key, cosNorm) return cosNorm
''' for n_point in n_points: print('n_points: ', n_point) for i in range(Z.shape[0]): print(i) for j in range(Z.shape[1]): Z[i,j] = swarm.MAP_loss([X[i,j], Y[i,j]], xSol[50, :], Cins[50],xSol[50:n_point+50,0]) np.save('Z_diff_n_points_from_stationary/Z_' + str(n_point) + '.npy', Z) sys.exit() ''' Z = np.load('Z_small_domain.npy') #Z = np.load('/Users/Neythen/Desktop/masters_project/parameter_estimation/global_optimsiation/Z_diff_n_points/Z_2.npy') ind = Z.argmin() ind = np.unravel_index(ind, (100, 100)) min = np.min(Z) ''' print(Z) print(min) print(X[ind], Y[ind]) ''' fig = plt.figure(figsize=(12, 8)) im = plt.contour(X, Y, Z, 40, vmin=abs(Z).min(), vmax=abs(Z).max()) cb = fig.colorbar(im) swarm.find_minimum_time_series(50) print(swarm.global_best_positions) print(swarm.global_best_values)
R_int_term_2 = k_grad[2]*\ ( ((input_vec[2] - input_vec[1])/(2*DELTA_H))**2 + ((input_vec[4] - input_vec[3])/(2*DELTA_H))**2 ) R_int_term_3 = input_vec[5] return R_int_term_1 + R_int_term_2 + R_int_term_3 compute_R_int_grad = grad(compute_R_int) ravel = lambda i, j: np.ravel_multi_index( (i, j), [int(1 / DELTA_H) + 1, int(1 / DELTA_H) + 1]) unravel = lambda n: np.unravel_index( n, [int(1 / DELTA_H) + 1, int(1 / DELTA_H) + 1]) ''' Functions for discrete k ''' def compute_R_int_discrete_k( input_vec ): # input_vec = [T_i,j T_i-1,j T_i+1,j T_i,j-1 T_i,j+1 q k_i,j k_i-1,j k_i+1,j k_i,j-1 k_i,j+1] R_int_term_1 = input_vec[6]*\ ( (input_vec[2] - 2*input_vec[0] + input_vec[1])/(DELTA_H**2) + (input_vec[4] - 2*input_vec[0] + input_vec[3])/(DELTA_H**2) )