Python numpy.maximum() Examples
The following are 30 code examples for showing how to use numpy.maximum(). These examples are extracted from open source projects. You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example.
You may check out the related API usage on the sidebar.
You may also want to check out all available functions/classes of the module
numpy
, or try the search function
.
Example 1
Project: DDPAE-video-prediction Author: jthsieh File: moving_mnist.py License: MIT License | 6 votes |
def generate_moving_mnist(self, num_digits=2): ''' Get random trajectories for the digits and generate a video. ''' data = np.zeros((self.n_frames_total, self.image_size_, self.image_size_), dtype=np.float32) for n in range(num_digits): # Trajectory start_y, start_x = self.get_random_trajectory(self.n_frames_total) ind = random.randint(0, self.mnist.shape[0] - 1) digit_image = self.mnist[ind] for i in range(self.n_frames_total): top = start_y[i] left = start_x[i] bottom = top + self.digit_size_ right = left + self.digit_size_ # Draw digit data[i, top:bottom, left:right] = np.maximum(data[i, top:bottom, left:right], digit_image) data = data[..., np.newaxis] return data
Example 2
Project: Adversarial-Face-Attack Author: ppwwyyxx File: face_attack.py License: GNU General Public License v3.0 | 6 votes |
def detect(self, img): """ img: rgb 3 channel """ minsize = 20 # minimum size of face threshold = [0.6, 0.7, 0.7] # three steps's threshold factor = 0.709 # scale factor bounding_boxes, _ = FaceDet.detect_face( img, minsize, self.pnet, self.rnet, self.onet, threshold, factor) area = (bounding_boxes[:, 2] - bounding_boxes[:, 0]) * (bounding_boxes[:, 3] - bounding_boxes[:, 1]) face_idx = area.argmax() bbox = bounding_boxes[face_idx][:4] # xy,xy margin = 32 x0 = np.maximum(bbox[0] - margin // 2, 0) y0 = np.maximum(bbox[1] - margin // 2, 0) x1 = np.minimum(bbox[2] + margin // 2, img.shape[1]) y1 = np.minimum(bbox[3] + margin // 2, img.shape[0]) x0, y0, x1, y1 = bbox = [int(k + 0.5) for k in [x0, y0, x1, y1]] cropped = img[y0:y1, x0:x1, :] scaled = cv2.resize(cropped, (160, 160), interpolation=cv2.INTER_LINEAR) return scaled, bbox
Example 3
Project: mmdetection Author: open-mmlab File: structures.py License: Apache License 2.0 | 6 votes |
def crop(self, bbox): """See :func:`BaseInstanceMasks.crop`.""" assert isinstance(bbox, np.ndarray) assert bbox.ndim == 1 # clip the boundary bbox = bbox.copy() bbox[0::2] = np.clip(bbox[0::2], 0, self.width) bbox[1::2] = np.clip(bbox[1::2], 0, self.height) x1, y1, x2, y2 = bbox w = np.maximum(x2 - x1, 1) h = np.maximum(y2 - y1, 1) if len(self.masks) == 0: cropped_masks = np.empty((0, h, w), dtype=np.uint8) else: cropped_masks = self.masks[:, y1:y1 + h, x1:x1 + w] return BitmapMasks(cropped_masks, h, w)
Example 4
Project: neural-fingerprinting Author: StephanZheng File: attacks_tf.py License: BSD 3-Clause "New" or "Revised" License | 6 votes |
def apply_perturbations(i, j, X, increase, theta, clip_min, clip_max): """ TensorFlow implementation for apply perturbations to input features based on salency maps :param i: index of first selected feature :param j: index of second selected feature :param X: a matrix containing our input features for our sample :param increase: boolean; true if we are increasing pixels, false otherwise :param theta: delta for each feature adjustment :param clip_min: mininum value for a feature in our sample :param clip_max: maximum value for a feature in our sample : return: a perturbed input feature matrix for a target class """ # perturb our input sample if increase: X[0, i] = np.minimum(clip_max, X[0, i] + theta) X[0, j] = np.minimum(clip_max, X[0, j] + theta) else: X[0, i] = np.maximum(clip_min, X[0, i] - theta) X[0, j] = np.maximum(clip_min, X[0, j] - theta) return X
Example 5
Project: dynamic-training-with-apache-mxnet-on-aws Author: awslabs File: gradcam.py License: Apache License 2.0 | 6 votes |
def backward(self, req, out_grad, in_data, out_data, in_grad, aux): if ReluOp.guided_backprop: # Get output and gradients of output y = out_data[0] dy = out_grad[0] # Zero out the negatives in the gradients of the output dy_positives = nd.maximum(dy, nd.zeros_like(dy)) # What output values were greater than 0? y_ones = y.__gt__(0) # Mask out the values for which at least one of dy or y is negative dx = dy_positives * y_ones self.assign(in_grad[0], req[0], dx) else: # Regular backward for ReLU x = in_data[0] x_gt_zero = x.__gt__(0) dx = out_grad[0] * x_gt_zero self.assign(in_grad[0], req[0], dx)
Example 6
Project: dynamic-training-with-apache-mxnet-on-aws Author: awslabs File: pascal_voc.py License: Apache License 2.0 | 6 votes |
def voc_ap(rec, prec, use_07_metric=False): if use_07_metric: ap = 0. for t in np.arange(0., 1.1, 0.1): if np.sum(rec >= t) == 0: p = 0 else: p = np.max(prec[rec >= t]) ap += p / 11. else: # append sentinel values at both ends mrec = np.concatenate(([0.], rec, [1.])) mpre = np.concatenate(([0.], prec, [0.])) # compute precision integration ladder for i in range(mpre.size - 1, 0, -1): mpre[i - 1] = np.maximum(mpre[i - 1], mpre[i]) # look for recall value changes i = np.where(mrec[1:] != mrec[:-1])[0] # sum (\delta recall) * prec ap = np.sum((mrec[i + 1] - mrec[i]) * mpre[i + 1]) return ap
Example 7
Project: dynamic-training-with-apache-mxnet-on-aws Author: awslabs File: test_quantization.py License: Apache License 2.0 | 6 votes |
def test_quantize_float32_to_int8(): shape = rand_shape_nd(4) data = rand_ndarray(shape, 'default', dtype='float32') min_range = mx.nd.min(data) max_range = mx.nd.max(data) qdata, min_val, max_val = mx.nd.contrib.quantize(data, min_range, max_range, out_type='int8') data_np = data.asnumpy() min_range = min_range.asscalar() max_range = max_range.asscalar() real_range = np.maximum(np.abs(min_range), np.abs(max_range)) quantized_range = 127.0 scale = quantized_range / real_range assert qdata.dtype == np.int8 assert min_val.dtype == np.float32 assert max_val.dtype == np.float32 assert same(min_val.asscalar(), -real_range) assert same(max_val.asscalar(), real_range) qdata_np = (np.sign(data_np) * np.minimum(np.abs(data_np) * scale + 0.5, quantized_range)).astype(np.int8) assert_almost_equal(qdata.asnumpy(), qdata_np, atol = 1)
Example 8
Project: DOTA_models Author: ringringyi File: graph_utils.py License: Apache License 2.0 | 6 votes |
def heuristic_fn_vec(n1, n2, n_ori, step_size): # n1 is a vector and n2 is a single point. dx = (n1[:,0] - n2[0,0])/step_size dy = (n1[:,1] - n2[0,1])/step_size dt = n1[:,2] - n2[0,2] dt = np.mod(dt, n_ori) dt = np.minimum(dt, n_ori-dt) if n_ori == 6: if dx*dy > 0: d = np.maximum(np.abs(dx), np.abs(dy)) else: d = np.abs(dy-dx) elif n_ori == 4: d = np.abs(dx) + np.abs(dy) return (d + dt).reshape((-1,1))
Example 9
Project: DOTA_models Author: ringringyi File: map_utils.py License: Apache License 2.0 | 6 votes |
def resize_maps(map, map_scales, resize_method): scaled_maps = [] for i, sc in enumerate(map_scales): if resize_method == 'antialiasing': # Resize using open cv so that we can compute the size. # Use PIL resize to use anti aliasing feature. map_ = cv2.resize(map*1, None, None, fx=sc, fy=sc, interpolation=cv2.INTER_LINEAR) w = map_.shape[1]; h = map_.shape[0] map_img = PIL.Image.fromarray((map*255).astype(np.uint8)) map__img = map_img.resize((w,h), PIL.Image.ANTIALIAS) map_ = np.asarray(map__img).astype(np.float32) map_ = map_/255. map_ = np.minimum(map_, 1.0) map_ = np.maximum(map_, 0.0) elif resize_method == 'linear_noantialiasing': map_ = cv2.resize(map*1, None, None, fx=sc, fy=sc, interpolation=cv2.INTER_LINEAR) else: logging.error('Unknown resizing method') scaled_maps.append(map_) return scaled_maps
Example 10
Project: DOTA_models Author: ringringyi File: np_box_ops.py License: Apache License 2.0 | 6 votes |
def intersection(boxes1, boxes2): """Compute pairwise intersection areas between boxes. Args: boxes1: a numpy array with shape [N, 4] holding N boxes boxes2: a numpy array with shape [M, 4] holding M boxes Returns: a numpy array with shape [N*M] representing pairwise intersection area """ [y_min1, x_min1, y_max1, x_max1] = np.split(boxes1, 4, axis=1) [y_min2, x_min2, y_max2, x_max2] = np.split(boxes2, 4, axis=1) all_pairs_min_ymax = np.minimum(y_max1, np.transpose(y_max2)) all_pairs_max_ymin = np.maximum(y_min1, np.transpose(y_min2)) intersect_heights = np.maximum( np.zeros(all_pairs_max_ymin.shape), all_pairs_min_ymax - all_pairs_max_ymin) all_pairs_min_xmax = np.minimum(x_max1, np.transpose(x_max2)) all_pairs_max_xmin = np.maximum(x_min1, np.transpose(x_min2)) intersect_widths = np.maximum( np.zeros(all_pairs_max_xmin.shape), all_pairs_min_xmax - all_pairs_max_xmin) return intersect_heights * intersect_widths
Example 11
Project: DOTA_models Author: ringringyi File: test_utils.py License: Apache License 2.0 | 6 votes |
def create_random_boxes(num_boxes, max_height, max_width): """Creates random bounding boxes of specific maximum height and width. Args: num_boxes: number of boxes. max_height: maximum height of boxes. max_width: maximum width of boxes. Returns: boxes: numpy array of shape [num_boxes, 4]. Each row is in form [y_min, x_min, y_max, x_max]. """ y_1 = np.random.uniform(size=(1, num_boxes)) * max_height y_2 = np.random.uniform(size=(1, num_boxes)) * max_height x_1 = np.random.uniform(size=(1, num_boxes)) * max_width x_2 = np.random.uniform(size=(1, num_boxes)) * max_width boxes = np.zeros(shape=(num_boxes, 4)) boxes[:, 0] = np.minimum(y_1, y_2) boxes[:, 1] = np.minimum(x_1, x_2) boxes[:, 2] = np.maximum(y_1, y_2) boxes[:, 3] = np.maximum(x_1, x_2) return boxes.astype(np.float32)
Example 12
Project: libTLDA Author: wmkouw File: util.py License: MIT License | 5 votes |
def nullspace(A, atol=1e-13, rtol=0): """ Compute an approximate basis for the nullspace of A. INPUT (1) array 'A': 1-D array with length k will be treated as a 2-D with shape (1, k). (2) float 'atol': the absolute tolerance for a zero singular value. Singular values smaller than `atol` are considered to be zero. (3) float 'rtol': relative tolerance. Singular values less than rtol*smax are considered to be zero, where smax is the largest singular value. If both `atol` and `rtol` are positive, the combined tolerance is the maximum of the two; tol = max(atol, rtol * smax) Singular values smaller than `tol` are considered to be zero. OUTPUT (1) array 'B': if A is an array with shape (m, k), then B will be an array with shape (k, n), where n is the estimated dimension of the nullspace of A. The columns of B are a basis for the nullspace; each element in np.dot(A, B) will be approximately zero. """ # Expand A to a matrix A = np.atleast_2d(A) # Singular value decomposition u, s, vh = al.svd(A) # Set tolerance tol = max(atol, rtol * s[0]) # Compute the number of non-zero entries nnz = (s >= tol).sum() # Conjugate and transpose to ensure real numbers ns = vh[nnz:].conj().T return ns
Example 13
Project: libTLDA Author: wmkouw File: tcpr.py License: MIT License | 5 votes |
def project_simplex(self, v, z=1.0): """ Project vector onto simplex using sorting. Reference: "Efficient Projections onto the L1-Ball for Learning in High Dimensions (Duchi, Shalev-Shwartz, Singer, Chandra, 2006)." Parameters ---------- v : array vector to be projected (n dimensions by 0) z : float constant (def: 1.0) Returns ------- w : array projected vector (n dimensions by 0) """ # Number of dimensions n = v.shape[0] # Sort vector mu = np.sort(v, axis=0)[::-1] # Find rho C = np.cumsum(mu) - z j = np.arange(n) + 1 rho = j[mu - C/j > 0][-1] # Define theta theta = C[mu - C/j > 0][-1] / float(rho) # Subtract theta from original vector and cap at 0 w = np.maximum(v - theta, 0) # Return projected vector return w
Example 14
Project: libTLDA Author: wmkouw File: rba.py License: MIT License | 5 votes |
def iwe_kernel_densities(self, X, Z, clip=1000): """ Estimate importance weights based on kernel density estimation. Parameters ---------- X : array source data (N samples by D features) Z : array target data (M samples by D features) clip : float maximum allowed value for individual weights (def: 1000) Returns ------- array importance weights (N samples by 1) """ # Data shapes N, DX = X.shape M, DZ = Z.shape # Assert equivalent dimensionalities assert DX == DZ # Compute probabilities based on source kernel densities pT = st.gaussian_kde(Z.T).pdf(X.T) pS = st.gaussian_kde(X.T).pdf(X.T) # Check for numerics assert not np.any(np.isnan(pT)) or np.any(pT == 0) assert not np.any(np.isnan(pS)) or np.any(pS == 0) # Compute importance weights iw = pT / pS # Clip importance weights return np.minimum(clip, np.maximum(0, iw))
Example 15
Project: fenics-topopt Author: zfergus File: filter.py License: MIT License | 5 votes |
def __init__(self, nelx, nely, rmin): """ Filter: Build (and assemble) the index+data vectors for the coo matrix format. """ nfilter = int(nelx * nely * ((2 * (np.ceil(rmin) - 1) + 1)**2)) iH = np.zeros(nfilter) jH = np.zeros(nfilter) sH = np.zeros(nfilter) cc = 0 for i in range(nelx): for j in range(nely): row = i * nely + j kk1 = int(np.maximum(i - (np.ceil(rmin) - 1), 0)) kk2 = int(np.minimum(i + np.ceil(rmin), nelx)) ll1 = int(np.maximum(j - (np.ceil(rmin) - 1), 0)) ll2 = int(np.minimum(j + np.ceil(rmin), nely)) for k in range(kk1, kk2): for l in range(ll1, ll2): col = k * nely + l fac = rmin - np.sqrt( ((i - k) * (i - k) + (j - l) * (j - l))) iH[cc] = row jH[cc] = col sH[cc] = np.maximum(0.0, fac) cc = cc + 1 # Finalize assembly and convert to csc format self.H = scipy.sparse.coo_matrix((sH, (iH, jH)), shape=(nelx * nely, nelx * nely)).tocsc() self.Hs = self.H.sum(1)
Example 16
Project: fenics-topopt Author: zfergus File: filter.py License: MIT License | 5 votes |
def filter_compliance_sensitivities(self, xPhys, dc, ft): if ft == 0: dc[:] = (np.asarray((self.H * (xPhys * dc))[np.newaxis].T / self.Hs)[:, 0] / np.maximum(0.001, xPhys)) elif ft == 1: dc[:] = np.asarray(self.H * (dc[np.newaxis].T / self.Hs))[:, 0]
Example 17
Project: fenics-topopt Author: zfergus File: filter.py License: MIT License | 5 votes |
def __init__(self, nelx, nely, rmin): """ Filter: Build (and assemble) the index+data vectors for the coo matrix format. """ nfilter = int(nelx * nely * ((2 * (np.ceil(rmin) - 1) + 1)**2)) iH = np.zeros(nfilter) jH = np.zeros(nfilter) sH = np.zeros(nfilter) cc = 0 for i in range(nelx): for j in range(nely): row = i * nely + j kk1 = int(np.maximum(i - (np.ceil(rmin) - 1), 0)) kk2 = int(np.minimum(i + np.ceil(rmin), nelx)) ll1 = int(np.maximum(j - (np.ceil(rmin) - 1), 0)) ll2 = int(np.minimum(j + np.ceil(rmin), nely)) for k in range(kk1, kk2): for l in range(ll1, ll2): col = k * nely + l fac = rmin - np.sqrt( ((i - k) * (i - k) + (j - l) * (j - l))) iH[cc] = row jH[cc] = col sH[cc] = np.maximum(0.0, fac) cc = cc + 1 # Finalize assembly and convert to csc format self.H = scipy.sparse.coo_matrix((sH, (iH, jH)), shape=(nelx * nely, nelx * nely)).tocsc() self.Hs = self.H.sum(1)
Example 18
Project: fenics-topopt Author: zfergus File: filter.py License: MIT License | 5 votes |
def filter_compliance_sensitivities(self, xPhys, dc, ft): if ft == 0: dc[:] = (np.asarray((self.H * (xPhys * dc))[np.newaxis].T / self.Hs)[:, 0] / np.maximum(0.001, xPhys)) elif ft == 1: dc[:] = np.asarray(self.H * (dc[np.newaxis].T / self.Hs))[:, 0]
Example 19
Project: Collaborative-Learning-for-Weakly-Supervised-Object-Detection Author: Sunarker File: test.py License: MIT License | 5 votes |
def _clip_boxes(boxes, im_shape): """Clip boxes to image boundaries.""" # x1 >= 0 boxes[:, 0::4] = np.maximum(boxes[:, 0::4], 0) # y1 >= 0 boxes[:, 1::4] = np.maximum(boxes[:, 1::4], 0) # x2 < im_shape[1] boxes[:, 2::4] = np.minimum(boxes[:, 2::4], im_shape[1] - 1) # y2 < im_shape[0] boxes[:, 3::4] = np.minimum(boxes[:, 3::4], im_shape[0] - 1) return boxes
Example 20
Project: Collaborative-Learning-for-Weakly-Supervised-Object-Detection Author: Sunarker File: test.py License: MIT License | 5 votes |
def apply_nms(all_boxes, thresh): """Apply non-maximum suppression to all predicted boxes output by the test_net method. """ num_classes = len(all_boxes) num_images = len(all_boxes[0]) nms_boxes = [[[] for _ in range(num_images)] for _ in range(num_classes)] for cls_ind in range(num_classes): for im_ind in range(num_images): dets = all_boxes[cls_ind][im_ind] if dets == []: continue x1 = dets[:, 0] y1 = dets[:, 1] x2 = dets[:, 2] y2 = dets[:, 3] scores = dets[:, 4] inds = np.where((x2 > x1) & (y2 > y1))[0] dets = dets[inds,:] if dets == []: continue keep = nms(torch.from_numpy(dets), thresh).numpy() if len(keep) == 0: continue nms_boxes[cls_ind][im_ind] = dets[keep, :].copy() return nms_boxes
Example 21
Project: Collaborative-Learning-for-Weakly-Supervised-Object-Detection Author: Sunarker File: test_train.py License: MIT License | 5 votes |
def _clip_boxes(boxes, im_shape): """Clip boxes to image boundaries.""" # x1 >= 0 boxes[:, 0::4] = np.maximum(boxes[:, 0::4], 0) # y1 >= 0 boxes[:, 1::4] = np.maximum(boxes[:, 1::4], 0) # x2 < im_shape[1] boxes[:, 2::4] = np.minimum(boxes[:, 2::4], im_shape[1] - 1) # y2 < im_shape[0] boxes[:, 3::4] = np.minimum(boxes[:, 3::4], im_shape[0] - 1) return boxes
Example 22
Project: Collaborative-Learning-for-Weakly-Supervised-Object-Detection Author: Sunarker File: test_train.py License: MIT License | 5 votes |
def apply_nms(all_boxes, thresh): """Apply non-maximum suppression to all predicted boxes output by the test_net method. """ num_classes = len(all_boxes) num_images = len(all_boxes[0]) nms_boxes = [[[] for _ in range(num_images)] for _ in range(num_classes)] for cls_ind in range(num_classes): for im_ind in range(num_images): dets = all_boxes[cls_ind][im_ind] if dets == []: continue x1 = dets[:, 0] y1 = dets[:, 1] x2 = dets[:, 2] y2 = dets[:, 3] scores = dets[:, 4] inds = np.where((x2 > x1) & (y2 > y1))[0] dets = dets[inds,:] if dets == []: continue keep = nms(torch.from_numpy(dets), thresh).numpy() if len(keep) == 0: continue nms_boxes[cls_ind][im_ind] = dets[keep, :].copy() return nms_boxes
Example 23
Project: Collaborative-Learning-for-Weakly-Supervised-Object-Detection Author: Sunarker File: voc_eval.py License: MIT License | 5 votes |
def voc_ap(rec, prec, use_07_metric=False): """ ap = voc_ap(rec, prec, [use_07_metric]) Compute VOC AP given precision and recall. If use_07_metric is true, uses the VOC 07 11 point method (default:False). """ if use_07_metric: # 11 point metric ap = 0. for t in np.arange(0., 1.1, 0.1): if np.sum(rec >= t) == 0: p = 0 else: p = np.max(prec[rec >= t]) ap = ap + p / 11. else: # correct AP calculation # first append sentinel values at the end mrec = np.concatenate(([0.], rec, [1.])) mpre = np.concatenate(([0.], prec, [0.])) # compute the precision envelope for i in range(mpre.size - 1, 0, -1): mpre[i - 1] = np.maximum(mpre[i - 1], mpre[i]) # to calculate area under PR curve, look for points # where X axis (recall) changes value i = np.where(mrec[1:] != mrec[:-1])[0] # and sum (\Delta recall) * prec ap = np.sum((mrec[i + 1] - mrec[i]) * mpre[i + 1]) return ap
Example 24
Project: disentangling_conditional_gans Author: zalandoresearch File: misc.py License: MIT License | 5 votes |
def setup_text_label(text, font='Calibri', fontsize=32, padding=6, glow_size=2.0, glow_coef=3.0, glow_exp=2.0, cache_size=100): # => (alpha, glow) # Lookup from cache. key = (text, font, fontsize, padding, glow_size, glow_coef, glow_exp) if key in _text_label_cache: value = _text_label_cache[key] del _text_label_cache[key] # LRU policy _text_label_cache[key] = value return value # Limit cache size. while len(_text_label_cache) >= cache_size: _text_label_cache.popitem(last=False) # Render text. import moviepy.editor # pip install moviepy alpha = moviepy.editor.TextClip(text, font=font, fontsize=fontsize).mask.make_frame(0) alpha = np.pad(alpha, padding, mode='constant', constant_values=0.0) glow = scipy.ndimage.gaussian_filter(alpha, glow_size) glow = 1.0 - np.maximum(1.0 - glow * glow_coef, 0.0) ** glow_exp # Add to cache. value = (alpha, glow) _text_label_cache[key] = value return value #----------------------------------------------------------------------------
Example 25
Project: dc_tts Author: Kyubyong File: utils.py License: Apache License 2.0 | 5 votes |
def griffin_lim(spectrogram): '''Applies Griffin-Lim's raw.''' X_best = copy.deepcopy(spectrogram) for i in range(hp.n_iter): X_t = invert_spectrogram(X_best) est = librosa.stft(X_t, hp.n_fft, hp.hop_length, win_length=hp.win_length) phase = est / np.maximum(1e-8, np.abs(est)) X_best = spectrogram * phase X_t = invert_spectrogram(X_best) y = np.real(X_t) return y
Example 26
Project: mmdetection Author: open-mmlab File: demodata.py License: Apache License 2.0 | 5 votes |
def random_boxes(num=1, scale=1, rng=None): """Simple version of ``kwimage.Boxes.random`` Returns: Tensor: shape (n, 4) in x1, y1, x2, y2 format. References: https://gitlab.kitware.com/computer-vision/kwimage/blob/master/kwimage/structs/boxes.py#L1390 Example: >>> num = 3 >>> scale = 512 >>> rng = 0 >>> boxes = random_boxes(num, scale, rng) >>> print(boxes) tensor([[280.9925, 278.9802, 308.6148, 366.1769], [216.9113, 330.6978, 224.0446, 456.5878], [405.3632, 196.3221, 493.3953, 270.7942]]) """ rng = ensure_rng(rng) tlbr = rng.rand(num, 4).astype(np.float32) tl_x = np.minimum(tlbr[:, 0], tlbr[:, 2]) tl_y = np.minimum(tlbr[:, 1], tlbr[:, 3]) br_x = np.maximum(tlbr[:, 0], tlbr[:, 2]) br_y = np.maximum(tlbr[:, 1], tlbr[:, 3]) tlbr[:, 0] = tl_x * scale tlbr[:, 1] = tl_y * scale tlbr[:, 2] = br_x * scale tlbr[:, 3] = br_y * scale boxes = torch.from_numpy(tlbr) return boxes
Example 27
Project: mmdetection Author: open-mmlab File: structures.py License: Apache License 2.0 | 5 votes |
def rescale(self, scale, interpolation='nearest'): """Rescale masks as large as possible while keeping the aspect ratio. For details can refer to `mmcv.imrescale`. Args: scale (tuple[int]): The maximum size (h, w) of rescaled mask. interpolation (str): Same as :func:`mmcv.imrescale`. Returns: BaseInstanceMasks: The rescaled masks. """ pass
Example 28
Project: mmdetection Author: open-mmlab File: structures.py License: Apache License 2.0 | 5 votes |
def crop_and_resize(self, bboxes, out_shape, inds, device='cpu', interpolation='bilinear'): """see :func:`BaseInstanceMasks.crop_and_resize`""" out_h, out_w = out_shape if len(self.masks) == 0: return PolygonMasks([], out_h, out_w) resized_masks = [] for i in range(len(bboxes)): mask = self.masks[inds[i]] bbox = bboxes[i, :] x1, y1, x2, y2 = bbox w = np.maximum(x2 - x1, 1) h = np.maximum(y2 - y1, 1) h_scale = out_h / max(h, 0.1) # avoid too large scale w_scale = out_w / max(w, 0.1) resized_mask = [] for p in mask: p = p.copy() # crop # pycocotools will clip the boundary p[0::2] -= bbox[0] p[1::2] -= bbox[1] # resize p[0::2] *= w_scale p[1::2] *= h_scale resized_mask.append(p) resized_masks.append(resized_mask) return PolygonMasks(resized_masks, *out_shape)
Example 29
Project: neural-fingerprinting Author: StephanZheng File: attacks_tf.py License: BSD 3-Clause "New" or "Revised" License | 5 votes |
def vatm(model, x, logits, eps, num_iterations=1, xi=1e-6, clip_min=None, clip_max=None, scope=None): """ Tensorflow implementation of the perturbation method used for virtual adversarial training: https://arxiv.org/abs/1507.00677 :param model: the model which returns the network unnormalized logits :param x: the input placeholder :param logits: the model's unnormalized output tensor (the input to the softmax layer) :param eps: the epsilon (input variation parameter) :param num_iterations: the number of iterations :param xi: the finite difference parameter :param clip_min: optional parameter that can be used to set a minimum value for components of the example returned :param clip_max: optional parameter that can be used to set a maximum value for components of the example returned :param seed: the seed for random generator :return: a tensor for the adversarial example """ with tf.name_scope(scope, "virtual_adversarial_perturbation"): d = tf.random_normal(tf.shape(x), dtype=tf_dtype) for i in range(num_iterations): d = xi * utils_tf.l2_batch_normalize(d) logits_d = model.get_logits(x + d) kl = utils_tf.kl_with_logits(logits, logits_d) Hd = tf.gradients(kl, d)[0] d = tf.stop_gradient(Hd) d = eps * utils_tf.l2_batch_normalize(d) adv_x = x + d if (clip_min is not None) and (clip_max is not None): adv_x = tf.clip_by_value(adv_x, clip_min, clip_max) return adv_x
Example 30
Project: Griffin_lim Author: candlewill File: audio.py License: MIT License | 5 votes |
def _mel_to_linear(mel_spectrogram): global _inv_mel_basis if _inv_mel_basis is None: _inv_mel_basis = np.linalg.pinv(_build_mel_basis()) return np.maximum(1e-10, np.dot(_inv_mel_basis, mel_spectrogram))