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 test_zero_safe_divide(self):
from blmath.numerics.operations import zero_safe_divide
numerator = np.ones((5, 5))
numerator[3, 3] = 0.
denominator = np.ones((5, 5))
denominator[2, 2] = 0.
denominator[3, 3] = 0.
with warnings.catch_warnings():
warnings.simplefilter("ignore", RuntimeWarning)
true_divide = np.true_divide(numerator, denominator)
safe_divide = zero_safe_divide(numerator, denominator)
self.assertTrue(np.isinf(true_divide[2, 2]))
self.assertEqual(safe_divide[2, 2], 0.)
self.assertTrue(np.isnan(true_divide[3, 3]))
self.assertEqual(safe_divide[3, 3], 0.) Example 2
def zero_safe_divide(a, b, default_error_value=0.):
"""Element-wise division that accounts for floating point errors.
Both invalid floating-point (e.g. 0. / 0.) and divide be zero errors are
suppressed. Resulting values (NaN and Inf respectively) are replaced with
`default_error_value`.
"""
import numpy as np
with np.errstate(invalid='ignore', divide='ignore'):
quotient = np.true_divide(a, b)
bad_value_indices = np.logical_or(
np.isnan(quotient), np.isinf(quotient))
quotient[bad_value_indices] = default_error_value
return quotient Example 3
def V_short(self,eta):
sum0 = np.zeros(7,dtype=float)
sum1 = np.zeros(7,dtype=float)
for n1,n2 in product(range(self.N1+1),range(self.N2+1)):
wdo = comb(self.N1,n1,exact=True)*comb(self.N2,n2,exact=True)
wdox10 = comb(self.N1-1,n1,exact=True)*comb(self.N2,n2,exact=True)
wdox11 = comb(self.N1-1,n1-1,exact=True)*comb(self.N2,n2,exact=True)
wdox20 = comb(self.N1,n1,exact=True)*comb(self.N2-1,n2,exact=True)
wdox21 = comb(self.N1,n1,exact=True)*comb(self.N2-1,n2-1,exact=True)
w = np.asarray([wdox10,wdox20,wdox11,wdox21,wdo,wdo,wdo])
pz0,pz1 = self.p_n_given_z(n1,n2)
counts = [self.N1-n1,self.N2-n2,n1,n2,1,1,1]
Q = (eta*pz0*counts*(1-self.pZgivenA)+eta*pz1*counts*self.pZgivenA).sum()
ratio = np.nan_to_num(np.true_divide(pz0*(1-self.pZgivenA)+pz1*self.pZgivenA,Q))
sum0 += np.asfarray(w*pz0*ratio)
sum1 += np.asfarray(w*pz1*ratio)
result = self.pZgivenA*sum1+(1-self.pZgivenA)*sum0
return result Example 4
def run(self,T,model):
if T <= model.K: # result is not defined if the horizon is shorter than the number of actions
self.best_action = None
return np.nan
actions = range(0,model.K)
self.trials = np.ones(model.K)
self.success = model.sample_multiple(actions,1)
for t in range(model.K,T):
arm = argmax_rand(self.upper_bound(t))
self.trials[arm] += 1
self.success[arm] +=model.sample_multiple(arm,1)
mu = np.true_divide(self.success,self.trials)
self.best_action = argmax_rand(mu)
return max(model.expected_rewards) - model.expected_rewards[self.best_action] Example 5
def fit(self, x, y, verbose=True): #setting data attributes for the model instance X = tfidf_to_counts(x) #splitting by target class so we can calculate the log-count ratio X_pos = X[np.where(y == 1)] X_neg = X[np.where(y == 0)] self.r = log_count_ratio(X_pos, X_neg) #setting the npos and nneg variables n_pos = X_pos.shape[0] n_neg = X_neg.shape[0] #getting the bais for the MNB model self.nb_bias = np.log(np.true_divide(n_pos, n_neg)) #trains, tests, and assesses the performance of the model
Example 6
def test_NotImplemented_not_returned(self):
# See gh-5964 and gh-2091. Some of these functions are not operator
# related and were fixed for other reasons in the past.
binary_funcs = [
np.power, np.add, np.subtract, np.multiply, np.divide,
np.true_divide, np.floor_divide, np.bitwise_and, np.bitwise_or,
np.bitwise_xor, np.left_shift, np.right_shift, np.fmax,
np.fmin, np.fmod, np.hypot, np.logaddexp, np.logaddexp2,
np.logical_and, np.logical_or, np.logical_xor, np.maximum,
np.minimum, np.mod
]
# These functions still return NotImplemented. Will be fixed in
# future.
# bad = [np.greater, np.greater_equal, np.less, np.less_equal, np.not_equal]
a = np.array('1')
b = 1
for f in binary_funcs:
assert_raises(TypeError, f, a, b) Example 7
def __itruediv__(self, other):
"""
True divide self by other in-place.
"""
other_data = getdata(other)
dom_mask = _DomainSafeDivide().__call__(self._data, other_data)
other_mask = getmask(other)
new_mask = mask_or(other_mask, dom_mask)
# The following 3 lines control the domain filling
if dom_mask.any():
(_, fval) = ufunc_fills[np.true_divide]
other_data = np.where(dom_mask, fval, other_data)
self._mask |= new_mask
self._data.__itruediv__(np.where(self._mask, self.dtype.type(1),
other_data))
return self Example 8
def load_files(avg_file, std_file):
# load files
with open(avg_file) as f:
avg = simplejson.load(f)
with open(std_file) as f:
std = simplejson.load(f)
std = np.array(std)
print std
std = np.true_divide(std, 2.)
print std
avg = np.array(avg)
avg_upper = avg + std
avg_lower = avg - std
return avg, avg_upper, avg_lower Example 9
def test_NotImplemented_not_returned(self):
# See gh-5964 and gh-2091. Some of these functions are not operator
# related and were fixed for other reasons in the past.
binary_funcs = [
np.power, np.add, np.subtract, np.multiply, np.divide,
np.true_divide, np.floor_divide, np.bitwise_and, np.bitwise_or,
np.bitwise_xor, np.left_shift, np.right_shift, np.fmax,
np.fmin, np.fmod, np.hypot, np.logaddexp, np.logaddexp2,
np.logical_and, np.logical_or, np.logical_xor, np.maximum,
np.minimum, np.mod
]
# These functions still return NotImplemented. Will be fixed in
# future.
# bad = [np.greater, np.greater_equal, np.less, np.less_equal, np.not_equal]
a = np.array('1')
b = 1
for f in binary_funcs:
assert_raises(TypeError, f, a, b) Example 10
def __itruediv__(self, other):
"""
True divide self by other in-place.
"""
other_data = getdata(other)
dom_mask = _DomainSafeDivide().__call__(self._data, other_data)
other_mask = getmask(other)
new_mask = mask_or(other_mask, dom_mask)
# The following 3 lines control the domain filling
if dom_mask.any():
(_, fval) = ufunc_fills[np.true_divide]
other_data = np.where(dom_mask, fval, other_data)
self._mask |= new_mask
self._data.__itruediv__(np.where(self._mask, self.dtype.type(1),
other_data))
return self Example 11
def test_NotImplemented_not_returned(self):
# See gh-5964 and gh-2091. Some of these functions are not operator
# related and were fixed for other reasons in the past.
binary_funcs = [
np.power, np.add, np.subtract, np.multiply, np.divide,
np.true_divide, np.floor_divide, np.bitwise_and, np.bitwise_or,
np.bitwise_xor, np.left_shift, np.right_shift, np.fmax,
np.fmin, np.fmod, np.hypot, np.logaddexp, np.logaddexp2,
np.logical_and, np.logical_or, np.logical_xor, np.maximum,
np.minimum, np.mod
]
# These functions still return NotImplemented. Will be fixed in
# future.
# bad = [np.greater, np.greater_equal, np.less, np.less_equal, np.not_equal]
a = np.array('1')
b = 1
for f in binary_funcs:
assert_raises(TypeError, f, a, b) Example 12
def __itruediv__(self, other):
"""
True divide self by other in-place.
"""
other_data = getdata(other)
dom_mask = _DomainSafeDivide().__call__(self._data, other_data)
other_mask = getmask(other)
new_mask = mask_or(other_mask, dom_mask)
# The following 3 lines control the domain filling
if dom_mask.any():
(_, fval) = ufunc_fills[np.true_divide]
other_data = np.where(dom_mask, fval, other_data)
self._mask |= new_mask
self._data.__itruediv__(np.where(self._mask, self.dtype.type(1),
other_data))
return self Example 13
def test_NotImplemented_not_returned(self):
# See gh-5964 and gh-2091. Some of these functions are not operator
# related and were fixed for other reasons in the past.
binary_funcs = [
np.power, np.add, np.subtract, np.multiply, np.divide,
np.true_divide, np.floor_divide, np.bitwise_and, np.bitwise_or,
np.bitwise_xor, np.left_shift, np.right_shift, np.fmax,
np.fmin, np.fmod, np.hypot, np.logaddexp, np.logaddexp2,
np.logical_and, np.logical_or, np.logical_xor, np.maximum,
np.minimum, np.mod
]
# These functions still return NotImplemented. Will be fixed in
# future.
# bad = [np.greater, np.greater_equal, np.less, np.less_equal, np.not_equal]
a = np.array('1')
b = 1
for f in binary_funcs:
assert_raises(TypeError, f, a, b) Example 14
def __itruediv__(self, other):
"""
True divide self by other in-place.
"""
other_data = getdata(other)
dom_mask = _DomainSafeDivide().__call__(self._data, other_data)
other_mask = getmask(other)
new_mask = mask_or(other_mask, dom_mask)
# The following 3 lines control the domain filling
if dom_mask.any():
(_, fval) = ufunc_fills[np.true_divide]
other_data = np.where(dom_mask, fval, other_data)
self._mask |= new_mask
self._data.__itruediv__(np.where(self._mask, self.dtype.type(1),
other_data))
return self Example 15
def _entropy(self, y, return_class_counts=False):
""" Entropy for the classes in the array y
:math: \sum_{x \in X} p(x) \log_{2}(1/p(x)) :math: from
https://en.wikipedia.org/wiki/ID3_algorithm
Parameters
----------
y : nparray of shape [n remaining attributes]
containing the class names
Returns
-------
: float
information for remaining examples given feature
"""
n = y.shape[0]
if n <= 0:
return 0
classes, count = unique(y)
p = np.true_divide(count, n)
res = np.abs(np.sum(np.multiply(p, np.log2(p))))
if return_class_counts:
return res, np.vstack((classes, count)).T
else:
return res Example 16
def _info_nominal(self, x, y):
""" Info for nominal feature feature_values
:math: p(a)H(a) :math: from
https://en.wikipedia.org/wiki/ID3_algorithm
Parameters
----------
x : np.array of shape [n remaining examples]
containing feature values
y : np.array of shape [n remaining examples]
containing relevent class
Returns
-------
: float
information for remaining examples given feature
"""
info = 0
n = x.shape[0]
items, count = unique(x)
for value, p in zip(items, count):
info += p * self._entropy(y[x == value])
return CalcRecord(CalcRecord.NOM,
info * np.true_divide(1, n),
attribute_counts=count) Example 17
def bilinearResize(images, ratiox, ratioy):
'''
images: 4D image batch
ratiox, ratioy: magnification ratio. Positive integer.
'''
b, h, w, c = [v.value for v in images.get_shape()]
sidex = 2 * ratiox - 1
sidey = 2 * ratioy - 1
interpolatex = np.true_divide((ratiox - np.abs(np.arange(sidex) - ratiox + 1)), ratiox)
interpolatey = np.true_divide((ratioy - np.abs(np.arange(sidey) - ratioy + 1)), ratioy)
weight = np.outer(interpolatex, interpolatey).astype(np.float32)
weights = np.zeros((sidex,sidey,c,c), dtype=np.float32)
for i in range(c):
weights[:,:,i,i] = weight
out_shape = [b, h*ratiox, w*ratioy, c]
strides = [1, ratiox, ratioy, 1]
kernel = tf.constant(weights, name='bilinear_convt_weights')
return tf.nn.conv2d_transpose(images, weights,
out_shape, strides=strides, padding='SAME') Example 18
def test_cumsum(mock_np, arr, normalize, expected_result):
mock_np.cumsum = mock.Mock(side_effect = lambda *a, **k: np.cumsum(*a, **k))
mock_np.square = mock.Mock(side_effect = lambda *a, **k: np.square(*a, **k))
mock_np.max = mock.Mock(side_effect = lambda *a, **k: np.max(*a, **k))
# mock_np.true_divide = mock.Mock(side_effect = lambda *a, **k: np.true_divide(*a, **k))
mock_np.isnan = mock.Mock(side_effect = lambda *a, **k: np.isnan(*a, **k))
r = cumsum(arr, normalize=normalize)
assert len(r) == len(arr)
assert (r == np.array(expected_result)).all()
assert mock_np.cumsum.called
assert mock_np.square.called
assert mock_np.isnan.called == normalize
assert mock_np.max.called == normalize
# if normalize:
# assert mock_np.isnan.called
# assert mock_np.max.called
# assert mock_np.true_divide.called
# else:
# assert not mock_np.max.called
# assert not mock_np.true_divide.called Example 19
def Quadrify(contour): epsilon = 10 for i in range(1,10): quad = cv2.approxPolyDP(contour, epsilon, True) length = len(quad) randomVar = np.random.random() epsilon = np.multiply(epsilon, np.true_divide(np.add(length, randomVar), np.add(4, randomVar))) # print epsilon, length if length == 4: return np.multiply(i, 0.01) return 1
Example 20
def test_NotImplemented_not_returned(self):
# See gh-5964 and gh-2091. Some of these functions are not operator
# related and were fixed for other reasons in the past.
binary_funcs = [
np.power, np.add, np.subtract, np.multiply, np.divide,
np.true_divide, np.floor_divide, np.bitwise_and, np.bitwise_or,
np.bitwise_xor, np.left_shift, np.right_shift, np.fmax,
np.fmin, np.fmod, np.hypot, np.logaddexp, np.logaddexp2,
np.logical_and, np.logical_or, np.logical_xor, np.maximum,
np.minimum, np.mod
]
# These functions still return NotImplemented. Will be fixed in
# future.
# bad = [np.greater, np.greater_equal, np.less, np.less_equal, np.not_equal]
a = np.array('1')
b = 1
for f in binary_funcs:
assert_raises(TypeError, f, a, b) Example 21
def test_true_divide(self):
# True_divide has a non uniform signature, see #3484.
# This also tests type_tuple_type_resolver.
a = np.full(5, 12.5)
b = np.full(5, 10.0)
tgt = np.full(5, 1.25)
assert_almost_equal(np.true_divide(a, b, dtype=np.float64), tgt)
assert_almost_equal(np.true_divide(a, b, dtype=np.float32), tgt)
assert_raises(TypeError, np.true_divide, a, b, dtype=np.int) Example 22
def test_NotImplemented_not_returned(self):
# See gh-5964 and gh-2091. Some of these functions are not operator
# related and were fixed for other reasons in the past.
binary_funcs = [
np.power, np.add, np.subtract, np.multiply, np.divide,
np.true_divide, np.floor_divide, np.bitwise_and, np.bitwise_or,
np.bitwise_xor, np.left_shift, np.right_shift, np.fmax,
np.fmin, np.fmod, np.hypot, np.logaddexp, np.logaddexp2,
np.logical_and, np.logical_or, np.logical_xor, np.maximum,
np.minimum, np.mod
]
# These functions still return NotImplemented. Will be fixed in
# future.
# bad = [np.greater, np.greater_equal, np.less, np.less_equal, np.not_equal]
a = np.array('1')
b = 1
for f in binary_funcs:
assert_raises(TypeError, f, a, b) Example 23
def _hist_bin_doane(x):
"""
Doane's histogram bin estimator.
Improved version of Sturges' formula which works better for
non-normal data. See
http://stats.stackexchange.com/questions/55134/doanes-formula-for-histogram-binning
Parameters
----------
x : array_like
Input data that is to be histogrammed, trimmed to range. May not
be empty.
Returns
-------
h : An estimate of the optimal bin width for the given data.
"""
if x.size > 2:
sg1 = np.sqrt(6.0 * (x.size - 2) / ((x.size + 1.0) * (x.size + 3)))
sigma = np.std(x)
if sigma > 0.0:
# These three operations add up to
# g1 = np.mean(((x - np.mean(x)) / sigma)**3)
# but use only one temp array instead of three
temp = x - np.mean(x)
np.true_divide(temp, sigma, temp)
np.power(temp, 3, temp)
g1 = np.mean(temp)
return x.ptp() / (1.0 + np.log2(x.size) +
np.log2(1.0 + np.absolute(g1) / sg1))
return 0.0 Example 24
def __truediv__(self, other):
"""
Divide other into self, and return a new masked array.
"""
if self._delegate_binop(other):
return NotImplemented
return true_divide(self, other) Example 25
def __rtruediv__(self, other):
"""
Divide self into other, and return a new masked array.
"""
return true_divide(other, self) Example 26
def divide(x, y):
with np.errstate(divide='ignore', invalid='ignore'):
z = np.true_divide(x, y)
z[~ np.isfinite(z)] = 0
return z Example 27
def __truediv__(self, other):
return true_divide(self, other) Example 28
def __itruediv__(self, other):
return true_divide(self, other, self) Example 29
def __rtruediv__(self, other):
return true_divide(other, self) Example 30
def div0(a, b):
""" ignore / 0, div0( [-1, 0, 1], 0 ) -> [0, 0, 0] """
with np.errstate(divide='ignore', invalid='ignore'):
c = np.true_divide(a, b)
c[~np.isfinite(c)] = 0 # -inf inf NaN
return c Example 31
def fullness(self):
potential_leaves = np.prod(np.ceil(np.true_divide(self.bounds[1] - self.bounds[0], self.leaf_shape)))
return self.root_node.count_leaves() / float(potential_leaves) Example 32
def test_true_divide(self):
# True_divide has a non uniform signature, see #3484.
# This also tests type_tuple_type_resolver.
a = np.full(5, 12.5)
b = np.full(5, 10.0)
tgt = np.full(5, 1.25)
assert_almost_equal(np.true_divide(a, b, dtype=np.float64), tgt)
assert_almost_equal(np.true_divide(a, b, dtype=np.float32), tgt)
assert_raises(TypeError, np.true_divide, a, b, dtype=np.int) Example 33
def test_NotImplemented_not_returned(self):
# See gh-5964 and gh-2091. Some of these functions are not operator
# related and were fixed for other reasons in the past.
binary_funcs = [
np.power, np.add, np.subtract, np.multiply, np.divide,
np.true_divide, np.floor_divide, np.bitwise_and, np.bitwise_or,
np.bitwise_xor, np.left_shift, np.right_shift, np.fmax,
np.fmin, np.fmod, np.hypot, np.logaddexp, np.logaddexp2,
np.logical_and, np.logical_or, np.logical_xor, np.maximum,
np.minimum, np.mod
]
# These functions still return NotImplemented. Will be fixed in
# future.
# bad = [np.greater, np.greater_equal, np.less, np.less_equal, np.not_equal]
a = np.array('1')
b = 1
for f in binary_funcs:
assert_raises(TypeError, f, a, b) Example 34
def _hist_bin_doane(x):
"""
Doane's histogram bin estimator.
Improved version of Sturges' formula which works better for
non-normal data. See
http://stats.stackexchange.com/questions/55134/doanes-formula-for-histogram-binning
Parameters
----------
x : array_like
Input data that is to be histogrammed, trimmed to range. May not
be empty.
Returns
-------
h : An estimate of the optimal bin width for the given data.
"""
if x.size > 2:
sg1 = np.sqrt(6.0 * (x.size - 2) / ((x.size + 1.0) * (x.size + 3)))
sigma = np.std(x)
if sigma > 0.0:
# These three operations add up to
# g1 = np.mean(((x - np.mean(x)) / sigma)**3)
# but use only one temp array instead of three
temp = x - np.mean(x)
np.true_divide(temp, sigma, temp)
np.power(temp, 3, temp)
g1 = np.mean(temp)
return x.ptp() / (1.0 + np.log2(x.size) +
np.log2(1.0 + np.absolute(g1) / sg1))
return 0.0 Example 35
def __truediv__(self, other):
"""
Divide other into self, and return a new masked array.
"""
if self._delegate_binop(other):
return NotImplemented
return true_divide(self, other) Example 36
def __rtruediv__(self, other):
"""
Divide self into other, and return a new masked array.
"""
return true_divide(other, self) Example 37
def __itruediv__(self, other):
""" See __div__. """
oth = sanitize_units_mul(self, other)
np.true_divide(self, oth, out=self)
return self Example 38
def one_shot_classification(test_data, num_shots, num_classes, compute_similarities, k_neighbours=1,
num_episodes=10000):
data_shape = np.prod(test_data[0][0].shape)
episode_length = num_shots * num_classes + 1
batch = np.zeros([num_classes, episode_length, data_shape], dtype=np.float32)
accuracy = 0.
votes = np.zeros(num_classes)
for episode in xrange(num_episodes):
classes = np.random.choice(test_data.shape[0], num_classes, False)
classes_idx = np.repeat(classes[:, np.newaxis], num_shots, 1).flatten()
idx = []
for k in xrange(num_classes):
idx.append(np.random.choice(test_data.shape[1], num_shots + 1, False))
idx = np.vstack(idx)
y = np.repeat(np.arange(num_classes)[:, np.newaxis], num_shots, 1).flatten()
# print batch[:, :-1, :].shape, idx[:, :-1].flatten().shape
batch[:, :-1, :] = test_data[classes_idx, idx[:, :-1].flatten(), :]
batch[:, -1, :] = test_data[classes, idx[:, -1].flatten(), :]
# np.true_divide(batch, 255., out=batch, casting='unsafe')
# sim[i, j] -- similarity between batch[i, -1] and batch[i, j]
sim = compute_similarities(batch)
for k in xrange(num_classes):
votes[:] = 0.
nearest = sim[k].argsort()[-k_neighbours:]
for j in nearest:
votes[y[j]] += sim[k, j]
y_hat = votes.argmax()
if y_hat == k:
accuracy += 1
status = 'episode: %d, accuracy: %f' % (episode, accuracy / num_classes / (episode + 1))
sys.stdout.write('\r' + status)
sys.stdout.flush()
return accuracy / num_episodes / num_classes Example 39
def load_data(path):
raw_data = np.load(path)
data = []
min_size = min([raw_data[f].shape[0] for f in raw_data.files])
max_value = max([raw_data[f].max() for f in raw_data.files])
for cl in raw_data.files:
class_data = raw_data[cl][:min_size]
class_data = class_data.reshape(min_size, np.prod(class_data.shape[1:]))
np.true_divide(class_data, max_value, out=class_data, casting='unsafe')
# reverse_data = class_data.copy()
# reverse_data[class_data > 0.] = 0.
# reverse_data[class_data <= 0.95] = 1.
# data.append(reverse_data[None, :, :])
data.append(class_data[None, :, :])
return np.concatenate(data, axis=0) Example 40
def _prepare_network_input(self, states):
""" Normalizes the states from one minibatch.
Args:
states (numpy.ndarray): Mini-batch of states, shape=(batch_size,sequence_length,frame_width,frame_height)
Returns:
normalized_states (numpy.ndarray): State values divided by the maximim state value, shape=(batch_size,sequence_length,frame_width,frame_height)
"""
_logger.debug("Normalizing input")
return np.true_divide(states, self.grayscales) Example 41
def prod_all_but_j(vector):
""" returns a vector where the jth term is the product of all the entries except the jth one """
zeros = np.where(vector==0)[0]
if len(zeros) > 1:
return np.zeros(len(vector))
if len(zeros) == 1:
result = np.zeros(len(vector))
j = zeros[0]
result[j] = np.prod(vector[np.arange(len(vector)) != j])
return result
joint = np.prod(vector)
return np.true_divide(joint,vector) Example 42
def R(self,pa,eta):
""" returns the ratio of the probability of the given assignment under each action to the probability under the eta weighted sum of actions. """
Q = (eta*pa).sum()
ratio = np.true_divide(pa,Q)
ratio[np.isnan(ratio)] = 0 # we get nan when 0/0 but should just be 0 in this case
return ratio Example 43
def V(self,eta):
""" returns a vector of length K with the expected value of R (over x sampled from p(x|a)) for each action a """
#with np.errstate(divide='ignore'):
u = np.true_divide(1.0,np.dot(self.A,eta))
u = np.nan_to_num(u) # converts infinities to very large numbers such that multiplying by 0 gives 0
v = np.dot(self.A2T,u)
return v Example 44
def P(self,x):
""" calculate vector of P_a for each action a """
indx = np.arange(len(x))
ps = self.pX[x,indx] #probability of P(X_i = x_i) for each i given do()
joint = ps.prod() # probability of x given do()
pi = np.true_divide(joint,ps) # will be nan for elements for which ps is 0
for j in np.where(np.isnan(pi))[0]:
pi[j] = np.prod(ps[indx != j])
pij = np.vstack((pi,pi))
pij[1-x,indx] = 0 # now this is the probability of x given do(x_i=j)
pij = pij.reshape((len(x)*2,)) #flatten first N-1 will be px=0,2nd px=1
result = np.hstack((pij,joint))
return result Example 45
def estimate_infrequent(self,h):
qij_hat = np.true_divide(self.trials,h)
s_indx = np.argsort(qij_hat) #indexes of elements from s in sorted(s)
m_hat = Parallel.calculate_m(qij_hat[s_indx])
infrequent = s_indx[0:m_hat]
return infrequent Example 46
def run(self,T,model):
self.trials = np.full(model.K,2,dtype=int)
self.success = np.full(model.K,1,dtype=int)
for t in xrange(T):
fails = self.trials - self.success
theta = np.random.beta(self.success,fails)
arm = argmax_rand(theta)
self.trials[arm] +=1
self.success[arm]+= model.sample_multiple(arm,1)
mu = np.true_divide(self.success,self.trials)
self.best_action = argmax_rand(mu)
return max(model.expected_rewards) - model.expected_rewards[self.best_action] Example 47
def upper_bound(self,t):
mu = np.true_divide(self.success,self.trials)
interval = np.sqrt(self.alpha*np.log(t)/(2.0*self.trials))
return mu+interval Example 48
def allocate(self,T,K):
logK = .5 + np.true_divide(1,range(2,K+1)).sum()
n = np.zeros((K),dtype=int)
n[1:] = np.ceil((1.0/logK)*np.true_divide((T - K),range(K,1,-1)))
allocations = np.diff(n)
return allocations Example 49
def run(self,T,model):
self.trials = np.zeros(model.K)
self.success = np.zeros(model.K)
for t in xrange(T):
x,y = model.sample(model.K-1)
xij = np.hstack((1-x,x,1)) # first N actions represent x_i = 0,2nd N x_i=1, last do()
self.trials += xij
self.success += y*xij
self.u = np.true_divide(self.success,self.trials)
self.best_action = argmax_rand(self.u)
return max(model.expected_rewards) - model.expected_rewards[self.best_action] Example 50
def run(self,T,model):
trials_per_action = T/model.K
success = model.sample_multiple(range(model.K),trials_per_action)
self.u = np.true_divide(success,trials_per_action)
self.best_action = argmax_rand(self.u)
return max(model.expected_rewards) - model.expected_rewards[self.best_action] 