def df_to_graph(fname: str,verbose=True,weighted=True):
"""
:fname path/to/dataframe
:returns nx graph
"""
if weighted:
df = pd.read_csv(fname,sep='\t').take([0,1,2],axis=1)
else:
df = pd.read_csv(fname,sep='\t').take([0,1],axis=1)
#df = pd.read_csv(fname,sep='\t',skiprows=0,names=['head','tail','weight']).take([0,1,2],axis=1)
#df = df.drop(0)
ff = df
edges = [tuple(x) for x in df.values]
#print(edges)
vertices = list(df.stack())
GR = nx.DiGraph()
for v in vertices:
GR.add_node(v)
for e in edges:
if weighted:
u,v,w = e
GR.add_edge(u,v,weight=float(w),cost=-math_log(max([0.000000001, w]))/math_log(10))
else:
u,v = e
GR.add_edge(u,v)
if verbose:
print('length of edge set: {}'.format(len(set(edges))))
print('number of edges in GR: {}'.format(len(list(GR.edges))))
return GR
def test_log():
log_five = modifiers.log(5)
eq_(solve(log_five), math_log(5))
eq_(solve(pickle.loads(pickle.dumps(log_five))), math_log(5))
eq_(str(log_five), "<log(5)>")
def test_log():
log_five = modifiers.log(5)
eq_(solve(log_five), math_log(5))
eq_(solve(pickle.loads(pickle.dumps(log_five))), math_log(5))
eq_(str(log_five), "<log(5)>")
def test_log():
log_five = modifiers.log(5)
assert solve(log_five) == math_log(5)
assert solve(pickle.loads(pickle.dumps(log_five))) == math_log(5)
assert repr(log_five) == "<feature.log(5)>"
def augment_graph(G, sources, targets, verbose):
if verbose:
print(' augmenting graph...')
## initialize edge variables with capacities, flow_var name, and flow.
for u, v in G.edges():
G[u][v]['cap'] = 1.0 ## edge capacity
G[u][v]['flow_var'] = DELIM.join(['f', u,
v]) ## flow variable name for ILP
G[u][v]['flow'] = None
## (1) Add super source and super sink
G.add_node(SUPERSOURCE)
G.add_node(SUPERSINK)
## (2) Add dir. edges from supersource to receptors and tfs to supersink
## (2a) Add capacities to edges from supersource to receptors
## NOTE: capacities are uniform for both of these types of edges.
## The original paper changed this to the strength of
## each genetic hit. PathLinker used uniform capcities.
for s in sources:
G.add_edge(SUPERSOURCE,
s,
weight=1 / len(sources),
cap=1 / len(sources),
flow_var=DELIM.join(['f', SUPERSOURCE, s]),
flow=None)
G[SUPERSOURCE][s]['cost'] = -math_log(
max([0.000000001, G[SUPERSOURCE][s]['weight']])) / math_log(10)
## (2b) Add capacities to eges from tfs to supersink
for t in targets:
G.add_edge(t,
SUPERSINK,
weight=1 / len(targets),
cap=1 / len(targets),
flow_var=DELIM.join(['f', t, SUPERSINK]),
flow=None)
G[t][SUPERSINK]['cost'] = -math_log(
max([0.000000001, G[t][SUPERSINK]['weight']])) / math_log(10)
orderedvariables = [] # sets the order of flow variables
i = 0
for u, v in G.edges():
G[u][v]['index'] = i
orderedvariables.append(G[u][v]['flow_var'])
i += 1
if verbose:
print('augmented graph has %d nodes and %d edges' %
(G.number_of_nodes(), G.number_of_edges()))
return orderedvariables
def log(v, base=None):
try:
if v == None:
return Null
if v == 0.0:
return -float("inf")
if base == None:
return math_log(v)
return math_log(v, base)
except Exception as e:
from mo_logs import Log
Log.error("error in log", cause=e)
def __pow__(self, other):
if other.units != unity:
raise_QuantError("the exponent can't have units", "%s ^ %s", (self, other))
if self.units == unity:
units = self.units
else:
if not hasattr(other.number, 'denominator'): # not int or fraction
raise_QuantError("can't raise units to irrational exponent", "%s ^ %s", (self, other))
units = tuple([fraction_or_int(u * other.number) for u in self.units])
try:
if hasattr(self.number, 'denominator') and hasattr(other.number, 'denominator') and other.number > 10:
number = self.number ** float(other.number)
else:
number = self.number ** other.number
except ValueError:
raise_QuantError("arithmetic problem, e.g. complex numbers not implemented", "%s ^ %s", (self, other))
except OverflowError:
raise_QuantError("overflow: value too high", "%s ^ %s", (self, other))
# try:
# number = self.number ** mpmath.mpf(other.number)
# except OverflowError:
# raise_QuantError("overflow: value too high", "%s ^ %s", (self, other))
if number.imag:
raise_QuantError("complex numbers not implemented", "%s ^ %s", (self, other))
uncert1 = abs(self.uncert / self.number * number * other.number)
if hasattr(self.number, 'denominator'):
argument = float(self.number)
else:
argument = self.number
uncert2 = abs(other.uncert * math_log(abs(argument)) * number)
uncert = uncert1 + uncert2
return Q(number, '%s ^ %s', units, uncert, self.prefu, (self, other))
def _build_positional_encoding_sublayer(self,
inputs,
seq_len,
scope="PositionalEncoding"):
"""Add positional encoding to the inputs.
Based on the paper "Attention is all you need" by Vaswani et al.
(https://arxiv.org/pdf/1706.03762.pdf).
Code adapted from Google's Tensor2Tensor repo on GitHub.
"""
with tf.variable_scope(scope):
vec_size = inputs.get_shape().as_list()[-1]
positions = tf.expand_dims(tf.to_float(tf.range(seq_len)),
1) # shape (seq_len, 1)
d_model = vec_size // 2
exponent_step = math_log(10000.) / (tf.to_float(d_model) - 1)
pos_multiplier = tf.exp(
tf.to_float(tf.range(d_model)) * -exponent_step)
pos_encoded = positions * tf.expand_dims(
pos_multiplier, 0) # shape (seq_len, d_model)
pos_encoded = tf.concat(
[tf.sin(pos_encoded), tf.cos(pos_encoded)], axis=1)
pos_encoded = tf.pad(pos_encoded,
[[0, 0], [0, tf.mod(vec_size, 2)]])
pos_encoded = tf.reshape(pos_encoded, [1, seq_len, vec_size])
outputs = inputs + pos_encoded
outputs = tf.nn.dropout(outputs, self.keep_prob)
return outputs
def ln_model_prob(self, Xf):
"""Returns the ln of the model probability, which is the
variational bound / K! to account for symmetries in the classifier
matching function.
"""
# we need to use the log function from the math module,
# as the one from the numpy module cannot handle numbers of type 'long'
return self.var_bound(Xf) - math_log(fact(len(self.cls)))
def append_inflection_report(db, row, years, index_roe, total_roe,
total_finish):
row_base_roe = db.get_index_history_minus_years(database2.CONST_INDEX_ROE,
years)
cagr = ((index_roe / row_base_roe.value)**Decimal(1 / years)) - 1
inflect = inflect_years = four_pct_years = five_m_years = float("NaN")
if cagr > 0:
inflect = total_roe * cagr
inflect_years = math_log(CONST_ONE_UNIT / (total_roe * cagr), cagr + 1)
four_pct_years = math_log(total_finish / total_roe, cagr + 1)
five_m_years = math_log(CONST_FIVE_MILLION / total_roe, cagr + 1)
row.append(cagr)
row.append(inflect)
row.append(inflect_years * -1)
row.append(five_m_years * -1)
row.append(four_pct_years * -1)
row.append(row_base_roe.date)
def log(x, b=None):
"""The logarithm function.
Works for both numeric and symbolic (`SymPy.Expr`) inputs.
Default base `b=None` means `e`, i.e. take the natural logarithm.
"""
if isinstance(x, _symExpr):
# https://stackoverflow.com/questions/46129259/how-to-simplify-logarithm-of-exponent-in-sympy
if b is not None:
return _symlog(x, b).expand(force=True)
else:
return _symlog(x).expand(force=True)
if b is not None:
return math_log(x, b)
else:
return math_log(x)
def calc_entropy(byte_dict):
entropy = 0
total = sum(byte_dict.values())
for key in byte_dict:
if byte_dict[key] != 0:
freq = byte_dict[key] / total
entropy = entropy + freq * math_log(freq, 2)
entropy *= -1
return entropy
def get_string_size(bytes):
units = [' b','Kb','Mb','Gb','Tb']
if not bytes:
return '0 b'
exponent = int(math_log(bytes, 1024))
if exponent > 4:
return '%d b' % bytes
value = bytes / 1024.0 ** exponent, units[exponent]
return '%6.2f %s' % value
def count_omx_vol(vol_percent):
try:
float_percent = float(vol_percent) / 100
except Exception as e:
float_percent = 0.01
try:
return int(2000 * (math_log(float_percent, 10)))
except Exception as e:
return -4000
def _safelog(item):
"""Takes the logarithm of `item`. Instead of raising exceptions
like `math.log` does, it returns ``-inf`` for zero and ``nan``
for negative numbers.
"""
if item < 0:
return float("nan")
if item == 0:
return float("-inf")
return math_log(item)
def _safelog(item):
"""Takes the logarithm of `item`. Instead of raising exceptions
like `math.log` does, it returns ``-inf`` for zero and ``nan``
for negative numbers.
"""
if item < 0:
return float('nan')
if item == 0:
return float('-inf')
return math_log(item)
def sizeof_fmt(num):
"""Human friendly sizes"""
if num > 1:
exponent = min(int(math_log(num, 1024)), len(unit_list) - 1)
quotient = float(num) / 1024**exponent
unit, num_decimals = unit_list[exponent]
format_string = '{:.%sf} {}' % (num_decimals)
return format_string.format(quotient, unit)
if num == 0:
return '0 bytes'
if num == 1:
return '1 byte'
def sizeof_fmt(num):
"""Human friendly sizes"""
if num > 1:
exponent = min(int(math_log(num, 1024)), len(unit_list) - 1)
quotient = float(num) / 1024**exponent
unit, num_decimals = unit_list[exponent]
format_string = '{:.%sf} {}' % (num_decimals)
return format_string.format(quotient, unit)
if num == 0:
return '0 bytes'
if num == 1:
return '1 byte'
def _set_target_values(self, feature_map_width, feature_map_height,
image_index, t, target, anchor_index, iou,
ground_truth_center_x_pixel,
ground_truth_center_y_pixel, ground_truth_height,
ground_truth_width, target_center_x_values,
target_center_y_values, target_class_values,
target_confidence_score_values,
target_height_values, target_width_values):
image = target[image_index]
target_center_x_values[image_index][anchor_index][
ground_truth_center_y_pixel][ground_truth_center_x_pixel] = image[
t * 5 + 1] * feature_map_width - ground_truth_center_x_pixel
target_center_y_values[image_index][anchor_index][
ground_truth_center_y_pixel][ground_truth_center_x_pixel] = image[
t * 5 + 2] * feature_map_height - ground_truth_center_y_pixel
target_width_values[image_index][anchor_index][
ground_truth_center_y_pixel][
ground_truth_center_x_pixel] = math_log(
ground_truth_width /
self.anchors[self.anchor_step * anchor_index])
target_height_values[image_index][anchor_index][
ground_truth_center_y_pixel][
ground_truth_center_x_pixel] = math_log(
ground_truth_height /
self.anchors[self.anchor_step * anchor_index + 1])
target_confidence_score_values[image_index][anchor_index][
ground_truth_center_y_pixel][ground_truth_center_x_pixel] = iou
target_class_values[image_index][anchor_index][
ground_truth_center_y_pixel][ground_truth_center_x_pixel] = image[
t * 5]
return target_center_x_values, target_center_y_values, target_width_values, target_height_values, \
target_confidence_score_values, target_class_values
def get_AA_score(networks, target_A, target_B, frequency_dict):
AA_score = 0
A_neighbors = list()
B_neighbors = list()
for edge in networks:
if edge[0] == target_A:
A_neighbors.append(edge[1])
if edge[1] == target_A:
A_neighbors.append(edge[0])
if edge[0] == target_B:
B_neighbors.append(edge[1])
if edge[1] == target_B:
B_neighbors.append(edge[0])
for neighbor in A_neighbors:
if neighbor in B_neighbors:
if frequency_dict[neighbor] > 1:
AA_score += 1 / (math_log(frequency_dict[neighbor]))
return AA_score
def run(G, sources, targets, alpha=0.85, thres=0.80, verbose=False):
print('backward flux calculation...')
personalization = {t:1/len(targets) for t in targets}
G_rev = G.reverse(copy=True)
backward_pagerank = nx.pagerank(G_rev,alpha=alpha,personalization=personalization,weight='weight')
## BACKWARD: We compute BACKWARDS flux score for edge (u, v) by multiplying the visitation probability
## of v by the edge weight and normalizing by the weighted IN degree of v.
for v in backward_pagerank:
denom = len(list(G.predecessors(v)))
for u in G.predecessors(v):
G[u][v]['backward_flux'] = backward_pagerank[v]*G[u][v]['weight']/denom
## combine flux
## take negative logs on the flux scores
print('combining fluxes...')
tot_flux = 0
for u,v in G.edges():
if G[u][v]['backward_flux'] == 0:
G[u][v]['neglog_backward_flux'] = sys.float_info.max ## maximum float value
else:
G[u][v]['neglog_backward_flux'] = - (math_log(G[u][v]['backward_flux']))
tot_flux+=G[u][v]['backward_flux']
print('sorting and taking predictions that comprise %f of total flux' % (thres))
edges = {} #dictionary of (u,v): -log(flux*flux)
running_sum = 0
counter = 0
## iterate through edges sorted by -log(flux*flux)
for u,v,d in sorted(G.edges(data=True), key=lambda t: t[2]['neglog_backward_flux']):
edges[(u,v)] = G[u][v]['neglog_backward_flux']
running_sum+=G[u][v]['backward_flux']
counter+=1
if counter % 1000 == 0:
print('%d of %d: %d of %d (%f)' % (counter,len(G.edges()),running_sum,tot_flux,running_sum/tot_flux))
if running_sum/tot_flux > thres:
print('theshold of %f limits predictions to %d edges' %(thres,len(edges)))
break
return edges
def __pow__(self, other):
if other.units != unity:
raise_QuantError("the exponent can't have units", "%s ^ %s", (self, other))
if self.units == unity:
units = self.units
else:
if not hasattr(other.number, 'denominator'): # not int or fraction
raise_QuantError("can't raise units to irrational exponent", "%s ^ %s", (self, other))
units = tuple([fraction_or_int(u * other.number) for u in self.units])
try:
if hasattr(self.number, 'denominator') and hasattr(other.number, 'denominator') and other.number > 10:
number = self.number ** float(other.number)
else:
number = self.number ** other.number
except ValueError:
raise_QuantError("arithmetic problem, e.g. complex numbers not implemented", "%s ^ %s", (self, other))
except OverflowError:
raise_QuantError("overflow: value too high", "%s ^ %s", (self, other))
if number.imag:
raise_QuantError("complex numbers not implemented", "%s ^ %s", (self, other))
uncert = abs(self.uncert / self.number * number * other.number) + abs(
other.uncert * math_log(abs(self.number)) * number)
return Q(number, '%s ^ %s', units, uncert, self.prefu, (self, other))
def nearestpoweroftwo(num):
"""Helper function to find the next higher power of 2 to a given number.
Such that the power of two is the smallest power of two larger than the
supplied number.
Helps find correct buffer sizes in bytes.
Parameters
----------
num : {int}
The number of bytes for which you wish to find the smallest power of 2
larger than.
2 -> 4
4 -> 8
7 -> 8
Returns
-------
int
The integer value of the nearest power of two larger than num.
"""
return pow(2, int(math_log(num, 2) + 1))
def best_tick(largest, most_ticks):
"""Generate a 'nice' interval for graphs given a max value and most number of intervals
Arguments:
largest: - A number which represents the greatest amount that needs to be displayed.
most_ticks: - A integer which represents the most number of intervals that
should be displayed.
Returns:
A number: that is the best unit of increment for the input data.
"""
minimum = largest / most_ticks#minimum increment
magnitude = 10 ** math_floor(math_log(minimum, 10))
residual = minimum / magnitude#most significant digit of the minimum increment
if residual > 5:
tick = 10 * magnitude
elif residual > 2:
tick = 5 * magnitude
elif residual > 1:
tick = 2 * magnitude
else:
tick = magnitude
return tick
def _row_sax_word_array(self, ntss_tmp, bigger_cardinality, size_word):
"""
Convert all sequences according to the different cardinality of the tree.
For each cardinality, uses :func:`~pyCFOFiSAX.isax.IndexableSymbolicAggregateApproximation.transform_sax`.
:param ntss_tmp: The sequences to be analyzed
:param int bigger_cardinality: The greatest cardinality *i*\ SAX of the tree
:param int size_word: The size of the SAX sequences of the tree
:returns: SAX words from all ``ntss_tmp`` sequences according to all the cardinalities of the tree, a dict returning the cardinality index *i*\ SAX
:rtype: numpy.ndarray, dict
"""
# TODO integrate tree.base_cardinality in the calculation
# si tree.base_cardinality = 3 par exemple...
number_of_card = int(math_log(bigger_cardinality, 2))
row_sax_word = np_zeros(
(number_of_card + 1, len(ntss_tmp), size_word, 1))
# TODO card_current = tree.base_cardinality 1/2
card_current = 1
card_index = 0
card_to_index = dict()
""" TODO np.vectorize
>>> vtransform_sax = np.vectorize(tree.isax.transform_sax)
>>> card_list = 2**np.arange(1,int(np.sqrt(tree.bigger_current_cardinality))-1)
>>> vtransform_sax(ntss_tmp, card_list)"""
while card_current <= bigger_cardinality:
card_to_index[card_current] = card_index
row_sax_word[card_index] = self.transform_sax(
ntss_tmp, card_current)
card_current = card_current * 2
card_index += 1
row_sax_word = row_sax_word.transpose((2, 1, 0, 3))
return row_sax_word.reshape(row_sax_word.shape[:-1]), card_to_index
def _cur_size_limit(self):
len_self, size_factor = len(self), self._size_factor
return int(round(size_factor * math_log(len_self + 2, 2)))
def ln_func(x):
return max(0, float(math_log(x + .1) + 2) / 2.1)
def log(x):
if x < 1e-10:
return 0.0
else:
return math_log(x)
def _process(self, feature_value):
return math_log(feature_value)
def _process(self, feature_value):
return math_log(feature_value)
def calculate_gamma(from_value, to_value=None):
return math_log(
from_value
) / LongExposureStandard.constants.mid_log if to_value is None else math_log(
from_value) / math_log(to_value)
def qln(a):
return Q(math_log(a.number), "ln(%s)", a.units, abs(a.uncert / a.number), a.prefu, (a,))
def qln(a):
return Q(math_log(a.number), "ln(%s)", a.units, abs(a.uncert / a.number), a.prefu, (a,))
def test_prim_log(x):
return math_log(x)
def log(x):
if x == 0:
return -100
else:
return math_log(x)
def log(x):
""" Returns the natural log of x, -inf if x is >= 0 """
return math_log(float(x)) if x > 0.0 else float("-inf")
def get_digits(n):
return int(ceil(math_log(n + 1, 10))) + 1
def log10(v):
try:
return math_log(v, 10)
except Exception as e:
return Null
def ln_func(x):
return max(0, float(math_log(x+.1) + 2)/2.1)