# Python numpy.NINF() 使用实例

The following are code examples for showing how to use . They are extracted from open source Python projects. You can vote up the examples you like or vote down the exmaples you don’t like. You can also save this page to your account.

Example 1

def max2(iterable, key=lambda x: x):
first = None
second = None
first_value = np.NINF
second_value = np.NINF
for v in iterable:
n = key(v)
if n > first_value:
second = first
second_value = first_value
first = v
first_value = n
elif n > second_value:
second = v
second_value = n
return first, first_value, second, second_value

Example 2

def max2(iterable, key=None):
first = None
second = None
first_value = np.NINF
second_value = np.NINF
for v in iterable:
n = key(v) if key is not None else v
if n > first_value:
second = first
second_value = first_value
first = v
first_value = n
elif n > second_value:
second = v
second_value = n
return first, first_value, second, second_value

Example 3

def _plot_bucket_values(splits, values, title=None, class_labels={0: '0', 1: '1'}):
class_0 = [val[0] for val in values]
class_1 = [val[1] for val in values]
sp = np.asarray(splits)
non_na = sp[~np.isnan(sp)]
non_na = np.insert(non_na, 0, np.NINF)
label = ['({0:6.2f}, {1:6.2f}]'.format(tup[0], tup[1]) for tup in zip(non_na[:-1], non_na[1:])] + ['nan']
ind = np.arange(len(class_0))
w = 0.5
plt.bar(ind, class_0, w, label=class_labels[0])
plt.bar(ind, class_1, w, bottom=class_0, color='g', label=class_labels[1])
plt.xticks(ind + w / 2., label, size=16, rotation=75)
plt.yticks(size=16)
plt.legend(fontsize=16)
if title:
plt.title(title, size=16)
plt.xlabel('bucket', size=18)
plt.ylabel('bucket value', size=18)

Example 4

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)

Example 5

def get_transition_params(label_strs):
'''Construct transtion scoresd (0 for allowed, -inf for invalid).
Args:
label_strs: A [num_tags,] sequence of BIO-tags.
Returns:
A [num_tags, num_tags] matrix of transition scores.
'''
num_tags = len(label_strs)
transition_params = numpy.zeros([num_tags, num_tags], dtype=numpy.float32)
for i, prev_label in enumerate(label_strs):
for j, label in enumerate(label_strs):
if i != j and label[0] == 'I' and not prev_label == 'B' + label[1:]:
transition_params[i,j] = numpy.NINF
return transition_params

Example 6

def test_any_ninf(self):
# atan2(+-y, -infinity) returns +-pi for finite y > 0.
assert_almost_equal(ncu.arctan2(1, np.NINF),  np.pi)
assert_almost_equal(ncu.arctan2(-1, np.NINF), -np.pi)

Example 7

def test_any_ninf(self):
# atan2(+-y, -infinity) returns +-pi for finite y > 0.
assert_almost_equal(ncu.arctan2(1, np.NINF),  np.pi)
assert_almost_equal(ncu.arctan2(-1, np.NINF), -np.pi)

Example 8

def factor(self, marginals, targets):
f = np.divide(targets, marginals)  # We compute the factors
f[f == np.NINF] = 1  # And treat the errors, with the infinites first
f = f + 1  # and the NaN second
f = np.nan_to_num(f)  # The sequence of operations is just a resort to
f[f == 0] = 2  # use at most numpy functions as possible instead of pure Python
f = f - 1
return f

Example 9

def test_frame_from_json_nones(self):
df = DataFrame([[1, 2], [4, 5, 6]])
self.assertTrue(np.isnan(unser[2][0]))

df = DataFrame([['1', '2'], ['4', '5', '6']])
self.assertTrue(np.isnan(unser[2][0]))
self.assertTrue(unser[2][0] is None)
self.assertTrue(unser['2']['0'] is None)

self.assertTrue(np.isnan(unser[2][0]))
self.assertTrue(unser[2][0] is None)
convert_axes=False, dtype=False)
self.assertTrue(unser['2']['0'] is None)

# infinities get mapped to nulls which get mapped to NaNs during
# deserialisation
df = DataFrame([[1, 2], [4, 5, 6]])
df.loc[0, 2] = np.inf
self.assertTrue(np.isnan(unser[2][0]))
self.assertTrue(np.isnan(unser[2][0]))

df.loc[0, 2] = np.NINF
self.assertTrue(np.isnan(unser[2][0]))
self.assertTrue(np.isnan(unser[2][0]))

Example 10

def test_any_ninf(self):
# atan2(+-y, -infinity) returns +-pi for finite y > 0.
assert_almost_equal(ncu.arctan2(1, np.NINF),  np.pi)
assert_almost_equal(ncu.arctan2(-1, np.NINF), -np.pi)

Example 11

def test_any_ninf(self):
# atan2(+-y, -infinity) returns +-pi for finite y > 0.
assert_almost_equal(ncu.arctan2(1, np.NINF),  np.pi)
assert_almost_equal(ncu.arctan2(-1, np.NINF), -np.pi)

Example 12

