我们从Python开源项目中，提取了以下16个代码示例，用于说明如何使用numpy.isneginf()。
def PPMI_matrix(M): M = scale_sim_mat(M) nm_nodes = len(M) col_s = np.sum(M, axis=0).reshape(1,nm_nodes) row_s = np.sum(M, axis=1).reshape(nm_nodes,1) D = np.sum(col_s) rowcol_s = np.dot(row_s,col_s) PPMI = np.log(np.divide(D*M,rowcol_s)) PPMI[np.isnan(PPMI)] = 0.0 PPMI[np.isinf(PPMI)] = 0.0 PPMI[np.isneginf(PPMI)] = 0.0 PPMI[PPMI<0] = 0.0 return PPMI
def heatmap (d, bins=(100, 100), smoothing=1.3, cmap='jet'): def getx (pt): return pt.coords[0][0] def gety (pt): return pt.coords[0][1] x = list(d.geometry.apply(getx)) y = list(d.geometry.apply(gety)) heatmap, xedges, yedges = np.histogram2d(y, x, bins=bins) extent = [yedges[0], yedges[-1], xedges[-1], xedges[0]] # bin edges along the x and y dimensions, ordered # why are we taking log? logheatmap = np.log(heatmap) logheatmap[np.isneginf(logheatmap)] = 0 logheatmap = ndimage.filters.gaussian_filter(logheatmap, smoothing, mode='nearest') return (logheatmap, extent)
def test_lnprob_does_not_raise_on_LinAlgError(datasets_db): """lnprob() should catch LinAlgError raised by equilibrium and return -np.inf""" datasets_db.insert(zpf_json) res = lnprob([10], comps=['CU','MG', 'VA'], dbf=dbf, phases=['LIQUID', 'FCC_A1', 'HCP_A3', 'LAVES_C15', 'CUMG2'], datasets=datasets_db, symbols_to_fit=['VV0001'], phase_models=None, scheduler=None) assert np.isneginf(res)
def test_lnprob_does_not_raise_on_ValueError(datasets_db): """lnprob() should catch ValueError raised by equilibrium and return -np.inf""" datasets_db.insert(zpf_json) res = lnprob([10], comps=['CU','MG', 'VA'], dbf=dbf, phases=['LIQUID', 'FCC_A1', 'HCP_A3', 'LAVES_C15', 'CUMG2'], datasets=datasets_db, symbols_to_fit=['VV0001'], phase_models=None, scheduler=None) assert np.isneginf(res)
def tolerant_eq(a, b): return (True if (numpy.isinf(a) and numpy.isinf(b)) or (numpy.isneginf(a) and numpy.isneginf(b)) or abs(a-b) < 1e-10 else False)
def is_invalid(arr): return any([f(arr).any() for f in [numpy.isinf, numpy.isnan, numpy.isneginf]])
def get_mask_invalid(matrix): mask = np.isposinf(matrix) + np.isneginf(matrix) + np.isnan(matrix) return mask
def test_known_value_0_0(self): x = lin2db(0.0) self.assertTrue(np.isneginf(x))
def test_known_value_0_0(self): x = pow2db(0.0) self.assertTrue(np.isneginf(x))
def set_logp_to_neg_inf(X, logp, bounds): """Set `logp` to negative infinity when `X` is outside the allowed bounds. # Arguments X: tensorflow.Tensor The variable to apply the bounds to logp: tensorflow.Tensor The log probability corrosponding to `X` bounds: list of `Region` objects The regions corrosponding to allowed regions of `X` # Returns logp: tensorflow.Tensor The newly bounded log probability """ conditions = [] for l, u in bounds: lower_is_neg_inf = not isinstance(l, tf.Tensor) and np.isneginf(l) upper_is_pos_inf = not isinstance(u, tf.Tensor) and np.isposinf(u) if not lower_is_neg_inf and upper_is_pos_inf: conditions.append(tf.greater(X, l)) elif lower_is_neg_inf and not upper_is_pos_inf: conditions.append(tf.less(X, u)) elif not (lower_is_neg_inf or upper_is_pos_inf): conditions.append(tf.logical_and(tf.greater(X, l), tf.less(X, u))) if len(conditions) > 0: is_inside_bounds = conditions[0] for condition in conditions[1:]: is_inside_bounds = tf.logical_or(is_inside_bounds, condition) logp = tf.select( is_inside_bounds, logp, tf.fill(tf.shape(X), config.dtype(-np.inf)) ) return logp
def modified_topology_features(ds, seg_id, use_2d_edges): modified_features = ds.topology_features(seg_id, use_2d_edges) if not ds.defect_slices: return modified_features skip_edges = get_skip_edges( ds, seg_id) skip_ranges = get_skip_ranges( ds, seg_id) skip_starts = get_skip_starts( ds, seg_id) delete_edge_ids = get_delete_edge_ids(ds, seg_id) # delete all features corresponding to delete - edges modified_features = np.delete(modified_features, delete_edge_ids, axis = 0) # get topo features for the new skip edges seg = ds.seg(seg_id) lower_slices = np.unique(skip_starts) skip_edge_pairs_to_slice = {z : skip_edges[skip_starts == z] for z in lower_slices} skip_edge_indices_to_slice = {z : np.where(skip_starts == z)[0] for z in lower_slices} skip_edge_ranges_to_slice = {z : skip_ranges[skip_starts == z] for z in lower_slices} n_feats = modified_features.shape[1] skip_topo_features = np.zeros( (skip_edges.shape[0], n_feats) ) for z in lower_slices: _get_skip_topo_features_for_slices( z, seg, skip_edge_pairs_to_slice[z], skip_edge_ranges_to_slice[z], skip_edge_indices_to_slice[z], use_2d_edges, skip_topo_features) skip_topo_features[np.isinf(skip_topo_features)] = 0. skip_topo_features[np.isneginf(skip_topo_features)] = 0. skip_topo_features = np.nan_to_num(skip_topo_features) assert skip_topo_features.shape[1] == modified_features.shape[1] return np.concatenate([modified_features, skip_topo_features],axis = 0) # the last argument is only for caching results with different features correctly
def _numpy(self, data, weights, shape): q = self.quantity(data) self._checkNPQuantity(q, shape) self._checkNPWeights(weights, shape) weights = self._makeNPWeights(weights, shape) newentries = weights.sum() import numpy selection = numpy.isnan(q) numpy.bitwise_not(selection, selection) subweights = weights.copy() subweights[selection] = 0.0 self.nanflow._numpy(data, subweights, shape) # switch to float here like in bin.py else numpy throws # TypeError on trivial integer cases such as: # >>> q = numpy.array([1,2,3,4]) # >>> np.divide(q,1,q) # >>> np.floor(q,q) q = numpy.array(q, dtype=numpy.float64) neginfs = numpy.isneginf(q) posinfs = numpy.isposinf(q) numpy.subtract(q, self.origin, q) numpy.divide(q, self.binWidth, q) numpy.floor(q, q) q = numpy.array(q, dtype=numpy.int64) q[neginfs] = LONG_MINUSINF q[posinfs] = LONG_PLUSINF selected = q[weights > 0.0] selection = numpy.empty(q.shape, dtype=numpy.bool) for index in numpy.unique(selected): if index != LONG_NAN: bin = self.bins.get(index) if bin is None: bin = self.value.zero() self.bins[index] = bin numpy.not_equal(q, index, selection) subweights[:] = weights subweights[selection] = 0.0 bin._numpy(data, subweights, shape) # no possibility of exception from here on out (for rollback) self.entries += float(newentries)
def _propose_anchors(self, num_anchors): if num_anchors != 2: raise Exception('PointInformedSplitMergeSetupKernel only works for 2 anchors') anchor_1 = np.random.randint(0, self.num_data_points) if anchor_1 not in self.data_to_clusters: self._set_data_to_clusters(anchor_1) log_p_anchor = self.data_to_clusters[anchor_1].copy() u = np.random.random() alpha = np.random.beta(1, 9) * 100 if u <= 0.5: x = np.percentile(log_p_anchor, alpha) log_p_anchor[log_p_anchor > x] = float('-inf') log_p_anchor[log_p_anchor <= x] = 0 else: x = np.percentile(log_p_anchor, 100 - alpha) log_p_anchor[log_p_anchor > x] = 0 log_p_anchor[log_p_anchor <= x] = float('-inf') log_p_anchor[anchor_1] = float('-inf') if np.isneginf(np.max(log_p_anchor)): idx = np.arange(self.num_data_points) idx = list(idx) idx.remove(anchor_1) anchor_2 = np.random.choice(idx) else: idx = np.where(~np.isneginf(log_p_anchor))[0].flatten() anchor_2 = np.random.choice(idx) return anchor_1, anchor_2
def elliptical_slice(xx, log_like_fn, prior_chol, prior_mean, *log_like_args, **sampler_args): cur_log_like = sampler_args.get('cur_log_like', None) angle_range = sampler_args.get('angle_range', 0) if cur_log_like is None: cur_log_like = log_like_fn(xx, *log_like_args) if np.isneginf(cur_log_like): raise Exception("Elliptical Slice Sampler: initial logprob is -inf for inputs %s" % xx) if np.isnan(cur_log_like): raise Exception("Elliptical Slice Sampler: initial logprob is NaN for inputs %s" % xx) nu = np.dot(prior_chol, npr.randn(xx.shape[0])) # don't bother adding mean here, would just subtract it at update step hh = np.log(npr.rand()) + cur_log_like # log likelihood threshold -- LESS THAN THE INITIAL LOG LIKELIHOOD # Set up a bracket of angles and pick a first proposal. # "phi = (theta'-theta)" is a change in angle. if angle_range <= 0: # Bracket whole ellipse with both edges at first proposed point phi = npr.rand()*2*math.pi phi_min = phi - 2*math.pi phi_max = phi else: # Randomly center bracket on current point phi_min = -angle_range*npr.rand(); phi_max = phi_min + angle_range; phi = npr.rand()*(phi_max - phi_min) + phi_min; # Slice sampling loop while True: # Compute xx for proposed angle difference # and check if it's on the slice xx_prop = (xx-prior_mean)*np.cos(phi) + nu*np.sin(phi) + prior_mean cur_log_like = log_like_fn(xx_prop, *log_like_args) if cur_log_like > hh: # New point is on slice, ** EXIT LOOP ** return xx_prop, cur_log_like # Shrink slice to rejected point if phi > 0: phi_max = phi elif phi < 0: phi_min = phi else: sys.stderr.write('Initial x: %s\n' % xx) # sys.stderr.write('initial log like = %f\n' % initial_log_like) sys.stderr.write('Proposed x: %s\n' % xx_prop) sys.stderr.write('ESS log lik = %f\n' % cur_log_like) raise Exception('BUG DETECTED: Shrunk to current position ' 'and still not acceptable.'); # Propose new angle difference phi = npr.rand()*(phi_max - phi_min) + phi_min
def initnw(layer): """ Nguyen-Widrow initialization function """ ci = layer.ci cn = layer.cn w_fix = 0.7 * cn ** (1. / ci) w_rand = np.random.rand(cn, ci) * 2 - 1 # Normalize if ci == 1: w_rand = w_rand / np.abs(w_rand) else: w_rand = np.sqrt(1. / np.square(w_rand).sum(axis=1).reshape(cn, 1)) * w_rand w = w_fix * w_rand b = np.array([0]) if cn == 1 else w_fix * np.linspace(-1, 1, cn) * np.sign(w[:, 0]) # Scaleble to inp_active amin, amax = layer.transf.inp_active amin = -1 if amin == -np.Inf else amin amax = 1 if amax == np.Inf else amax x = 0.5 * (amax - amin) y = 0.5 * (amax + amin) w = x * w b = x * b + y # Scaleble to inp_minmax minmax = layer.inp_minmax.copy() minmax[np.isneginf(minmax)] = -1 minmax[np.isinf(minmax)] = 1 x = 2. / (minmax[:, 1] - minmax[:, 0]) y = 1. - minmax[:, 1] * x w = w * x b = np.dot(w, y) + b layer.np['w'][:] = w layer.np['b'][:] = b return
