Python numpy.where() Examples
The following are 30 code examples for showing how to use numpy.where(). 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: MomentumContrast.pytorch Author: peisuke File: test.py License: MIT License | 6 votes |
def show(mnist, targets, ret): target_ids = range(len(set(targets))) colors = ['r', 'g', 'b', 'c', 'm', 'y', 'k', 'violet', 'orange', 'purple'] plt.figure(figsize=(12, 10)) ax = plt.subplot(aspect='equal') for label in set(targets): idx = np.where(np.array(targets) == label)[0] plt.scatter(ret[idx, 0], ret[idx, 1], c=colors[label], label=label) for i in range(0, len(targets), 250): img = (mnist[i][0] * 0.3081 + 0.1307).numpy()[0] img = OffsetImage(img, cmap=plt.cm.gray_r, zoom=0.5) ax.add_artist(AnnotationBbox(img, ret[i])) plt.legend() plt.show()
Example 2
Project: Collaborative-Learning-for-Weakly-Supervised-Object-Detection Author: Sunarker File: train_val.py License: MIT License | 6 votes |
def filter_roidb(roidb): """Remove roidb entries that have no usable RoIs.""" def is_valid(entry): # Valid images have: # (1) At least one foreground RoI OR # (2) At least one background RoI overlaps = entry['max_overlaps'] # find boxes with sufficient overlap fg_inds = np.where(overlaps >= cfg.TRAIN.FG_THRESH)[0] # Select background RoIs as those within [BG_THRESH_LO, BG_THRESH_HI) bg_inds = np.where((overlaps < cfg.TRAIN.BG_THRESH_HI) & (overlaps >= cfg.TRAIN.BG_THRESH_LO))[0] # image is only valid if such boxes exist valid = len(fg_inds) > 0 or len(bg_inds) > 0 return valid num = len(roidb) filtered_roidb = [entry for entry in roidb if is_valid(entry)] num_after = len(filtered_roidb) print('Filtered {} roidb entries: {} -> {}'.format(num - num_after, num, num_after)) return filtered_roidb
Example 3
Project: cgp-cnn Author: sg-nm File: cgp.py License: MIT License | 6 votes |
def _evaluation(self, pop, eval_flag): # create network list net_lists = [] active_index = np.where(eval_flag)[0] for i in active_index: net_lists.append(pop[i].active_net_list()) # evaluation fp = self.eval_func(net_lists) for i, j in enumerate(active_index): pop[j].eval = fp[i] evaluations = np.zeros(len(pop)) for i in range(len(pop)): evaluations[i] = pop[i].eval self.num_eval += len(net_lists) return evaluations
Example 4
Project: mmdetection Author: open-mmlab File: group_sampler.py License: Apache License 2.0 | 6 votes |
def __iter__(self): indices = [] for i, size in enumerate(self.group_sizes): if size == 0: continue indice = np.where(self.flag == i)[0] assert len(indice) == size np.random.shuffle(indice) num_extra = int(np.ceil(size / self.samples_per_gpu) ) * self.samples_per_gpu - len(indice) indice = np.concatenate( [indice, np.random.choice(indice, num_extra)]) indices.append(indice) indices = np.concatenate(indices) indices = [ indices[i * self.samples_per_gpu:(i + 1) * self.samples_per_gpu] for i in np.random.permutation( range(len(indices) // self.samples_per_gpu)) ] indices = np.concatenate(indices) indices = indices.astype(np.int64).tolist() assert len(indices) == self.num_samples return iter(indices)
Example 5
Project: NiBetaSeries Author: HBClab File: nistats.py License: MIT License | 6 votes |
def _lsa_events_converter(events_file): """Make a model where each trial has its own regressor using least squares all (LSA) Parameters ---------- events_file : str File that contains all events from the bold run Yields ------ events : DataFrame A DataFrame in which each trial has its own trial_type """ import pandas as pd events = pd.read_csv(events_file, sep='\t') events['original_trial_type'] = events['trial_type'] for cond, cond_df in events.groupby('trial_type'): cond_idx = cond_df.index for i_trial, trial_idx in enumerate(cond_idx): trial_name = '{0}_{1:04d}'.format(cond, i_trial+1) events.loc[trial_idx, 'trial_type'] = trial_name return events
Example 6
Project: neuropythy Author: noahbenson File: core.py License: GNU Affero General Public License v3.0 | 6 votes |
def to_cortex(c): ''' to_cortex(c) yields a Cortex object if the argument c can be coerced to one and otherwise raises an error. An object can be coerced to a Cortex object if: * it is a cortex object * it is a tuple (subject, h) where subject is a subject object and h is a subject hemisphere. ''' if is_cortex(c): return c elif pimms.is_vector(c) and len(c) == 2: (s,h) = c if is_subject(s) and pimms.is_str(h): if h in s.hemis: return s.hemis[h] else: raise ValueError('to_cortex: hemi %s not found in given subject' % h) raise ValueError('Could not coerce argument to Cortex object') #################################################################################################### # These functions deal with cortex_to_image and image_to_cortex interpolation:
Example 7
Project: neuropythy Author: noahbenson File: core.py License: GNU Affero General Public License v3.0 | 6 votes |
def to_potential(f): ''' to_potential(f) yields f if f is a potential function; if f is not, but f can be converted to a potential function, that conversion is performed then the result is yielded. to_potential(Ellipsis) yields a potential function whose output is simply its input (i.e., the identity function). to_potential(None) is equivalent to to_potential(0). The following can be converted into potential functions: * Anything for which pimms.is_array(x, 'number') yields True (i.e., arrays of constants). * Any tuple (g, h) where g(x) yields a potential value and h(x) yields a jacobian matrix for the parameter vector x. ''' if is_potential(f): return f elif f is Ellipsis: return identity elif pimms.is_array(f, 'number'): return const_potential(f) elif isinstance(f, tuple) and len(f) == 2: return PotentialLambda(f[0], f[1]) else: raise ValueError('Could not convert object of type %s to potential function' % type(f))
Example 8
Project: neuropythy Author: noahbenson File: core.py License: GNU Affero General Public License v3.0 | 6 votes |
def jacobian(self, params, into=None): params = flattest(params) n = len(params) ii = np.arange(n) (rs,cs,zs) = ([],[],[]) for ((mn,mx), f) in self.pieces_with_default: if len(ii) == 0: break k = np.where((params >= mn) & (params <= mx))[0] if len(k) == 0: continue kk = ii[k] j = f.jacobian(params[k]) if j.shape[0] == 1 and j.shape[1] > 1: j = repmat(j, j.shape[1], 1) (rj,cj,vj) = sps.find(j) rs.append(kk[rj]) cs.append(kk[cj]) zs.append(vj) ii = np.delete(ii, k) params = np.delete(params, k) (rs,cs,zs) = [np.concatenate(us) if len(us) > 0 else [] for us in (rs,cs,zs)] dz = sps.csr_matrix((zs, (rs,cs)), shape=(n,n)) return safe_into(into, dz)
Example 9
Project: neuropythy Author: noahbenson File: core.py License: GNU Affero General Public License v3.0 | 6 votes |
def signed_face_areas(faces, axis=1): ''' signed_face_areas(faces) yields a potential function f(x) that calculates the signed area of each face represented by the simplices matrix faces. If faces is None, then the parameters must arrive in the form of a flattened (n x 3 x 2) matrix where n is the number of triangles. Otherwise, the faces matrix must be either (n x 3) or (n x 3 x s); if the former, each row must list the vertex indices for the faces where the vertex matrix is presumed to be shaped (V x 2). Alternately, faces may be a full (n x 3 x 2) simplex array of the indices into the parameters. The optional argument axis (default: 1) may be set to 0 if the faces argument is a matrix but the coordinate matrix will be (2 x V) instead of (V x 2). ''' faces = np.asarray(faces) if len(faces.shape) == 2: if faces.shape[1] != 3: faces = faces.T n = 2 * (np.max(faces) + 1) if axis == 0: tmp = np.reshape(np.arange(n), (2,-1)).T else: tmp = np.reshape(np.arange(n), (-1,2)) faces = np.reshape(tmp[faces.flat], (-1,3,2)) faces = faces.flatten() return compose(TriangleSignedArea2DPotential(), part(Ellipsis, faces))
Example 10
Project: neuropythy Author: noahbenson File: core.py License: GNU Affero General Public License v3.0 | 6 votes |
def face_areas(faces, axis=1): ''' face_areas(faces) yields a potential function f(x) that calculates the unsigned area of each faces represented by the simplices matrix faces. If faces is None, then the parameters must arrive in the form of a flattened (n x 3 x 2) matrix where n is the number of triangles. Otherwise, the faces matrix must be either (n x 3) or (n x 3 x s); if the former, each row must list the vertex indices for the faces where the vertex matrix is presumed to be shaped (V x 2). Alternately, faces may be a full (n x 3 x 2) simplex array of the indices into the parameters. The optional argument axis (default: 1) may be set to 0 if the faces argument is a matrix but the coordinate matrix will be (2 x V) instead of (V x 2). ''' faces = np.asarray(faces) if len(faces.shape) == 2: if faces.shape[1] != 3: faces = faces.T n = 2 * (np.max(faces) + 1) if axis == 0: tmp = np.reshape(np.arange(n), (2,-1)).T else: tmp = np.reshape(np.arange(n), (-1,2)) faces = np.reshape(tmp[faces.flat], (-1,3,2)) faces = faces.flatten() return compose(TriangleArea2DPotential(), part(Ellipsis, faces))
Example 11
Project: neuropythy Author: noahbenson File: core.py License: GNU Affero General Public License v3.0 | 6 votes |
def dataframe_select(df, *cols, **filters): ''' dataframe_select(df, k1=v1, k2=v2...) yields df after selecting all the columns in which the given keys (k1, k2, etc.) have been selected such that the associated columns in the dataframe contain only the rows whose cells match the given values. dataframe_select(df, col1, col2...) selects the given columns. dataframe_select(df, col1, col2..., k1=v1, k2=v2...) selects both. If a value is a tuple/list of 2 elements, then it is considered a range where cells must fall between the values. If value is a tuple/list of more than 2 elements or is a set of any length then it is a list of values, any one of which can match the cell. ''' ii = np.ones(len(df), dtype='bool') for (k,v) in six.iteritems(filters): vals = df[k].values if pimms.is_set(v): jj = np.isin(vals, list(v)) elif pimms.is_vector(v) and len(v) == 2: jj = (v[0] <= vals) & (vals < v[1]) elif pimms.is_vector(v): jj = np.isin(vals, list(v)) else: jj = (vals == v) ii = np.logical_and(ii, jj) if len(ii) != np.sum(ii): df = df.loc[ii] if len(cols) > 0: df = df[list(cols)] return df
Example 12
Project: neuropythy Author: noahbenson File: core.py License: GNU Affero General Public License v3.0 | 6 votes |
def arccosine(x, null=(-np.inf, np.inf)): ''' arccosine(x) is equivalent to acos(x) except that it also works on sparse arrays. The optional argument null (default, (-numpy.inf, numpy.inf)) may be specified to indicate what value(s) should be assigned when x < -1 or x > 1. If only one number is given, then it is used for both values; otherwise the first value corresponds to <-1 and the second to >1. If null is None, then an error is raised when invalid values are encountered. ''' if sps.issparse(x): x = x.toarray() else: x = np.asarray(x) try: (nln,nlp) = null except Exception: (nln,nlp) = (null,null) ii = None if nln is None else np.where(x < -1) jj = None if nlp is None else np.where(x > 1) if ii: x[ii] = 0 if jj: x[jj] = 0 x = np.arccos(x) if ii: x[ii] = nln if jj: x[jj] = nlp return x
Example 13
Project: neuropythy Author: noahbenson File: core.py License: GNU Affero General Public License v3.0 | 6 votes |
def splrep(coordinates, t, order, weights, smoothing, periodic): from scipy import interpolate (x,y) = coordinates # we need to skip anything where t[i] and t[i+1] are too close wh = np.where(np.isclose(np.diff(t), 0))[0] if len(wh) > 0: (t,x,y) = [np.array(u) for u in (t,x,y)] ii = np.arange(len(t)) for i in reversed(wh): ii[i+1:-1] = ii[i+2:] for u in (t,x,y): u[i] = np.mean(u[i:i+2]) ii = ii[:-len(wh)] (t,x,y) = [u[ii] for u in (t,x,y)] xtck = interpolate.splrep(t, x, k=order, s=smoothing, w=weights, per=periodic) ytck = interpolate.splrep(t, y, k=order, s=smoothing, w=weights, per=periodic) return tuple([tuple([pimms.imm_array(u) for u in tck]) for tck in (xtck,ytck)])
Example 14
Project: fullrmc Author: bachiraoun File: Collection.py License: GNU Affero General Public License v3.0 | 6 votes |
def collect(self, index, dataDict, check=True): """ Collect atom given its index. :Parameters: #. index (int): The atom index to collect. #. dataDict (dict): The atom data dict to collect. #. check (boolean): Whether to check dataDict keys before collecting. If set to False, user promises that collected data is a dictionary and contains the needed keys. """ assert not self.is_collected(index), LOGGER.error("attempting to collect and already collected atom of index '%i'"%index) # add data if check: assert isinstance(dataDict, dict), LOGGER.error("dataDict must be a dictionary of data where keys are dataKeys") assert tuple(sorted(dataDict)) == self.__dataKeys, LOGGER.error("dataDict keys don't match promised dataKeys") self.__collectedData[index] = dataDict # set indexes sorted array idx = np.searchsorted(a=self.__indexesSortedArray, v=index, side='left') self.__indexesSortedArray = np.insert(self.__indexesSortedArray, idx, index) # set state self.__state = str(uuid.uuid1())
Example 15
Project: RF-Monitor Author: EarToEarOak File: cli.py License: GNU General Public License v2.0 | 5 votes |
def __on_scan_data(self, event): levels = numpy.log10(event['l']) levels *= 10 noise = numpy.percentile(levels, self._dynP) for monitor in self._monitors: freq = monitor.get_frequency() if monitor.get_enabled(): monitor.set_noise(noise) index = numpy.where(freq == event['f'])[0] signal = monitor.set_level(levels[index][0], event['timestamp'], self._location) if signal is not None: signals = 'Signals: {}\r'.format(self.__count_signals() - self._signalCount) self.__std_out(signals, False) if signal.end is not None: recording = format_recording(freq, signal) if self._pushUri is not None: self._push.send(self._pushUri, recording) if self._server is not None: self._server.send(recording) if self._json: sys.stdout.write(recording + '\n')
Example 16
Project: RF-Monitor Author: EarToEarOak File: gui.py License: GNU General Public License v2.0 | 5 votes |
def __on_scan_data(self, event): levels = numpy.log10(event['l']) levels *= 10 self._levels = levels noise = numpy.percentile(levels, self._toolbar.get_dynamic_percentile()) updated = False for monitor in self._monitors: freq = monitor.get_frequency() if monitor.get_enabled(): monitor.set_noise(noise) index = numpy.where(freq == event['f'])[0] signal = monitor.set_level(levels[index][0], event['timestamp'], self._location) if signal is not None: updated = True if signal.end is not None: recording = format_recording(freq, signal) if self._settings.get_push_enable(): self._push.send(self._settings.get_push_uri(), recording) if self._server is not None: self._server.send(recording) if updated: if self._isSaved: self._isSaved = False self.__set_title() self.__set_timeline() self.__set_spectrum(noise) self._rssi.set_noise(numpy.mean(levels)) self._rssi.set_level(numpy.max(levels))
Example 17
Project: Collaborative-Learning-for-Weakly-Supervised-Object-Detection Author: Sunarker File: layer.py License: MIT License | 5 votes |
def _shuffle_roidb_inds(self): """Randomly permute the training roidb.""" # If the random flag is set, # then the database is shuffled according to system time # Useful for the validation set if self._random: st0 = np.random.get_state() millis = int(round(time.time() * 1000)) % 4294967295 np.random.seed(millis) if cfg.TRAIN.ASPECT_GROUPING: raise NotImplementedError ''' widths = np.array([r['width'] for r in self._roidb]) heights = np.array([r['height'] for r in self._roidb]) horz = (widths >= heights) vert = np.logical_not(horz) horz_inds = np.where(horz)[0] vert_inds = np.where(vert)[0] inds = np.hstack(( np.random.permutation(horz_inds), np.random.permutation(vert_inds))) inds = np.reshape(inds, (-1, 2)) row_perm = np.random.permutation(np.arange(inds.shape[0])) inds = np.reshape(inds[row_perm, :], (-1,)) self._perm = inds ''' else: self._perm = np.random.permutation(np.arange(len(self._roidb))) # Restore the random state if self._random: np.random.set_state(st0) self._cur = 0
Example 18
Project: Collaborative-Learning-for-Weakly-Supervised-Object-Detection Author: Sunarker File: train_val.py License: MIT License | 5 votes |
def remove_snapshot(self, np_paths, ss_paths): to_remove = len(np_paths) - cfg.TRAIN.SNAPSHOT_KEPT for c in range(to_remove): nfile = np_paths[0] os.remove(str(nfile)) np_paths.remove(nfile) to_remove = len(ss_paths) - cfg.TRAIN.SNAPSHOT_KEPT for c in range(to_remove): sfile = ss_paths[0] # To make the code compatible to earlier versions of Tensorflow, # where the naming tradition for checkpoints are different os.remove(str(sfile)) ss_paths.remove(sfile)
Example 19
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 20
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 21
Project: Collaborative-Learning-for-Weakly-Supervised-Object-Detection Author: Sunarker File: coco.py License: MIT License | 5 votes |
def __init__(self, image_set, year): imdb.__init__(self, 'coco_' + year + '_' + image_set) # COCO specific config options self.config = {'use_salt': True, 'cleanup': True} # name, paths self._year = year self._image_set = image_set self._data_path = osp.join(cfg.DATA_DIR, 'coco') # load COCO API, classes, class <-> id mappings self._COCO = COCO(self._get_ann_file()) cats = self._COCO.loadCats(self._COCO.getCatIds()) self._classes = tuple(['__background__'] + [c['name'] for c in cats]) self._class_to_ind = dict(list(zip(self.classes, list(range(self.num_classes))))) self._class_to_coco_cat_id = dict(list(zip([c['name'] for c in cats], self._COCO.getCatIds()))) self._image_index = self._load_image_set_index() # Default to roidb handler self.set_proposal_method('gt') self.competition_mode(False) # Some image sets are "views" (i.e. subsets) into others. # For example, minival2014 is a random 5000 image subset of val2014. # This mapping tells us where the view's images and proposals come from. self._view_map = { 'minival2014': 'val2014', # 5k val2014 subset 'valminusminival2014': 'val2014', # val2014 \setminus minival2014 'test-dev2015': 'test2015', } coco_name = image_set + year # e.g., "val2014" self._data_name = (self._view_map[coco_name] if coco_name in self._view_map else coco_name) # Dataset splits that have ground-truth annotations (test splits # do not have gt annotations) self._gt_splits = ('train', 'val', 'minival')
Example 22
Project: Collaborative-Learning-for-Weakly-Supervised-Object-Detection Author: Sunarker File: coco.py License: MIT License | 5 votes |
def _print_detection_eval_metrics(self, coco_eval): IoU_lo_thresh = 0.5 IoU_hi_thresh = 0.95 def _get_thr_ind(coco_eval, thr): ind = np.where((coco_eval.params.iouThrs > thr - 1e-5) & (coco_eval.params.iouThrs < thr + 1e-5))[0][0] iou_thr = coco_eval.params.iouThrs[ind] assert np.isclose(iou_thr, thr) return ind ind_lo = _get_thr_ind(coco_eval, IoU_lo_thresh) ind_hi = _get_thr_ind(coco_eval, IoU_hi_thresh) # precision has dims (iou, recall, cls, area range, max dets) # area range index 0: all area ranges # max dets index 2: 100 per image precision = \ coco_eval.eval['precision'][ind_lo:(ind_hi + 1), :, :, 0, 2] ap_default = np.mean(precision[precision > -1]) print(('~~~~ Mean and per-category AP @ IoU=[{:.2f},{:.2f}] ' '~~~~').format(IoU_lo_thresh, IoU_hi_thresh)) print('{:.1f}'.format(100 * ap_default)) for cls_ind, cls in enumerate(self.classes): if cls == '__background__': continue # minus 1 because of __background__ precision = coco_eval.eval['precision'][ind_lo:(ind_hi + 1), :, cls_ind - 1, 0, 2] ap = np.mean(precision[precision > -1]) print('{:.1f}'.format(100 * ap)) print('~~~~ Summary metrics ~~~~') coco_eval.summarize()
Example 23
Project: Collaborative-Learning-for-Weakly-Supervised-Object-Detection Author: Sunarker File: ds_utils.py License: MIT License | 5 votes |
def filter_small_boxes(boxes, min_size): w = boxes[:, 2] - boxes[:, 0] h = boxes[:, 3] - boxes[:, 1] keep = np.where((w >= min_size) & (h > min_size))[0] return keep
Example 24
Project: Collaborative-Learning-for-Weakly-Supervised-Object-Detection Author: Sunarker File: demo.py License: MIT License | 5 votes |
def vis_detections(im, class_name, dets, thresh=0.5): """Draw detected bounding boxes.""" inds = np.where(dets[:, -1] >= thresh)[0] if len(inds) == 0: return im = im[:, :, (2, 1, 0)] fig, ax = plt.subplots(figsize=(12, 12)) ax.imshow(im, aspect='equal') for i in inds: bbox = dets[i, :4] score = dets[i, -1] ax.add_patch( plt.Rectangle((bbox[0], bbox[1]), bbox[2] - bbox[0], bbox[3] - bbox[1], fill=False, edgecolor='red', linewidth=3.5) ) ax.text(bbox[0], bbox[1] - 2, '{:s} {:.3f}'.format(class_name, score), bbox=dict(facecolor='blue', alpha=0.5), fontsize=14, color='white') ax.set_title(('{} detections with ' 'p({} | box) >= {:.1f}').format(class_name, class_name, thresh), fontsize=14) plt.axis('off') plt.tight_layout() plt.draw()
Example 25
Project: ultra_secret_scripts Author: CharlesDankoff File: image_search.py License: GNU General Public License v3.0 | 5 votes |
def search_image_in_image(small_image, large_image, precision=0.95): template = small_image.astype(np.float32) img_rgb = large_image.astype(np.float32) template = cv2.cvtColor(template, cv2.COLOR_BGR2GRAY) img_rgb = cv2.cvtColor(img_rgb, cv2.COLOR_BGR2GRAY) res = cv2.matchTemplate(img_rgb, template, cv2.TM_CCOEFF_NORMED) threshold = precision loc = np.where(res >= threshold) found_positions = list(zip(*loc[::-1])) # print("FOUND: {}".format(found_positions)) return found_positions
Example 26
Project: mmdetection Author: open-mmlab File: base.py License: Apache License 2.0 | 5 votes |
def forward_train(self, imgs, img_metas, **kwargs): """ Args: img (list[Tensor]): List of tensors of shape (1, C, H, W). Typically these should be mean centered and std scaled. img_metas (list[dict]): List of image info dict where each dict has: 'img_shape', 'scale_factor', 'flip', and my also contain 'filename', 'ori_shape', 'pad_shape', and 'img_norm_cfg'. For details on the values of these keys, see :class:`mmdet.datasets.pipelines.Collect`. kwargs (keyword arguments): Specific to concrete implementation. """ pass
Example 27
Project: mmdetection Author: open-mmlab File: base.py License: Apache License 2.0 | 5 votes |
def forward_test(self, imgs, img_metas, **kwargs): """ Args: imgs (List[Tensor]): the outer list indicates test-time augmentations and inner Tensor should have a shape NxCxHxW, which contains all images in the batch. img_metas (List[List[dict]]): the outer list indicates test-time augs (multiscale, flip, etc.) and the inner list indicates images in a batch. """ for var, name in [(imgs, 'imgs'), (img_metas, 'img_metas')]: if not isinstance(var, list): raise TypeError(f'{name} must be a list, but got {type(var)}') num_augs = len(imgs) if num_augs != len(img_metas): raise ValueError(f'num of augmentations ({len(imgs)}) ' f'!= num of image meta ({len(img_metas)})') # TODO: remove the restriction of samples_per_gpu == 1 when prepared samples_per_gpu = imgs[0].size(0) assert samples_per_gpu == 1 if num_augs == 1: # proposals (List[List[Tensor]]): the outer list indicates # test-time augs (multiscale, flip, etc.) and the inner list # indicates images in a batch. # The Tensor should have a shape Px4, where P is the number of # proposals. if 'proposals' in kwargs: kwargs['proposals'] = kwargs['proposals'][0] return self.simple_test(imgs[0], img_metas[0], **kwargs) else: # TODO: support test augmentation for predefined proposals assert 'proposals' not in kwargs return self.aug_test(imgs, img_metas, **kwargs)
Example 28
Project: mmdetection Author: open-mmlab File: group_sampler.py License: Apache License 2.0 | 5 votes |
def __iter__(self): # deterministically shuffle based on epoch g = torch.Generator() g.manual_seed(self.epoch) indices = [] for i, size in enumerate(self.group_sizes): if size > 0: indice = np.where(self.flag == i)[0] assert len(indice) == size indice = indice[list(torch.randperm(int(size), generator=g))].tolist() extra = int( math.ceil( size * 1.0 / self.samples_per_gpu / self.num_replicas) ) * self.samples_per_gpu * self.num_replicas - len(indice) # pad indice tmp = indice.copy() for _ in range(extra // size): indice.extend(tmp) indice.extend(tmp[:extra % size]) indices.extend(indice) assert len(indices) == self.total_size indices = [ indices[j] for i in list( torch.randperm( len(indices) // self.samples_per_gpu, generator=g)) for j in range(i * self.samples_per_gpu, (i + 1) * self.samples_per_gpu) ] # subsample offset = self.num_samples * self.rank indices = indices[offset:offset + self.num_samples] assert len(indices) == self.num_samples return iter(indices)
Example 29
Project: mmdetection Author: open-mmlab File: custom.py License: Apache License 2.0 | 5 votes |
def _rand_another(self, idx): """Get another random index from the same group as the given index.""" pool = np.where(self.flag == self.flag[idx])[0] return np.random.choice(pool)
Example 30
Project: mmdetection Author: open-mmlab File: iou_balanced_neg_sampler.py License: Apache License 2.0 | 5 votes |
def sample_via_interval(self, max_overlaps, full_set, num_expected): """Sample according to the iou interval. Args: max_overlaps (torch.Tensor): IoU between bounding boxes and ground truth boxes. full_set (set(int)): A full set of indices of boxes。 num_expected (int): Number of expected samples。 Returns: np.ndarray: Indices of samples """ max_iou = max_overlaps.max() iou_interval = (max_iou - self.floor_thr) / self.num_bins per_num_expected = int(num_expected / self.num_bins) sampled_inds = [] for i in range(self.num_bins): start_iou = self.floor_thr + i * iou_interval end_iou = self.floor_thr + (i + 1) * iou_interval tmp_set = set( np.where( np.logical_and(max_overlaps >= start_iou, max_overlaps < end_iou))[0]) tmp_inds = list(tmp_set & full_set) if len(tmp_inds) > per_num_expected: tmp_sampled_set = self.random_choice(tmp_inds, per_num_expected) else: tmp_sampled_set = np.array(tmp_inds, dtype=np.int) sampled_inds.append(tmp_sampled_set) sampled_inds = np.concatenate(sampled_inds) if len(sampled_inds) < num_expected: num_extra = num_expected - len(sampled_inds) extra_inds = np.array(list(full_set - set(sampled_inds))) if len(extra_inds) > num_extra: extra_inds = self.random_choice(extra_inds, num_extra) sampled_inds = np.concatenate([sampled_inds, extra_inds]) return sampled_inds