def test_any_ninf(self):
# atan2(+-y, -infinity) returns +-pi for finite y > 0.
assert_almost_equal(ncu.arctan2(1, np.NINF),  np.pi)
assert_almost_equal(ncu.arctan2(-1, np.NINF), -np.pi)

Example 13

def compute_weights(data, Nlive):
"""Returns log_ev, log_wts for the log-likelihood samples in data,
assumed to be a result of nested sampling with Nlive live points."""

start_data=np.concatenate(([float('-inf')], data[:-Nlive]))
end_data=data[-Nlive:]

log_wts=np.zeros(data.shape[0])

log_vols_start=np.cumsum(np.ones(len(start_data)+1)*np.log1p(-1./Nlive))-np.log1p(-1./Nlive)
log_vols_end=np.zeros(len(end_data))
log_vols_end[-1]=np.NINF
log_vols_end[0]=log_vols_start[-1]+np.log1p(-1.0/Nlive)
for i in range(len(end_data)-1):
log_vols_end[i+1]=log_vols_end[i]+np.log1p(-1.0/(Nlive-i))

log_likes = np.concatenate((start_data,end_data,[end_data[-1]]))

log_vols=np.concatenate((log_vols_start,log_vols_end))
log_ev = log_integrate_log_trap(log_likes, log_vols)

log_dXs = logsubexp(log_vols[:-1], log_vols[1:])
log_wts = log_likes[1:-1] + log_dXs[:-1]

log_wts -= log_ev

return log_ev, log_wts

Example 14

def test_any_ninf(self):
# atan2(+-y, -infinity) returns +-pi for finite y > 0.
assert_almost_equal(ncu.arctan2(1, np.NINF),  np.pi)
assert_almost_equal(ncu.arctan2(-1, np.NINF), -np.pi)

Example 15

def _recurse(tree, feature_vec):

assert isinstance(tree, Tree), "Tree is not a sklearn Tree"

break_idx = 0
node_id = 0

if not isinstance(feature_vec, list):
feature_vec = list([feature_vec])

leaf_node_id = 0
lower = np.NINF
upper = np.PINF

while (node_id != TREE_LEAF) & (tree.feature[node_id] != TREE_UNDEFINED):
feature_idx = tree.feature[node_id]
threshold = tree.threshold[node_id]

if np.float32(feature_vec[feature_idx]) <= threshold:
upper = threshold
if (tree.children_left[node_id] != TREE_LEAF) and (tree.children_left[node_id] != TREE_UNDEFINED):
leaf_node_id = tree.children_left[node_id]
node_id = tree.children_left[node_id]
else:
lower = threshold
if (tree.children_right[node_id] == TREE_LEAF) and (tree.children_right[node_id] != TREE_UNDEFINED):
leaf_node_id = tree.children_right[node_id]
node_id = tree.children_right[node_id]

break_idx += 1
if break_idx > 2 * tree.node_count:
raise RuntimeError("infinite recursion!")

return leaf_node_id, lower, upper

Example 16

def test_any_ninf(self):
# atan2(+-y, -infinity) returns +-pi for finite y > 0.
assert_almost_equal(ncu.arctan2(1, np.NINF),  np.pi)
assert_almost_equal(ncu.arctan2(-1, np.NINF), -np.pi)

Example 17

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

Example 18

def compute_loss(self, scores, scores_no_dropout, labels):

loss = tf.constant(0.0)

if self.viterbi:
zero_elements = tf.equal(self.sequence_lengths, tf.zeros_like(self.sequence_lengths))
count_zeros_per_row = tf.reduce_sum(tf.to_int32(zero_elements), axis=1)
tf.scalar_mul(2, count_zeros_per_row))

log_likelihood, transition_params = tf.contrib.crf.crf_log_likelihood(scores, labels, flat_sequence_lengths,
transition_params=self.transition_params)
loss += tf.reduce_mean(-log_likelihood)
else:
if self.which_loss == "mean" or self.which_loss == "block":
losses = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=scores, labels=labels)
elif self.which_loss == "sum":
losses = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=scores, labels=labels)
elif self.which_loss == "margin":
# todo put into utils
# also todo put idx-into-3d as sep func
flat_labels = tf.reshape(labels, [-1])
batch_offsets = tf.multiply(tf.range(self.batch_size), self.max_seq_len * self.num_classes)
repeated_batch_offsets = tf_utils.repeat(batch_offsets, self.max_seq_len)
tok_offsets = tf.multiply(tf.range(self.max_seq_len), self.num_classes)
tiled_tok_offsets = tf.tile(tok_offsets, [self.batch_size])

# scores w/ true label set to -inf
sparse = tf.sparse_to_dense(indices, [self.batch_size * self.max_seq_len * self.num_classes], np.NINF)
loss_augmented = tf.reshape(loss_augmented_flat, [self.batch_size, self.max_seq_len, self.num_classes])

# maxes excluding true label
max_scores = tf.reshape(tf.reduce_max(loss_augmented, [-1]), [-1])
sparse = tf.sparse_to_dense(indices, [self.batch_size * self.max_seq_len * self.num_classes],
-self.margin)