我们从Python开源项目中，提取了以下23个代码示例，用于说明如何使用numpy.PINF。
def classify(fn, M, E): """ Classify SAM or SID on a HSI cube Can't be use with NormXCorr """ import pysptools.util as util width, height, bands = M.shape M = util.convert2d(M) cmap = np.zeros(M.shape[0]) for i in range(M.shape[0]): T = M[i] floor = np.PINF k = 0 for j in range(E.shape[0]): R = E[j] result = fn(T, R) if result < floor: floor = result k = j cmap[i] = k return util.convert3d(cmap, width, height)
def test_adding_bin(): col = 'mean radius' data = cancer_df[col].values cib = ConditionalInferenceBinner('test_dim_{}'.format(col), alpha=0.95) cib.fit(data, cancer_target) cib.add_bin(-1.0, [0.1, 0.9]) np.testing.assert_equal(cib.splits, [-1.0, 11.75, 13.079999923706055, 15.039999961853027, 16.84000015258789, np.PINF, np.NaN]) np.testing.assert_equal(cib.values, [[0.1, 0.9], [0.02, 0.97999999999999998], [0.086956521739130432, 0.91304347826086951], [0.2878787878787879, 0.71212121212121215], [0.81481481481481477, 0.18518518518518517], [0.99152542372881358, 0.0084745762711864406], [0.37258347978910367, 0.62741652021089633]])
def test_recursion_with_nan(): col = 'mean area' data = cancer_df[col].values rand_idx = np.linspace(1, 500, 23).astype(int) data[rand_idx] = np.NaN cib = ConditionalInferenceBinner('test_dim_{}'.format(col), alpha=0.95) cib.fit(data, cancer_target) np.testing.assert_equal(cib.splits, [471.29998779296875, 555.0999755859375, 693.7000122070312, 880.2000122070312, np.PINF, np.NaN]) np.testing.assert_equal(cib.values, [[0.030769230769230771, 0.96923076923076923], [0.13414634146341464, 0.86585365853658536], [0.31730769230769229, 0.68269230769230771], [0.83333333333333337, 0.16666666666666666], [0.99145299145299148, 0.0085470085470085479], [0.2608695652173913, 0.73913043478260865]])
def test_recursion_with_nan_and_special_value(): col = 'mean area' data = cancer_df[col].values rand_idx = np.linspace(1, 500, 23).astype(int) data[rand_idx] = np.NaN rand_idx_2 = np.linspace(1, 550, 29).astype(int) data[rand_idx_2] = -1.0 cib = ConditionalInferenceBinner('test_dim_{}'.format(col), alpha=0.95, special_values=[-1.0, np.NaN]) cib.fit(data, cancer_target) np.testing.assert_equal(cib.splits, [-1.0, 471.29998779296875, 572.2999877929688, 693.7000122070312, 819.7999877929688, np.PINF, np.NaN]) np.testing.assert_equal(cib.values, [[0.4827586206896552, 0.5172413793103449], [0.032432432432432434, 0.9675675675675676], [0.14432989690721648, 0.8556701030927835], [0.3132530120481928, 0.6867469879518072], [0.8205128205128205, 0.1794871794871795], [1.0, 0.0], [0.23809523809523808, 0.7619047619047619]])
def _init_shapes_and_data(self, data, labels): self.n_features = data.shape[1] if isinstance(data, pandas.core.frame.DataFrame): self.feature_names = data.columns.tolist() data = data.as_matrix() if self.feature_names is None: self.feature_names = ['feature_{}'.format(dim) for dim in range(self.n_features)] if isinstance(labels, pandas.core.series.Series): labels = labels.values cntr = Counter(labels) assert set(cntr.keys()) == {-1, 1}, "Labels must be encoded with -1, 1. Cannot contain more classes." assert self.n_features is not None, "Number of attributes is None" self.shapes = {name: ShapeFunction([np.PINF], [0.0], name) for name in self.feature_names} self.initialized = True return data, labels
def _recurse_tree(tree, lst, mdlp, node_id=0, depth=0, min_val=np.NINF, max_val=np.PINF): left_child = tree.children_left[node_id] right_child = tree.children_right[node_id] if left_child == sklearn.tree._tree.TREE_LEAF: lst.append(((min_val, max_val), tree.value[node_id].flatten().tolist())) return else: if mdlp and _check_mdlp_stop(tree, node_id): lst.append(((min_val, max_val), tree.value[node_id].flatten().tolist())) return _recurse_tree(tree, lst, mdlp, left_child, depth=depth + 1, min_val=min_val, max_val=tree.threshold[node_id]) if right_child == sklearn.tree._tree.TREE_LEAF: lst.append(((min_val, max_val), tree.value[node_id].flatten().tolist())) return else: if mdlp and _check_mdlp_stop(tree, node_id): lst.append(((min_val, max_val), tree.value[node_id].flatten().tolist())) return _recurse_tree(tree, lst, mdlp, right_child, depth=depth + 1, min_val=tree.threshold[node_id], max_val=max_val)
def _clipper(self): ''' projects the weights to the feasible set :return: ''' return tf.assign(self.W, tf.clip_by_value(self.W, 0, np.PINF), name="projector")
def _create_partition(lst_of_splits): return np.append(lst_of_splits, np.PINF)
def test_func_add_2(): func1 = ShapeFunction([np.PINF], [0], 'test_1') func2 = ShapeFunction([0, 1, 2], [-1, 1, -2], 'test_1') assert func1 != func2 func3 = ShapeFunction([0.0, 1.0, 2.0, np.PINF], [-1.0, 1.0, -2.0, 0.0], 'test_1') assert func1.add(func2).equals(func3)
def test_recursion(): binner = tfb.DecisionTreeBinner('test', max_leaf_nodes=4) binner.fit(data[:, 0], target) np.testing.assert_equal(binner.splits, [13.094999313354492, 15.045000076293945, 16.924999237060547, np.PINF, np.NaN]) np.testing.assert_equal(binner.values, [[0.04905660377358491, 0.9509433962264151], [0.2878787878787879, 0.7121212121212122], [0.8148148148148148, 0.18518518518518517], [0.9915254237288136, 0.00847457627118644], [0.37258347978910367, 0.62741652021089633]])
def test_recursion_with_mdlp(): binner = tfb.DecisionTreeBinner('test', mdlp=True) binner.fit(data[:, 0], target) np.testing.assert_equal(binner.splits, [13.094999313354492, 15.045000076293945, 17.880001068115234, np.PINF, np.NaN]) np.testing.assert_equal(binner.values, [[0.04905660377358491, 0.9509433962264151], [0.2878787878787879, 0.7121212121212122], [0.8533333333333334, 0.14666666666666667], [1.0, 0.0], [0.37258347978910367, 0.62741652021089633]])
def test_recursion(): col = 'mean radius' data = cancer_df[col].values cib = ConditionalInferenceBinner('test_dim_{}'.format(col), alpha=0.95) cib.fit(data, cancer_target) np.testing.assert_equal(cib.splits, [11.75, 13.079999923706055, 15.039999961853027, 16.84000015258789, np.PINF, np.NaN]) np.testing.assert_equal(cib.values, [[0.02, 0.97999999999999998], [0.086956521739130432, 0.91304347826086951], [0.2878787878787879, 0.71212121212121215], [0.81481481481481477, 0.18518518518518517], [0.99152542372881358, 0.0084745762711864406], [0.37258347978910367, 0.62741652021089633]])
def test_adding_bin_with_non_numeric_splits_only(): cib = ConditionalInferenceBinner('test', alpha=0.05) cib.splits = [np.PINF, np.NaN] cib.values = [[0.1, 0.9], [0.8, 0.2]] cib.is_fit = True cib.add_bin(-1.0, [0.3, 0.7]) np.testing.assert_equal(cib.splits, [-1.0, np.PINF, np.NaN]) np.testing.assert_equal(cib.values, [[0.3, 0.7], [0.1, 0.9], [0.8, 0.2]])
def __init__(self, name, **kwargs): self.name = name self.alpha = kwargs.get('alpha', 0.95) self.min_samples_split = kwargs.get('min_samples_split', 2) self.min_samples_leaf = kwargs.get('min_samples_leaf', 2) self.special_values = kwargs.get('special_values', [np.NaN]) self.num_classes = None self._splits = [np.PINF] self._values = list() self.nodes = list() self._is_fit = False
def __init__(self, name, **kwargs): self.name = name self._is_fit = False criterion = kwargs.get('criterion', 'gini') splitter = kwargs.get('splitter', 'best') max_depth = kwargs.get('max_depth', None) min_samples_split = kwargs.get('min_samples_split', 2) min_samples_leaf = kwargs.get('min_samples_leaf', 1) min_weight_fraction_leaf = kwargs.get('min_weight_fraction_leaf', 0.0) max_features = kwargs.get('max_features', None) random_state = kwargs.get('random_state', None) max_leaf_nodes = kwargs.get('max_leaf_nodes', None) class_weight = kwargs.get('class_weight', None) presort = kwargs.get('presort', False) self.mdlp = kwargs.get('mdlp', False) if self.mdlp: criterion = 'entropy' max_leaf_nodes = None max_depth = None self.dtc = DecisionTreeClassifier(criterion=criterion, splitter=splitter, max_depth=max_depth, min_samples_split=min_samples_split, min_samples_leaf=min_samples_leaf, min_weight_fraction_leaf=min_weight_fraction_leaf, max_features=max_features, random_state=random_state, max_leaf_nodes=max_leaf_nodes, class_weight=class_weight, presort=presort) self._splits = [np.PINF] self._values = list()
def masked_invalid(a, copy=True): """ Mask an array where invalid values occur (NaNs or infs). This function is a shortcut to ``masked_where``, with `condition` = ~(np.isfinite(a)). Any pre-existing mask is conserved. Only applies to arrays with a dtype where NaNs or infs make sense (i.e. floating point types), but accepts any array_like object. See Also -------- masked_where : Mask where a condition is met. Examples -------- >>> import numpy.ma as ma >>> a = np.arange(5, dtype=np.float) >>> a[2] = np.NaN >>> a[3] = np.PINF >>> a array([ 0., 1., NaN, Inf, 4.]) >>> ma.masked_invalid(a) masked_array(data = [0.0 1.0 -- -- 4.0], mask = [False False True True False], fill_value=1e+20) """ a = np.array(a, copy=copy, subok=True) mask = getattr(a, '_mask', None) if mask is not None: condition = ~(np.isfinite(getdata(a))) if mask is not nomask: condition |= mask cls = type(a) else: condition = ~(np.isfinite(a)) cls = MaskedArray result = a.view(cls) result._mask = condition return result ############################################################################### # Printing options # ###############################################################################
def describe_1d(data, **kwargs): leng = len(data) # number of observations in the Series count = data.count() # number of non-NaN observations in the Series # Replace infinite values with NaNs to avoid issues with # histograms later. data.replace(to_replace=[np.inf, np.NINF, np.PINF], value=np.nan, inplace=True) n_infinite = count - data.count() # number of infinte observations in the Series distinct_count = data.nunique(dropna=False) # number of unique elements in the Series if count > distinct_count > 1: mode = data.mode().iloc[0] else: mode = data[0] results_data = {'count': count, 'distinct_count': distinct_count, 'p_missing': 1 - count / leng, 'n_missing': leng - count, 'p_infinite': n_infinite / leng, 'n_infinite': n_infinite, 'is_unique': distinct_count == leng, 'mode': mode, 'p_unique': distinct_count / leng} try: # pandas 0.17 onwards results_data['memorysize'] = data.memory_usage() except: results_data['memorysize'] = 0 result = pd.Series(results_data, name=data.name) vartype = get_vartype(data) if vartype == 'CONST': result = result.append(describe_constant_1d(data)) elif vartype == 'BOOL': result = result.append(describe_boolean_1d(data, **kwargs)) elif vartype == 'NUM': result = result.append(describe_numeric_1d(data, **kwargs)) elif vartype == 'DATE': result = result.append(describe_date_1d(data, **kwargs)) elif vartype == 'UNIQUE': result = result.append(describe_unique_1d(data, **kwargs)) else: result = result.append(describe_categorical_1d(data)) return result
