Python numpy.logical_not() Examples
The following are 30
code examples of numpy.logical_not().
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 also want to check out all available functions/classes of the module
numpy
, or try the search function
.
Example #1
Source File: test_kproxy_supercell_hf.py From pyscf with Apache License 2.0 | 6 votes |
def test_class(self): """Tests container behavior.""" model = kproxy_supercell.TDProxy(self.model_krhf, "hf", [self.k, 1, 1], density_fitting_hf) model.nroots = self.td_model_krhf.nroots assert not model.fast model.kernel() testing.assert_allclose(model.e, self.td_model_krhf.e, atol=1e-5) # Test real testing.assert_allclose(model.e.imag, 0, atol=1e-8) nocc = nvirt = 4 testing.assert_equal(model.xy.shape, (len(model.e), 2, self.k, self.k, nocc, nvirt)) # Test only non-degenerate roots d = abs(model.e[1:] - model.e[:-1]) < 1e-8 d = numpy.logical_or(numpy.concatenate(([False], d)), numpy.concatenate((d, [False]))) d = numpy.logical_not(d) assert_vectors_close(self.td_model_krhf.xy[d], model.xy[d], atol=1e-5)
Example #2
Source File: decision_making.py From pymoo with Apache License 2.0 | 6 votes |
def find_outliers_upper_tail(mu): # remove values that are nan I = np.where(np.logical_and(np.logical_not(np.isnan(mu)), np.logical_not(np.isinf(mu))))[0] mu = mu[I] # calculate mean and sigma mean, sigma = mu.mean(), mu.std() # calculate the deviation in terms of sigma deviation = (mu - mean) / sigma # 2 * sigma is considered as an outlier S = I[np.where(deviation >= 2)[0]] if len(S) == 0 and deviation.max() > 1: S = I[[np.argmax(mu)]] return S if len(S) > 0 else None
Example #3
Source File: balanced_positive_negative_sampler_test.py From object_detector_app with MIT License | 6 votes |
def test_subsample_selection(self): # Test random sampling when only some examples can be sampled: # 100 samples, 20 positives, 10 positives cannot be sampled numpy_labels = np.arange(100) numpy_indicator = numpy_labels < 90 indicator = tf.constant(numpy_indicator) numpy_labels = (numpy_labels - 80) >= 0 labels = tf.constant(numpy_labels) sampler = (balanced_positive_negative_sampler. BalancedPositiveNegativeSampler()) is_sampled = sampler.subsample(indicator, 64, labels) with self.test_session() as sess: is_sampled = sess.run(is_sampled) self.assertTrue(sum(is_sampled) == 64) self.assertTrue(sum(np.logical_and(numpy_labels, is_sampled)) == 10) self.assertTrue(sum(np.logical_and( np.logical_not(numpy_labels), is_sampled)) == 54) self.assertAllEqual(is_sampled, np.logical_and(is_sampled, numpy_indicator))
Example #4
Source File: balanced_positive_negative_sampler_test.py From object_detector_app with MIT License | 6 votes |
def test_subsample_all_examples(self): numpy_labels = np.random.permutation(300) indicator = tf.constant(np.ones(300) == 1) numpy_labels = (numpy_labels - 200) > 0 labels = tf.constant(numpy_labels) sampler = (balanced_positive_negative_sampler. BalancedPositiveNegativeSampler()) is_sampled = sampler.subsample(indicator, 64, labels) with self.test_session() as sess: is_sampled = sess.run(is_sampled) self.assertTrue(sum(is_sampled) == 64) self.assertTrue(sum(np.logical_and(numpy_labels, is_sampled)) == 32) self.assertTrue(sum(np.logical_and( np.logical_not(numpy_labels), is_sampled)) == 32)
Example #5
Source File: data_loader.py From Face-skin-hair-segmentaiton-and-skin-color-evaluation with Apache License 2.0 | 6 votes |
def _get_result_map(self, mask): """Processing mask data""" # mask.shape[0]: row, mask.shape[1]: column result_map = np.zeros((mask.shape[1], mask.shape[0], self.nb_classes)) # 0 (background pixel), 128 (face area pixel) or 255 (hair area pixel). skin = (mask == 128) hair = (mask == 255) if self.nb_classes == 2: # hair = (mask > 128) background = np.logical_not(hair) result_map[:, :, 0] = np.where(background, 1, 0) result_map[:, :, 1] = np.where(hair, 1, 0) elif self.nb_classes == 3: background = np.logical_not(hair + skin) result_map[:, :, 0] = np.where(background, 1, 0) result_map[:, :, 1] = np.where(skin, 1, 0) result_map[:, :, 2] = np.where(hair, 1, 0) else: raise Exception("error...") return result_map
Example #6
Source File: test_extras.py From recruit with Apache License 2.0 | 6 votes |
def test_2d_with_missing(self): # Test cov on 2D variable w/ missing value x = self.data x[-1] = masked x = x.reshape(3, 4) valid = np.logical_not(getmaskarray(x)).astype(int) frac = np.dot(valid, valid.T) xf = (x - x.mean(1)[:, None]).filled(0) assert_almost_equal(cov(x), np.cov(xf) * (x.shape[1] - 1) / (frac - 1.)) assert_almost_equal(cov(x, bias=True), np.cov(xf, bias=True) * x.shape[1] / frac) frac = np.dot(valid.T, valid) xf = (x - x.mean(0)).filled(0) assert_almost_equal(cov(x, rowvar=False), (np.cov(xf, rowvar=False) * (x.shape[0] - 1) / (frac - 1.))) assert_almost_equal(cov(x, rowvar=False, bias=True), (np.cov(xf, rowvar=False, bias=True) * x.shape[0] / frac))
Example #7
Source File: balanced_positive_negative_sampler_test.py From vehicle_counting_tensorflow with MIT License | 6 votes |
def test_subsample_all_examples_dynamic(self): numpy_labels = np.random.permutation(300) indicator = tf.constant(np.ones(300) == 1) numpy_labels = (numpy_labels - 200) > 0 labels = tf.constant(numpy_labels) sampler = ( balanced_positive_negative_sampler.BalancedPositiveNegativeSampler()) is_sampled = sampler.subsample(indicator, 64, labels) with self.test_session() as sess: is_sampled = sess.run(is_sampled) self.assertTrue(sum(is_sampled) == 64) self.assertTrue(sum(np.logical_and(numpy_labels, is_sampled)) == 32) self.assertTrue(sum(np.logical_and( np.logical_not(numpy_labels), is_sampled)) == 32)
Example #8
Source File: test_ufunc.py From recruit with Apache License 2.0 | 6 votes |
def test_object_logical(self): a = np.array([3, None, True, False, "test", ""], dtype=object) assert_equal(np.logical_or(a, None), np.array([x or None for x in a], dtype=object)) assert_equal(np.logical_or(a, True), np.array([x or True for x in a], dtype=object)) assert_equal(np.logical_or(a, 12), np.array([x or 12 for x in a], dtype=object)) assert_equal(np.logical_or(a, "blah"), np.array([x or "blah" for x in a], dtype=object)) assert_equal(np.logical_and(a, None), np.array([x and None for x in a], dtype=object)) assert_equal(np.logical_and(a, True), np.array([x and True for x in a], dtype=object)) assert_equal(np.logical_and(a, 12), np.array([x and 12 for x in a], dtype=object)) assert_equal(np.logical_and(a, "blah"), np.array([x and "blah" for x in a], dtype=object)) assert_equal(np.logical_not(a), np.array([not x for x in a], dtype=object)) assert_equal(np.logical_or.reduce(a), 3) assert_equal(np.logical_and.reduce(a), None)
Example #9
Source File: balanced_positive_negative_sampler_test.py From DOTA_models with Apache License 2.0 | 6 votes |
def test_subsample_selection(self): # Test random sampling when only some examples can be sampled: # 100 samples, 20 positives, 10 positives cannot be sampled numpy_labels = np.arange(100) numpy_indicator = numpy_labels < 90 indicator = tf.constant(numpy_indicator) numpy_labels = (numpy_labels - 80) >= 0 labels = tf.constant(numpy_labels) sampler = (balanced_positive_negative_sampler. BalancedPositiveNegativeSampler()) is_sampled = sampler.subsample(indicator, 64, labels) with self.test_session() as sess: is_sampled = sess.run(is_sampled) self.assertTrue(sum(is_sampled) == 64) self.assertTrue(sum(np.logical_and(numpy_labels, is_sampled)) == 10) self.assertTrue(sum(np.logical_and( np.logical_not(numpy_labels), is_sampled)) == 54) self.assertAllEqual(is_sampled, np.logical_and(is_sampled, numpy_indicator))
Example #10
Source File: balanced_positive_negative_sampler_test.py From DOTA_models with Apache License 2.0 | 6 votes |
def test_subsample_all_examples(self): numpy_labels = np.random.permutation(300) indicator = tf.constant(np.ones(300) == 1) numpy_labels = (numpy_labels - 200) > 0 labels = tf.constant(numpy_labels) sampler = (balanced_positive_negative_sampler. BalancedPositiveNegativeSampler()) is_sampled = sampler.subsample(indicator, 64, labels) with self.test_session() as sess: is_sampled = sess.run(is_sampled) self.assertTrue(sum(is_sampled) == 64) self.assertTrue(sum(np.logical_and(numpy_labels, is_sampled)) == 32) self.assertTrue(sum(np.logical_and( np.logical_not(numpy_labels), is_sampled)) == 32)
Example #11
Source File: balanced_positive_negative_sampler_test.py From vehicle_counting_tensorflow with MIT License | 6 votes |
def test_subsample_selection_no_batch_size(self): # Test random sampling when only some examples can be sampled: # 1000 samples, 6 positives (5 can be sampled). numpy_labels = np.arange(1000) numpy_indicator = numpy_labels < 999 indicator = tf.constant(numpy_indicator) numpy_labels = (numpy_labels - 994) >= 0 labels = tf.constant(numpy_labels) sampler = (balanced_positive_negative_sampler. BalancedPositiveNegativeSampler(0.01)) is_sampled = sampler.subsample(indicator, None, labels) with self.test_session() as sess: is_sampled = sess.run(is_sampled) self.assertTrue(sum(is_sampled) == 500) self.assertTrue(sum(np.logical_and(numpy_labels, is_sampled)) == 5) self.assertTrue(sum(np.logical_and( np.logical_not(numpy_labels), is_sampled)) == 495) self.assertAllEqual(is_sampled, np.logical_and(is_sampled, numpy_indicator))
Example #12
Source File: balanced_positive_negative_sampler_test.py From vehicle_counting_tensorflow with MIT License | 6 votes |
def test_subsample_selection_larger_batch_size_static(self): # Test random sampling when total number of examples that can be sampled are # less than batch size: # 100 samples, 50 positives, 40 positives cannot be sampled, batch size 64. # It should still return 64 samples, with 4 of them that couldn't have been # sampled. numpy_labels = np.arange(100) numpy_indicator = numpy_labels < 60 indicator = np.array(numpy_indicator, np.bool) numpy_labels = (numpy_labels - 50) >= 0 labels = np.array(numpy_labels, np.bool) def graph_fn(indicator, labels): sampler = ( balanced_positive_negative_sampler.BalancedPositiveNegativeSampler( is_static=True)) return sampler.subsample(indicator, 64, labels) is_sampled = self.execute(graph_fn, [indicator, labels]) self.assertTrue(sum(is_sampled) == 64) self.assertTrue(sum(np.logical_and(numpy_labels, is_sampled)) >= 10) self.assertTrue( sum(np.logical_and(np.logical_not(numpy_labels), is_sampled)) >= 50) self.assertTrue(sum(np.logical_and(is_sampled, numpy_indicator)) == 60)
Example #13
Source File: geometry.py From connecting_the_dots with MIT License | 6 votes |
def color_pcl(pcl, K, im, color_axis=0, as_int=True, invalid_color=[0,0,0]): uvd = K @ pcl.T uvd /= uvd[2] uvd = np.round(uvd).astype(np.int32) mask = np.logical_and(uvd[0] >= 0, uvd[1] >= 0) color = np.empty((pcl.shape[0], 3), dtype=im.dtype) if color_axis == 0: mask = np.logical_and(mask, uvd[0] < im.shape[2]) mask = np.logical_and(mask, uvd[1] < im.shape[1]) uvd = uvd[:,mask] color[mask,:] = im[:,uvd[1],uvd[0]].T elif color_axis == 2: mask = np.logical_and(mask, uvd[0] < im.shape[1]) mask = np.logical_and(mask, uvd[1] < im.shape[0]) uvd = uvd[:,mask] color[mask,:] = im[uvd[1],uvd[0], :] else: raise Exception('invalid color_axis') color[np.logical_not(mask),:3] = invalid_color if as_int: color = (255.0 * color).astype(np.int32) return color
Example #14
Source File: rj.py From SAR-change-detection with MIT License | 6 votes |
def number_of_changes(self, percent): """ The 'point of change' algorithm for each pixel, vectorized using numpy array operations Returns a 1D array """ image_shape = self.shape j = np.ones(self.size, dtype=int) l = np.ones(self.size, dtype=int) result = np.zeros(self.size, dtype=np.float32) for repeat in range(1, self.k): # Numpy array indexing black magic to obtain an image mask # indicating if there is change at this (l, j) time point change_mask = (1 - self.K[l, j, np.arange(self.size)]) < percent # Where there is change l[change_mask] += j[change_mask] j[change_mask] = 1 result[change_mask] += 1 # Where there is no change j[np.logical_not(change_mask)] += 1 return result
Example #15
Source File: balanced_positive_negative_sampler_test.py From vehicle_counting_tensorflow with MIT License | 6 votes |
def test_subsample_selection_static(self): # Test random sampling when only some examples can be sampled: # 100 samples, 20 positives, 10 positives cannot be sampled. numpy_labels = np.arange(100) numpy_indicator = numpy_labels < 90 indicator = np.array(numpy_indicator, np.bool) numpy_labels = (numpy_labels - 80) >= 0 labels = np.array(numpy_labels, np.bool) def graph_fn(indicator, labels): sampler = ( balanced_positive_negative_sampler.BalancedPositiveNegativeSampler( is_static=True)) return sampler.subsample(indicator, 64, labels) is_sampled = self.execute(graph_fn, [indicator, labels]) self.assertTrue(sum(is_sampled) == 64) self.assertTrue(sum(np.logical_and(numpy_labels, is_sampled)) == 10) self.assertTrue(sum(np.logical_and( np.logical_not(numpy_labels), is_sampled)) == 54) self.assertAllEqual(is_sampled, np.logical_and(is_sampled, numpy_indicator))
Example #16
Source File: balanced_positive_negative_sampler_test.py From vehicle_counting_tensorflow with MIT License | 6 votes |
def test_subsample_selection_dynamic(self): # Test random sampling when only some examples can be sampled: # 100 samples, 20 positives, 10 positives cannot be sampled numpy_labels = np.arange(100) numpy_indicator = numpy_labels < 90 indicator = tf.constant(numpy_indicator) numpy_labels = (numpy_labels - 80) >= 0 labels = tf.constant(numpy_labels) sampler = ( balanced_positive_negative_sampler.BalancedPositiveNegativeSampler()) is_sampled = sampler.subsample(indicator, 64, labels) with self.test_session() as sess: is_sampled = sess.run(is_sampled) self.assertTrue(sum(is_sampled) == 64) self.assertTrue(sum(np.logical_and(numpy_labels, is_sampled)) == 10) self.assertTrue(sum(np.logical_and( np.logical_not(numpy_labels), is_sampled)) == 54) self.assertAllEqual(is_sampled, np.logical_and(is_sampled, numpy_indicator))
Example #17
Source File: accumulators.py From pyqmc with MIT License | 6 votes |
def _node_regr(self, configs, wf): """ Return true if a given configuration is within nodal_cutoff of the node Also return the regularization polynomial if true, f = a * r ** 2 + b * r ** 4 + c * r ** 3 """ ne = configs.configs.shape[1] d2 = 0.0 for e in range(ne): d2 += np.sum(wf.gradient(e, configs.electron(e)) ** 2, axis=0) r = 1.0 / d2 mask = r < self.nodal_cutoff ** 2 c = 7.0 / (self.nodal_cutoff ** 6) b = -15.0 / (self.nodal_cutoff ** 4) a = 9.0 / (self.nodal_cutoff ** 2) f = a * r + b * r ** 2 + c * r ** 3 f[np.logical_not(mask)] = 1.0 return mask, f
Example #18
Source File: cvmc.py From pyqmc with MIT License | 6 votes |
def _node_regr(self, configs, wf): """ Return true if a given configuration is within nodal_cutoff of the node Also return the regularization polynomial if true, f = a * r ** 2 + b * r ** 4 + c * r ** 3 """ ne = configs.configs.shape[1] d2 = 0.0 for e in range(ne): d2 += np.sum(wf.gradient(e, configs.electron(e)) ** 2, axis=0) r = 1.0 / d2 mask = r < self.nodal_cutoff ** 2 c = 7.0 / (self.nodal_cutoff ** 6) b = -15.0 / (self.nodal_cutoff ** 4) a = 9.0 / (self.nodal_cutoff ** 2) f = a * r + b * r ** 2 + c * r ** 3 f[np.logical_not(mask)] = 1.0 return mask, f
Example #19
Source File: balanced_positive_negative_sampler_test.py From vehicle_counting_tensorflow with MIT License | 6 votes |
def test_subsample_all_examples_static(self): numpy_labels = np.random.permutation(300) indicator = np.array(np.ones(300) == 1, np.bool) numpy_labels = (numpy_labels - 200) > 0 labels = np.array(numpy_labels, np.bool) def graph_fn(indicator, labels): sampler = ( balanced_positive_negative_sampler.BalancedPositiveNegativeSampler( is_static=True)) return sampler.subsample(indicator, 64, labels) is_sampled = self.execute(graph_fn, [indicator, labels]) self.assertTrue(sum(is_sampled) == 64) self.assertTrue(sum(np.logical_and(numpy_labels, is_sampled)) == 32) self.assertTrue(sum(np.logical_and( np.logical_not(numpy_labels), is_sampled)) == 32)
Example #20
Source File: beam_search.py From knmt with GNU General Public License v3.0 | 6 votes |
def iterate_eos_scores(new_scores, eos_idx, existing_cases = None, beam_width=None)->Tuple[Sequence, Sequence, Sequence]: """ Return the indices and scores corresponding to the eos word. Meaning of returned values is the same as for iterate_best_score """ nb_cases, v_size = new_scores.shape num_cases = np.arange(nb_cases, dtype=np.int32) scores = -cuda.to_cpu(new_scores[:, eos_idx]) if existing_cases is not None: need_to_return = np.logical_not(np.isin(num_cases, existing_cases)) num_cases = num_cases[need_to_return] scores = scores[need_to_return] idx_in_cases = np.full(num_cases.shape[0], eos_idx, dtype=np.int32) if beam_width is not None: if beam_width < len(scores): idx_to_keep = np.argpartition(scores, beam_width)[:beam_width] scores = scores[idx_to_keep] num_cases = num_cases[idx_to_keep] idx_in_cases = idx_in_cases[idx_to_keep] return num_cases, idx_in_cases, scores
Example #21
Source File: train.py From ffn with Apache License 2.0 | 5 votes |
def add_patch(self, labels, predicted, weights, coord=None, volname=None, patches=None): """Evaluates single-object segmentation quality.""" predicted = mask.crop_and_pad(predicted, (0, 0, 0), self._eval_shape) weights = mask.crop_and_pad(weights, (0, 0, 0), self._eval_shape) labels = mask.crop_and_pad(labels, (0, 0, 0), self._eval_shape) loss, = self.sess.run([self.eval_loss], {self.eval_labels: labels, self.eval_preds: predicted}) self.loss += loss self.total_voxels += labels.size self.masked_voxels += np.sum(weights == 0.0) pred_mask = predicted >= self.eval_threshold true_mask = labels > 0.5 pred_bg = np.logical_not(pred_mask) true_bg = np.logical_not(true_mask) self.tp += np.sum(pred_mask & true_mask) self.fp += np.sum(pred_mask & true_bg) self.fn += np.sum(pred_bg & true_mask) self.tn += np.sum(pred_bg & true_bg) self.num_patches += 1 predicted = expit(predicted) self.images_xy.append(self.slice_image(labels, predicted, weights, 0)) self.images_xz.append(self.slice_image(labels, predicted, weights, 1)) self.images_yz.append(self.slice_image(labels, predicted, weights, 2))
Example #22
Source File: lattice.py From tenpy with GNU General Public License v3.0 | 5 votes |
def _keep_possible_multi_couplings(self, lat_ijkl, lat_ijkl_shifted, u_ijkl): """Filter possible couplings from :meth:`possible_multi_couplings`""" return np.all( np.logical_or( lat_ijkl_shifted == lat_ijkl, # not accross the boundary np.logical_not(self.bc)), # direction has PBC axis=(1, 2))
Example #23
Source File: verification.py From insightface with MIT License | 5 votes |
def calculate_accuracy(threshold, dist, actual_issame): predict_issame = np.less(dist, threshold) tp = np.sum(np.logical_and(predict_issame, actual_issame)) fp = np.sum(np.logical_and(predict_issame, np.logical_not(actual_issame))) tn = np.sum(np.logical_and(np.logical_not(predict_issame), np.logical_not(actual_issame))) fn = np.sum(np.logical_and(np.logical_not(predict_issame), actual_issame)) tpr = 0 if (tp+fn==0) else float(tp) / float(tp+fn) fpr = 0 if (fp+tn==0) else float(fp) / float(fp+tn) acc = float(tp+tn)/dist.size return tpr, fpr, acc
Example #24
Source File: decision_tree_submit.py From Python-Machine-Learning-By-Example-Second-Edition with MIT License | 5 votes |
def information_gain(y, mask, func=entropy): s1 = np.sum(mask) s2 = mask.size - s1 if (s1 == 0 | s2 == 0): return 0 return func(y) - s1 / float(s1 + s2) * func(y[mask]) - s2 / float(s1 + s2) * func(y[np.logical_not(mask)])
Example #25
Source File: plt.py From connecting_the_dots with MIT License | 5 votes |
def color_map(im_, cmap='viridis', vmin=None, vmax=None): cm = plt.get_cmap(cmap) im = im_.copy() if vmin is None: vmin = np.nanmin(im) if vmax is None: vmax = np.nanmax(im) mask = np.logical_not(np.isfinite(im)) im[mask] = vmin im = (im.clip(vmin, vmax) - vmin) / (vmax - vmin) im = cm(im) im = im[...,:3] for c in range(3): im[mask, c] = 1 return im
Example #26
Source File: voxel.py From 3D-R2N2 with MIT License | 5 votes |
def evaluate_voxel_prediction(preds, gt, thresh): preds_occupy = preds[:, 1, :, :] >= thresh diff = np.sum(np.logical_xor(preds_occupy, gt[:, 1, :, :])) intersection = np.sum(np.logical_and(preds_occupy, gt[:, 1, :, :])) union = np.sum(np.logical_or(preds_occupy, gt[:, 1, :, :])) num_fp = np.sum(np.logical_and(preds_occupy, gt[:, 0, :, :])) # false positive num_fn = np.sum(np.logical_and(np.logical_not(preds_occupy), gt[:, 1, :, :])) # false negative return np.array([diff, intersection, union, num_fp, num_fn])
Example #27
Source File: evaluation.py From hierarchical_loc with BSD 3-Clause "New" or "Revised" License | 5 votes |
def compute_tp_fp(ref_descriptors, query_descriptors, gt_matches, *arg, **kwarg): indices = retrieval(ref_descriptors, query_descriptors, *arg, **kwarg) tp = gt_matches[np.expand_dims(np.arange(len(indices)), axis=1), indices] fp = np.logical_not(tp) tp_cum = np.cumsum(tp, axis=1) fp_cum = np.cumsum(fp, axis=1) valid = np.any(gt_matches, axis=1) return tp_cum, fp_cum, valid
Example #28
Source File: lfw.py From insightface with MIT License | 5 votes |
def calculate_val_far(threshold, dist, actual_issame): predict_issame = np.less(dist, threshold) true_accept = np.sum(np.logical_and(predict_issame, actual_issame)) false_accept = np.sum(np.logical_and(predict_issame, np.logical_not(actual_issame))) n_same = np.sum(actual_issame) n_diff = np.sum(np.logical_not(actual_issame)) val = float(true_accept) / float(n_same) far = float(false_accept) / float(n_diff) return val, far
Example #29
Source File: lfw.py From insightface with MIT License | 5 votes |
def calculate_accuracy(threshold, dist, actual_issame): predict_issame = np.less(dist, threshold) tp = np.sum(np.logical_and(predict_issame, actual_issame)) fp = np.sum(np.logical_and(predict_issame, np.logical_not(actual_issame))) tn = np.sum(np.logical_and(np.logical_not(predict_issame), np.logical_not(actual_issame))) fn = np.sum(np.logical_and(np.logical_not(predict_issame), actual_issame)) tpr = 0 if (tp+fn==0) else float(tp) / float(tp+fn) fpr = 0 if (fp+tn==0) else float(fp) / float(fp+tn) acc = float(tp+tn)/dist.size return tpr, fpr, acc
Example #30
Source File: lfw.py From insightface with MIT License | 5 votes |
def calculate_val_far(threshold, dist, actual_issame): predict_issame = np.less(dist, threshold) true_accept = np.sum(np.logical_and(predict_issame, actual_issame)) false_accept = np.sum(np.logical_and(predict_issame, np.logical_not(actual_issame))) n_same = np.sum(actual_issame) n_diff = np.sum(np.logical_not(actual_issame)) val = float(true_accept) / float(n_same) far = float(false_accept) / float(n_diff) return val, far