def non_maximum_suppression(bbox, thresh, score=None, limit=None): """非极大值抑制""" bbox_y1 = bbox[:, 0] bbox_x1 = bbox[:, 1] bbox_y2 = bbox[:, 2] bbox_x2 = bbox[:, 3] area = (bbox_x2 - bbox_x1 + 1) * (bbox_y2 - bbox_y1 + 1) n_bbox = bbox.shape[0] if score is not None: order = score.argsort()[::-1].astype(np.int32) else: order = cp.arange(n_bbox, dtype=np.int32) keep = [] # 预测框之间进行两两比较,去除重叠面积iou大于thresh的框 while order.size > 0: i = order[0] keep.append(i) xx1 = cp.maximum(bbox_x1[i], bbox_x1[order[1:]]) yy1 = cp.maximum(bbox_y1[i], bbox_y1[order[1:]]) xx2 = cp.minimum(bbox_x2[i], bbox_x2[order[1:]]) yy2 = cp.minimum(bbox_y2[i], bbox_y2[order[1:]]) width = cp.maximum(0., (xx2 - xx1 + 1)) height = cp.maximum(0., (yy2 - yy1 + 1)) inter = width * height iou = inter / (area[i] + area[order[1:]] - inter) index = cp.where(iou <= thresh)[0] order = order[(index + 1).tolist()] if limit is not None: keep = keep[:limit] return cp.asnumpy(keep)
def non_max_suppression(self, A, threshold=0.5): """Remove overlapping bounding boxes. Returns filterd boxes in screen coordinates and as an array with shape (n_boxes, (x1, y1, x2, y2)). Args: A (np.array): predicted labels and boxes. threshold (float): overlap threshold to treat as new box Returns: np.array: only max boxes. """ x_stride = 34 y_stride = 34 score = [] x1 = [] x2 = [] y1 = [] y2 = [] for i in range(0, A.shape[1]): for j in range(0, A.shape[2]): if A[0, i, j][0] > 0.5: bx, by, w, h = A[0, i, j][1:] score.append(A[0, i, j, 0]) x1.append((j + bx - w / 2) * x_stride + 29) y1.append((i + by - h / 2) * y_stride) x2.append((j + bx + w / 2) * x_stride + 29) y2.append((i + by + h / 2) * y_stride) score = np.array(score) x1 = cp.array(x1) x2 = cp.array(x2) y1 = cp.array(y1) y2 = cp.array(y2) score_indexes = score.argsort().tolist() boxes_keep_index = [] while len(score_indexes) > 0: index = score_indexes.pop() boxes_keep_index.append(index) if not len(score_indexes): break #iou xs1 = cp.maximum(x1[index], x1[score_indexes]) ys1 = cp.maximum(y1[index], y1[score_indexes]) xs2 = cp.minimum(x2[index], x2[score_indexes]) ys2 = cp.minimum(y2[index], y2[score_indexes]) intersections = cp.maximum(ys2 - ys1, 0) * cp.maximum(xs2 - xs1, 0) unions = (x2[index]-x1[index])*(y2[index]-y1[index]) \ + (x2[score_indexes]-x1[score_indexes])*(y2[score_indexes]-y1[score_indexes]) \ - intersections ious = np.array(cp.asnumpy(intersections / unions)) filtered_indexes = set((ious > threshold).nonzero()[0]) score_indexes = [ v for (i, v) in enumerate(score_indexes) if i not in filtered_indexes ] nms_res = np.zeros((len(boxes_keep_index), 5)) for i, j in enumerate(boxes_keep_index): nms_res[i, :] = np.array([score[j], x1[j], y1[j], x2[j], y2[j]]) return nms_res
def _update_position( scan, position_options, position_update_numerator, position_update_denominator, alpha=0.05, max_shift=1, ): step = position_update_numerator / ( (1 - alpha) * position_update_denominator + alpha * position_update_denominator.max()) step_x = step[..., 0] step_y = step[..., 1] if position_options.use_adaptive_moment: logger.info( "position correction with ADAptive Momemtum acceleration enabled.") step_x, position_options.vx, position_options.mx = adam( step_x, position_options.vx, position_options.mx, vdecay=position_options.vdecay, mdecay=position_options.mdecay) step_y, position_options.vy, position_options.my = adam( step_y, position_options.vy, position_options.my, vdecay=position_options.vdecay, mdecay=position_options.mdecay) # Step limit for stability _max_shift = cp.minimum( max_shift, _mad( cp.concatenate((step_x, step_y), axis=-1), axis=-1, keepdims=True, ), ) step_x = cp.maximum(-_max_shift, cp.minimum(step_x, _max_shift)) step_y = cp.maximum(-_max_shift, cp.minimum(step_y, _max_shift)) # Ensure net movement is zero step_x -= cp.mean(step_x, axis=-1, keepdims=True) step_y -= cp.mean(step_y, axis=-1, keepdims=True) logger.info('position update norm is %+.3e', tike.linalg.norm(step_x)) scan[..., 0] -= step_x scan[..., 1] -= step_y return scan, position_options
def test_min(self): @jit.rawkernel() def f(x, y, z, r): tid = jit.blockDim.x * jit.blockIdx.x + jit.threadIdx.x r[tid] = min(x[tid], y[tid], z[tid]) x = testing.shaped_random((1024,), dtype=numpy.int32, seed=0) y = testing.shaped_random((1024,), dtype=numpy.int32, seed=1) z = testing.shaped_random((1024,), dtype=numpy.int32, seed=2) r = testing.shaped_random((1024,), dtype=numpy.int32, seed=3) f((8,), (128,), (x, y, z, r)) expected = cupy.minimum(x, cupy.minimum(y, z)) assert bool((r == expected).all())
def max_white(nimg): if nimg.dtype == np.uint8: brightest = float(2**8) elif nimg.dtype == np.uint16: brightest = float(2**16) elif nimg.dtype == np.uint32: brightest = float(2**32) else: brightest = float(2**8) nimg = nimg.transpose(2, 0, 1) nimg = nimg.astype(np.int32) nimg[0] = np.minimum(nimg[0] * (brightest / float(nimg[0].max())), 255) nimg[1] = np.minimum(nimg[1] * (brightest / float(nimg[1].max())), 255) nimg[2] = np.minimum(nimg[2] * (brightest / float(nimg[2].max())), 255) return nimg.transpose(1, 2, 0).astype(np.uint8)
def _nms_boxes(self, boxes, box_confidences): """Apply the Non-Maximum Suppression (NMS) algorithm on the bounding boxes with their confidence scores and return an array with the indexes of the bounding boxes we want to keep (and display later). Keyword arguments: boxes -- a NumPy array containing N bounding-box coordinates that survived filtering, with shape (N,4); 4 for x,y,height,width coordinates of the boxes box_confidences -- a Numpy array containing the corresponding confidences with shape N """ x_coord = boxes[:, 0] y_coord = boxes[:, 1] width = boxes[:, 2] height = boxes[:, 3] areas = width * height ordered = box_confidences.argsort()[::-1] keep = list() while ordered.size > 0: # Index of the current element: i = ordered[0] ii = cp.asnumpy(i) keep.append(ii) xx1 = cp.maximum(x_coord[i], x_coord[ordered[1:]]) yy1 = cp.maximum(y_coord[i], y_coord[ordered[1:]]) xx2 = cp.minimum(x_coord[i] + width[i], x_coord[ordered[1:]] + width[ordered[1:]]) yy2 = cp.minimum(y_coord[i] + height[i], y_coord[ordered[1:]] + height[ordered[1:]]) width1 = cp.maximum(0.0, xx2 - xx1 + 1) height1 = cp.maximum(0.0, yy2 - yy1 + 1) intersection = width1 * height1 union = (areas[i] + areas[ordered[1:]] - intersection) # Compute the Intersection over Union (IoU) score: iou = intersection / union # The goal of the NMS algorithm is to reduce the number of adjacent bounding-box # candidates to a minimum. In this step, we keep only those elements whose overlap # with the current bounding box is lower than the threshold: indexes = cp.where(iou <= self.nms_threshold)[0] ordered = ordered[indexes + 1] keep = np.array(keep) print(keep) keep = cp.asarray(keep) return keep
def _min_or_max(self, axis, out, min_or_max, sum_duplicates, non_zero): if out is not None: raise ValueError(("Sparse matrices do not support " "an 'out' parameter.")) util.validateaxis(axis) if axis is None: if 0 in self.shape: raise ValueError("zero-size array to reduction operation") zero = cupy.zeros((), dtype=self.dtype) if self.nnz == 0: return zero if sum_duplicates: self.sum_duplicates() m = min_or_max(self.data) if non_zero: return m if self.nnz != internal.prod(self.shape): if min_or_max is cupy.min: m = cupy.minimum(zero, m) elif min_or_max is cupy.max: m = cupy.maximum(zero, m) else: assert False return m if axis == 0 or axis == 1: return self._min_or_max_axis(axis, min_or_max, sum_duplicates, non_zero) else: raise ValueError("axis out of range")
def _min_or_max(self, axis, out, min_or_max, explicit): if out is not None: raise ValueError(("Sparse matrices do not support " "an 'out' parameter.")) sputils.validateaxis(axis) if axis is None: if 0 in self.shape: raise ValueError("zero-size array to reduction operation") zero = cupy.zeros((), dtype=self.dtype) if self.nnz == 0: return zero self.sum_duplicates() m = min_or_max(self.data) if explicit: return m if self.nnz != internal.prod(self.shape): if min_or_max is cupy.min: m = cupy.minimum(zero, m) elif min_or_max is cupy.max: m = cupy.maximum(zero, m) else: assert False return m if axis < 0: axis += 2 return self._min_or_max_axis(axis, min_or_max, explicit)
def ruzicka_mat(matrix_a, vector_new): matrix_a *= cp.arange(1023, -1, -1, dtype=cp.uint16) min_up = cp.minimum(cp.array(matrix_a), vector_new) max_down = cp.maximum(cp.array(matrix_a), vector_new) numerator = cp.sum(min_up, axis=1) denominator = cp.sum(max_down, axis=1) return cp.asnumpy(cp.divide(numerator, denominator))
def my_min(S1, sig, varargin=None): # returns a running minimum applied sequentially across a choice of dimensions and bin sizes # S1 is the matrix to be filtered # sig is either a scalar or a sequence of scalars, one for each axis to be filtered. # it's the plus/minus bin length for the minimum filter # varargin can be the dimensions to do filtering, if len(sig) != x.shape # if sig is scalar and no axes are provided, the default axis is 2 idims = 1 if varargin is not None: idims = varargin idims = _make_vect(idims) if _is_vect(idims) and _is_vect(sig): sigall = sig else: sigall = np.tile(sig, len(idims)) for sig, idim in zip(sigall, idims): Nd = S1.ndim S1 = cp.transpose(S1, [idim] + list(range(0, idim)) + list(range(idim + 1, Nd))) dsnew = S1.shape S1 = cp.reshape(S1, (S1.shape[0], -1), order='F') dsnew2 = S1.shape S1 = cp.concatenate((cp.full( (sig, dsnew2[1]), np.inf), S1, cp.full((sig, dsnew2[1]), np.inf)), axis=0) Smax = S1[:dsnew2[0], :] for j in range(1, 2 * sig + 1): Smax = cp.minimum(Smax, S1[j:j + dsnew2[0], :]) S1 = cp.reshape(Smax, dsnew, order='F') S1 = cp.transpose( S1, list(range(1, idim + 1)) + [0] + list(range(idim + 1, Nd))) return S1
def smearing(self, f, f_el, volt_mat, new_ind): ''' Produces B matrix by comparing voltages takes: f - array shape (n_nodes) f_el - array shape (n_electrodes) volt_mat - array shape (n_measurements, 2) new_ind - array shape (n_measurements) returns: b-matrix - array shape (n_measurements, n_nodes) ''' i = cp.arange(len(volt_mat)) f_volt0 = f_el[new_ind, volt_mat[:, 0].astype(int)] f_volt1 = f_el[new_ind, volt_mat[:, 1].astype(int)] min_fel = cp.minimum(f_volt0, f_volt1) max_fel = cp.maximum(f_volt0, f_volt1) b_matrix = cp.empty((len(volt_mat), self.n_pts+self.ne)) b_matrix[:] = (min_fel[:, None] < f[new_ind]) & (f[new_ind] <= max_fel[:, None]) return b_matrix
def constrain_variable_probe(variable_probe, weights): """Add the following constraints to variable probe weights 1. Remove outliars from weights 2. Enforce orthogonality once per epoch """ logger.info('Orthogonalize variable probes') variable_probe = tike.linalg.orthogonalize_gs( variable_probe, axis=(-3, -2, -1), ) logger.info('Remove outliars from variable probe weights') aevol = cp.abs(weights) weights = cp.minimum( aevol, 1.5 * cp.percentile( aevol, [95], axis=[-3], keepdims=True, ).astype(weights.dtype), ) * cp.sign(weights) # TODO: Smooth the weights as a function of the frame index. return variable_probe, weights
def genRecogBase(m, shape): """ Generate recognition database Arguments: m -- number of examples shape -- shape Returns: X -- images Y -- labels """ X = 0.5*cp.random.rand(m, shape[0], shape[1], shape[2]) Y = cp.zeros((3, m)) for i in range(m): typeM = np.random.randint(0, 3) if(typeM == 0): X[i, :, :, :] += cp.zeros(shape) Y[0, i] += 1 if(typeM == 1): X[i, :, :, :] += cp.ones(shape) Y[1, i] += 1 if(typeM == 2): X[i, :, :, np.random.randint(0, shape[2])] += cp.eye(shape[0], shape[1]) Y[2, i] += 1 return cp.minimum(X, 1), Y
def ruzicka_vec(vector_old, vector_new): vector_old_cp = cp.array(vector_old) * cp.arange( 1023, -1, -1, dtype=cp.uint16) min_up = cp.minimum(vector_old_cp, vector_new) max_down = cp.maximum(vector_old_cp, vector_new) numerator = cp.sum(min_up, axis=1) denominator = cp.sum(max_down, axis=1) return cp.asnumpy(cp.divide(numerator, denominator))
def clip(self, low, high): if not isinstance(low, VectorCupy): raise TypeError("Provided input low vector not a %s!" % self.whoami) if not isinstance(high, VectorCupy): raise TypeError("Provided input high vector not a %s!" % self.whoami) self.getNdArray()[:] = cp.minimum( cp.maximum(low.getNdArray(), self.getNdArray()), high.getNdArray()) return self
def getKernels(params): # this function makes upsampling kernels for the temporal components. # those are used for interpolating the biggest negative peak, # and aligning the template to that peak with sub-sample resolution # needs nup, the interpolation factor (default = 10) # also needs sig, the interpolation smoothness (default = 1) nup = params.nup sig = params.sig nt0min = params.nt0min nt0 = params.nt0 xs = cp.arange(1, nt0 + 1) ys = cp.linspace(.5, nt0 + .5, nt0 * nup + 1)[:-1] # these kernels are just standard kriging interpolators # first compute distances between the sample coordinates # for some reason, this seems to be circular, although the waveforms are not circular # I think the reason had to do with some constant offsets in some channels? d = cp.mod(xs[:, np.newaxis] - xs[np.newaxis, :] + nt0, nt0) d = cp.minimum(d, nt0 - d) # the kernel covariance uses a squared exponential of spatial scale sig Kxx = cp.exp(-d**2 / sig**2) # do the same for the kernel similarities between upsampled "test" timepoints and # the original coordinates d = cp.mod(ys[:, np.newaxis] - xs[np.newaxis, :] + nt0, nt0) d = cp.minimum(d, nt0 - d) Kyx = cp.exp(-d**2 / sig**2) # the upsampling matrix is given by the following formula, # with some light diagonal regularization of the matrix inversion B = cp.dot(Kyx, cp.linalg.inv(Kxx + .01 * cp.eye(nt0))) B = B.reshape((nup, nt0, nt0), order='F') # A is just a slice through this upsampling matrix corresponding to the most negative point # this is used to compute the biggest negative deflection (after upsampling) A = cp.squeeze(B[:, nt0min - 1, :]) B = cp.transpose(B, [1, 2, 0]) return A.astype(np.float64), B.astype(np.float64)
def log_likelihood(self,par,**args): for k,v in args.items(): if k=='X_train': X=cp.asarray(v) elif k=='y_train': y=cp.asarray(v) y_linear = cp.dot(X, par['weights']) + par['bias'] y_linear=cp.minimum(y_linear,-cp.log(cp.finfo(float).eps)) y_linear=cp.maximum(y_linear,-cp.log(1./cp.finfo(float).tiny-1.0)) return cp.sum(self.cross_entropy(y_linear,y))
def update_z(a_last, W, b, a, z_old, u, v, rho): z1 = np.matmul(W, a_last) + b - u / rho z2 = (z1 + a + v) / 2 z1 = np.minimum(z1, 0) z2 = np.maximum(z2, 0) value1 = z_obj(a_last, W, b, z1, u, v, a, rho) value2 = z_obj(a_last, W, b, z2, u, v, a, rho) z = z1 z[value1 > value2] = z2[value1 > value2] return z
def net(self,par,**args): for k,v in args.items(): if k=='X_train': X=cp.asarray(v) y_linear = cp.dot(X, par['weights']) + par['bias'] y_linear=cp.minimum(y_linear,-cp.log(cp.finfo(float).eps)) y_linear=cp.maximum(y_linear,-cp.log(1./cp.finfo(float).tiny-1.0)) #y_linear = cp.dot(X, par['weights']) yhat = self.sigmoid(y_linear) return yhat
def clipVector(self, low, high): """Function to bound vector values based on input vectors low and high""" if not isinstance(low, VectorCupy): raise TypeError("Provided input low vector not a %s!" % self.whoami) if not isinstance(high, VectorCupy): raise TypeError("Provided input high vector not a %s!" % self.whoami) self.getNdArray()[:] = cp.minimum( cp.maximum(low.getNdArray(), self.getNdArray()), high.getNdArray()) return self
def clip_gradient(self, gradient, threshold): # We do not use CuPy's linalg.norm, since it uses scalar reductions # using one CUDA block. This is a lot slower than the cuBLAS # implementation. def frobenius_norm(X): X_vec = X.reshape(-1) return cupy.cublas.nrm2(X_vec) grad_norm = cupy.maximum(frobenius_norm(gradient), 1e-12) gradient *= cupy.minimum(threshold, grad_norm) / grad_norm return gradient
def colour_iterations(i: np.ndarray) -> np.ndarray: li = np.log(i) img = np.empty((TILE_SIZE, TILE_SIZE, 3), dtype=np.uint8) img[:, :, 0] = (li * 255) % 255 img[:, :, 1] = 192 img[:, :, 2] = 128 + 13 * np.sin(li * 100) - np.minimum(115, (10000 * 13 / (10000 - i))) return img
def synaptic_plasticity(h, syn_x, syn_u, constants, use_stp, hidden_size): """ If required, applies STP updates to the hidden state and STP variables. If not required, just ensures correct hidden shape. """ # h = h[0,...] if h.ndim == 5 else False if use_stp: global which_step print("STARTING SYNAPTIC_PLASTICITY") print("running step {}".format(which_step)) print(which_step) which_step = which_step + 1 print("syn_x.shape") print(syn_x.shape) print("syn_u.shape") print(syn_u.shape) print("h.shape") print(h.shape) # input() syn_x += constants['alpha_std'] * ( 1 - syn_x) - constants['stp_mod'] * syn_u * syn_x * h syn_u += constants['alpha_stf'] * ( constants['U'] - syn_u) + constants['stp_mod'] * constants['U'] * (1 - syn_u) * h syn_x = cp.minimum(1., relu(syn_x)) syn_u = cp.minimum(1., relu(syn_u)) h_post = syn_u * syn_x * h else: h_post = h * cp.ones([1, 1, hidden_size], dtype=h.dtype) return h_post, syn_x, syn_u
def _select_next(self, X_pairwise, gain, idx): """This function will add the given item to the selected set.""" if self.cupy: self.current_values = cupy.minimum(self.max_values, self.current_values + X_pairwise) elif self.sparse: self.current_values = numpy.minimum(self.max_values, X_pairwise.toarray()[0] + self.current_values) else: self.current_values = numpy.minimum(self.max_values, self.current_values + X_pairwise) super(SaturatedCoverageSelection, self)._select_next( X_pairwise, gain, idx)
def generate_q_u_matrix(x_coordinate: cp.array, y_coordinate: cp.array) -> tuple: flatten_flag = x_coordinate.ndim > 1 if flatten_flag: x_coordinate = x_coordinate.flatten() y_coordinate = y_coordinate.flatten() t, u = cp.modf(y_coordinate) u = u.astype(int) uy = cp.vstack([ cp.minimum(cp.maximum(u - 1, 0), h - 1), cp.minimum(cp.maximum(u, 0), h - 1), cp.minimum(cp.maximum(u + 1, 0), h - 1), cp.minimum(cp.maximum(u + 2, 0), h - 1), ]).astype(int) Qy = cp.dot( coeff, cp.vstack([ cp.ones_like(t, dtype=cp.float32), t, cp.power(t, 2), cp.power(t, 3) ])) t, u = cp.modf(x_coordinate) u = u.astype(int) ux = cp.vstack([ cp.minimum(cp.maximum(u - 1, 0), w - 1), cp.minimum(cp.maximum(u, 0), w - 1), cp.minimum(cp.maximum(u + 1, 0), w - 1), cp.minimum(cp.maximum(u + 2, 0), w - 1), ]) Qx = cp.dot( coeff, cp.vstack([ cp.ones_like(t, dtype=cp.float32), t, cp.power(t, 2), cp.power(t, 3) ])) if flatten_flag: Qx = Qx.reshape(4, frame_n, int(w * mag)).transpose(1, 0, 2).copy() Qy = Qy.reshape(4, frame_n, int(h * mag)).transpose(1, 0, 2).copy() ux = ux.reshape(4, frame_n, int(w * mag)).transpose(1, 0, 2).copy() uy = uy.reshape(4, frame_n, int(h * mag)).transpose(1, 0, 2).copy() return Qx, Qy, ux, uy
def make_buddhabrot(x_min, x_max, x_dim, y_min, y_max, y_dim, iters, gens, sample_size): t0 = time.time() buddha_tensor = np.zeros((y_dim, x_dim), dtype=np.float32) for i in range(gens): iterate(buddha_tensor, x_min, x_max, x_dim, y_min, y_max, y_dim, iters, sample_size) print("\r\titeration: %d/%d" % (i + 1, gens), end='', flush=True) t1 = time.time() print_stats(buddha_tensor, x_dim, y_dim, t1 - t0) s = buddha_tensor.sum() buddha_tensor /= buddha_tensor.max() buddha_tensor = np.minimum(1.1 * buddha_tensor, buddha_tensor * .2 + .8) scipy.misc.toimage(np.asnumpy(buddha_tensor), cmin=0.0, cmax=1.0).save( "buddha_%dx%d_%d_%d.png" % (x_dim, y_dim, iters, s))
def _initialize_nets(self): self.weights = cp.random.normal( size=(self.pop_size, self.total, self.total), dtype='single') * cp.tile( cp.triu(cp.ones(shape=(self.total, self.total), dtype='bool_'), 1), (self.pop_size, 1, 1)) * (cp.random.uniform( size=(self.pop_size, self.total, self.total), dtype='single') < .5) self.weights[:, :, self.inputs:] *= cp.sqrt(4 / cp.minimum( cp.arange(self.inputs, self.total), self.inputs + self.hidden)) self.weights[:, :self.inputs, :self.inputs] = 0 self.weights[:, -self.outputs:, -self.outputs:] = cp.tile( cp.diag( cp.diag( cp.ones(shape=(self.outputs, self.outputs), dtype='bool_'))), (self.pop_size, 1, 1)) self.biases = cp.random.normal( size=(self.pop_size, 1, self.hidden + self.outputs), dtype='single') * .5
def reshape_to_yolo_size(img): input_height, input_width, _ = img.shape min_pixel = 320 # max_pixel = 608 max_pixel = 448 min_edge = xp.minimum(input_width, input_height) if min_edge < min_pixel: input_width *= min_pixel / min_edge input_height *= min_pixel / min_edge max_edge = xp.maximum(input_width, input_height) if max_edge > max_pixel: input_width *= max_pixel / max_edge input_height *= max_pixel / max_edge input_width = int(input_width / 32) * 32 input_height = int(input_height / 32) * 32 img = cv2.resize(img, (input_width, input_height)) return img
def Initialization_Pop(PopSize, Model): Dim = 0 SizeInform = [] LengthInform = [] Parameter = list(Model.parameters()) for i in range(0, len(Parameter)): SizeInform.append([Parameter[i].shape]) if len(Parameter[i].shape) < 2: Dim_module = Parameter[i].shape[0] else: Dim_module = np.array(numpy.prod(Parameter[i].shape)) LengthInform.extend([Dim_module]) Dim = Dim + Dim_module # Population = (np.random.random((PopSize, Dim * HiddenNum)) - 0.5) * 2 * ((np.power(6 / (Dim + HiddenNum), 1 / 2))) Dim = int(Dim) Population = np.random.rand(PopSize, Dim) - 0.5 for i in range(PopSize): Model.apply(weight_init) Population[i] = Extract_weight(Model, SizeInform) Population[i] = Population[i] * (np.random.rand(Dim) < ((i + 1) / PopSize) / 1) # Boundary = np.tile([[10], [-10]], [1, Dim]) Upper = np.tile(Boundary[0], (PopSize, 1)) Lower = np.tile(Boundary[1], (PopSize, 1)) Population = np.maximum(np.minimum(Upper, Population), Lower) # Boundary = np.tile([[20], [-20]], [1, Dim * HiddenNum]) Coding = 'Real' return Population, Boundary, Coding, SizeInform, LengthInform
def map_coordinates(input, coordinates, output=None, order=None, mode='constant', cval=0.0, prefilter=True): """Map the input array to new coordinates by interpolation. The array of coordinates is used to find, for each point in the output, the corresponding coordinates in the input. The value of the input at those coordinates is determined by spline interpolation of the requested order. The shape of the output is derived from that of the coordinate array by dropping the first axis. The values of the array along the first axis are the coordinates in the input array at which the output value is found. Args: input (cupy.ndarray): The input array. coordinates (array_like): The coordinates at which ``input`` is evaluated. output (cupy.ndarray or ~cupy.dtype): The array in which to place the output, or the dtype of the returned array. order (int): The order of the spline interpolation. If it is not given, order 1 is used. It is different from :mod:`scipy.ndimage` and can change in the future. Currently it supports only order 0 and 1. mode (str): Points outside the boundaries of the input are filled according to the given mode (``'constant'``, ``'nearest'``, ``'mirror'`` or ``'opencv'``). Default is ``'constant'``. cval (scalar): Value used for points outside the boundaries of the input if ``mode='constant'`` or ``mode='opencv'``. Default is 0.0 prefilter (bool): It is not used yet. It just exists for compatibility with :mod:`scipy.ndimage`. Returns: cupy.ndarray: The result of transforming the input. The shape of the output is derived from that of ``coordinates`` by dropping the first axis. .. seealso:: :func:`scipy.ndimage.map_coordinates` """ _check_parameter('map_coordinates', order, mode) if mode == 'opencv' or mode == '_opencv_edge': input = cupy.pad(input, [(1, 1)] * input.ndim, 'constant', constant_values=cval) coordinates = cupy.add(coordinates, 1) mode = 'constant' ret = _get_output(output, input, coordinates.shape[1:]) if mode == 'nearest': for i in six.moves.range(input.ndim): coordinates[i] = coordinates[i].clip(0, input.shape[i] - 1) elif mode == 'mirror': for i in six.moves.range(input.ndim): length = input.shape[i] - 1 if length == 0: coordinates[i] = 0 else: coordinates[i] = cupy.remainder(coordinates[i], 2 * length) coordinates[i] = 2 * cupy.minimum(coordinates[i], length) - coordinates[i] if input.dtype.kind in 'iu': input = input.astype(cupy.float32) if order == 0: out = input[tuple(cupy.rint(coordinates).astype(cupy.int32))] else: coordinates_floor = cupy.floor(coordinates).astype(cupy.int32) coordinates_ceil = coordinates_floor + 1 sides = [] for i in six.moves.range(input.ndim): # TODO(mizuno): Use array_equal after it is implemented if cupy.all(coordinates[i] == coordinates_floor[i]): sides.append([0]) else: sides.append([0, 1]) out = cupy.zeros(coordinates.shape[1], dtype=input.dtype) if input.dtype in (cupy.float64, cupy.complex128): weight = cupy.empty(coordinates.shape[1], dtype=cupy.float64) else: weight = cupy.empty(coordinates.shape[1], dtype=cupy.float32) for side in itertools.product(*sides): weight.fill(1) ind = [] for i in six.moves.range(input.ndim): if side[i] == 0: ind.append(coordinates_floor[i]) weight *= coordinates_ceil[i] - coordinates[i] else: ind.append(coordinates_ceil[i]) weight *= coordinates[i] - coordinates_floor[i] out += input[ind] * weight del weight if mode == 'constant': mask = cupy.zeros(coordinates.shape[1], dtype=cupy.bool_) for i in six.moves.range(input.ndim): mask += coordinates[i] < 0 mask += coordinates[i] > input.shape[i] - 1 out[mask] = cval del mask if ret.dtype.kind in 'iu': out = cupy.rint(out) ret[:] = out return ret