Python numpy 模块，Infinity() 实例源码
我们从Python开源项目中，提取了以下27个代码示例，用于说明如何使用numpy.Infinity()。
def prim(self):
'''
Returns Prim's minimum spanninng tree
'''
big_f = set([])
costs = np.empty((self.n), dtype=object)
costs[:] = np.max(self.costs) + 1
big_e = np.empty((self.n), dtype=object)
big_q = set(range(self.n))
tree_edges = np.array([], dtype=object)
while len(big_q) > 0:
v = np.argmin(costs)
big_q.remove(v)
costs[v] = np.Infinity
big_f.add(v)
if big_e[v] is not None:
tree_edges = np.append(tree_edges, None)
tree_edges[-1] = (big_e[v], v)
for i, w in zip(range(len(self.FSs[v])), self.FSs[v]):
if w in big_q and self.FS_costs[v][i] < costs[w]:
costs[w] = self.FS_costs[v][i]
big_e[w] = v
return tree_edges
def prim(self):
'''
Returns Prim's minimum spanninng tree
'''
big_f = set([])
costs = np.empty((self.n), dtype=object)
costs[:] = np.max(self.costs) + 1
big_e = np.empty((self.n), dtype=object)
big_q = set(range(self.n))
tree_edges = np.array([], dtype=object)
while len(big_q) > 0:
v = np.argmin(costs)
big_q.remove(v)
costs[v] = np.Infinity
big_f.add(v)
if big_e[v] is not None:
tree_edges = np.append(tree_edges, None)
tree_edges[-1] = (big_e[v], v)
for i, w in zip(range(len(self.FSs[v])), self.FSs[v]):
if w in big_q and self.FS_costs[v][i] < costs[w]:
costs[w] = self.FS_costs[v][i]
big_e[w] = v
return tree_edges
def fitness(self, x, limit=np.Infinity):
"""
Wraps the fitness-function of the actual problem, whose results
are logged if the fitness is an improvement.
"""
# Calculate fitness of the actual problem.
new_fitness = self.problem.fitness(x=x, limit=limit)
# If log is desired.
if self.capacity > 0:
# If the new fitness is an improvement over the worst-known fitness in the log.
if new_fitness < self.solutions[-1].fitness:
# Update the worst solution in the log with the new solution.
self.solutions[-1] = _LogElement(x=x, fitness=new_fitness)
# Sort the logged solutions.
self.solutions = sorted(self.solutions, key=lambda solution: solution.fitness)
return new_fitness
########################################################################
def fitness(self, x, limit=np.Infinity):
"""
This is the fitness function that must be implemented for an
optimization problem.
It is also sometimes called the cost- or error-function.
:param x:
Calculate the fitness value for these parameters in the search-space.
:param limit:
Calculation of the fitness can be aborted if the value is greater than this limit.
This is used for so-called Pre-Emptive Fitness Evaluation in the MetaFitness-class.
You can ignore this value.
:return:
Fitness-value of x.
"""
# Raise an exception if the child-class has not implemented this function.
raise NotImplementedError
########################################################################
def get_k(df, groupby, unknown=None):
"""
Return the k-anonymity level of a df, grouped by the specified columns.
:param df: The dataframe to get k from
:param groupby: The columns to group by
:type df: pandas.DataFrame
:type groupby: Array
:return: k-anonymity
:rtype: int
"""
df = _remove_unknown(df, groupby, unknown)
size_group = df.groupby(groupby).size()
if len(size_group) == 0:
return np.Infinity
return min(size_group)
def sample_cut(lX, uX, birth_time):
rate = np.sum(uX - lX)
if rate > 0:
E = np.random.exponential(scale=1.0/rate)
cut_time = birth_time + E
dim = sample_discrete(uX - lX)
loc = lX[dim] + (uX[dim] - lX[dim]) * np.random.rand()
return cut_time, dim, loc
else:
return np.Infinity, None, None
# FOURIER FEATURES
def bellman_ford(self, source):
'''
Returns Labels-algorithm's shortest paths from source to all other
nodes, if the (directed) graph doesn't contains cycles
'''
if self.oriented is False:
print 'cannot apply bellman_ford, graph is not oriented'
return
dist = np.array([np.Infinity for x in range(self.n)], dtype=np.float32)
pred = np.empty((self.n), dtype=np.int)
pred[source] = source
dist[source] = 0
for i in np.arange(1, self.n):
for e in range(len(self.edges)):
if dist[self.edges[e][0]] + self.costs[e] < dist[self.edges[e][1]]:
dist[self.edges[e][1]] = dist[
self.edges[e][0]] + self.costs[e]
pred[self.edges[e][1]] = self.edges[e][0]
for e in range(len(self.edges)):
if dist[self.edges[e][1]] > dist[self.edges[e][0]] + self.costs[e]:
print 'Error, Graph contains a negative-weight cycle'
break
edges = np.array([], dtype=object)
for v in range(len(pred)):
edges = np.append(edges, None)
edges[-1] = [pred[v], v]
return edges # , prev, dist
def floyd_warshall(self, source):
'''
Returns floyd_warshall's shortest paths from source to all other
nodes, if the (directed) graph doesn't contains negative cycles
'''
print '''warning! apply this algorithm only if constricted, it takes\\
O(n^3)!'''
print 'O(n^3) = O(', self.n**3, ')'
dist = np.empty((self.n, self.n), dtype=np.float32)
pred = np.zeros((self.n, self.n), dtype=np.int)
dist.fill(np.Infinity)
for v in range(self.n):
dist[v][v] = .0
for e in range(len(self.edges)):
u = self.edges[e][0]
v = self.edges[e][1]
dist[u][v] = self.costs[e]
pred[u][v] = v
for h in range(1, self.n):
for i in range(1, self.n):
for j in range(self.n):
if dist[i][h] + dist[h][j] < dist[i][j]:
dist[i][j] = dist[i][h] + dist[h][j]
pred[i][j] = pred[h][j]
for i in range(1, self.n):
if dist[i][i] < 0:
print 'Error! found negative cycle, thus the problem is inferiorly unlinmited'
return
edges = np.array([], dtype=object)
for v in range(len(pred)):
edges = np.append(edges, None)
edges[-1] = [pred[source][v], v]
return edges # , prev, dist
def bellman_ford(self, source):
'''
Returns Labels-algorithm's shortest paths from source to all other
nodes, if the (directed) graph doesn't contains cycles
'''
if self.oriented is False:
print 'cannot apply bellman_ford, graph is not oriented'
return
dist = np.array([np.Infinity for x in range(self.n)], dtype=np.float32)
pred = np.empty((self.n), dtype=np.int)
pred[source] = source
dist[source] = 0
for i in np.arange(1, self.n):
for e in range(len(self.edges)):
if dist[self.edges[e][0]] + self.costs[e] < dist[self.edges[e][1]]:
dist[self.edges[e][1]] = dist[
self.edges[e][0]] + self.costs[e]
pred[self.edges[e][1]] = self.edges[e][0]
for e in range(len(self.edges)):
if dist[self.edges[e][1]] > dist[self.edges[e][0]] + self.costs[e]:
print 'Error, Graph contains a negative-weight cycle'
break
edges = np.array([], dtype=object)
for v in range(len(pred)):
edges = np.append(edges, None)
edges[-1] = [pred[v], v]
return edges # , prev, dist
def floyd_warshall(self, source):
'''
Returns floyd_warshall's shortest paths from source to all other
nodes, if the (directed) graph doesn't contains negative cycles
'''
print '''warning! apply this algorithm only if constricted, it takes\\
O(n^3)!'''
print 'O(n^3) = O(', self.n**3, ')'
dist = np.empty((self.n, self.n), dtype=np.float32)
pred = np.zeros((self.n, self.n), dtype=np.int)
dist.fill(np.Infinity)
for v in range(self.n):
dist[v][v] = .0
for e in range(len(self.edges)):
u = self.edges[e][0]
v = self.edges[e][1]
dist[u][v] = self.costs[e]
pred[u][v] = v
for h in range(1, self.n):
for i in range(1, self.n):
for j in range(self.n):
if dist[i][h] + dist[h][j] < dist[i][j]:
dist[i][j] = dist[i][h] + dist[h][j]
pred[i][j] = pred[h][j]
for i in range(1, self.n):
if dist[i][i] < 0:
print 'Error! found negative cycle, thus the problem is inferiorly unlinmited'
return
edges = np.array([], dtype=object)
for v in range(len(pred)):
edges = np.append(edges, None)
edges[-1] = [pred[source][v], v]
return edges # , prev, dist
def predict(self, user, loc):
"""Predict the probability about user will checkin in loc.
prob = Pr[l|Li] = IIPr[l, li] (li in Li)
see: Exploiting Geographical Influence for Collaborative
Point-of-Interest Recommendation
"""
if user in self._cache:
if loc not in self._cache[user]:
return 0.0
return self._cache[user][loc]
self._cache[user] = {}
max_y = -np.Infinity
for l in xrange(self.num_items):
if l in self.checkins[user]:
continue
y = 0.0
for li in self.checkins[user]:
d = distance(self.locations[l], self.locations[li]) / 1000.0
y += np.log(self.prob(d))
if y > max_y:
max_y = y
self._cache[user][l] = y
for l, y in self._cache[user].items():
self._cache[user][l] = math.e ** (y - max_y)
if loc not in self._cache[user]:
return 0.0
return self._cache[user][loc]
def __init__(self, x=None, fitness=np.Infinity):
"""
Create object instance.
:param x: Position in the search-space aka. candidate solution.
:param fitness: Associated fitness of the position in the search-space.
:return: Object instance.
"""
# Copy arguments to instance variables.
self.x = x
self.fitness = fitness
########################################################################
def fitness(self, x, limit=np.Infinity):
return np.sum(x ** 2)
def fitness(self, x, limit=np.Infinity):
return np.sum(100.0 * (x[1:] - x[:-1] ** 2) ** 2 + (1.0 - x[:-1]) ** 2)
def fitness(self, x, limit=np.Infinity):
return np.sum(x ** 2 + 10.0 - 10.0 * np.cos(2 * np.pi * x))
def fitness(self, x, limit=np.Infinity):
return np.sum([np.sum(x[:i])**2 for i in range(self.dim)])
def fitness(self, x, limit=np.Infinity):
return np.max(np.abs(x))
def fitness(self, x, limit=np.Infinity):
absx = np.abs(x)
fitness = np.sum(absx) + np.prod(absx)
# For large dim, np.prod(absx) often overflows to infinity.
# This means the optimizers cannot work properly.
# So we limit the fitness to 1e20.
if fitness == np.Infinity or fitness > 1e20:
fitness = 1e20
return fitness
def fitness(self, x, limit=np.Infinity):
return np.sum(np.floor(x + 0.5) ** 2)
def fitness(self, x, limit=np.Infinity):
value = np.e + 20.0 - 20.0 * np.exp(-0.2 * np.sqrt(np.sum(x ** 2) / self.dim)) \
- np.exp(np.sum(np.cos(2 * np.pi * x)) / self.dim)
# Due to rounding errors, the value is sometimes slightly negative.
# This gives a warning in the MetaFitness-class.
if value < 0.0:
value = 0.0
return value
def fitness(self, x, limit=np.Infinity):
# Split the calculation into smaller formulas.
y = 1.0 + (x + 1.0) / 4.0
a = 10.0 * np.sin(np.pi * y[0]) ** 2
b = np.sum(((y[:-1] - 1.0) ** 2) * (1.0 + 10.0 * (np.sin(np.pi * y[1:]) ** 2)))
c = (y[-1] - 1.0) ** 2
# Penalty term.
penalty = _penalty(x, 10.0, 100.0, 4.0)
return np.pi * (a + b + c) / self.dim + penalty
def fitness(self, x, limit=np.Infinity):
# Split the calculation into smaller formulas.
a = np.sin(3 * np.pi * x[0]) ** 2
b = np.sum(((x[:-1] - 1.0) ** 2) * (1.0 + np.sin(3 * np.pi * x[1:]) ** 2))
c = (x[-1] - 1.0) ** 2 * (1.0 + np.sin(2 * np.pi * x[-1])**2)
# Penalty term.
penalty = _penalty(x, 5.0, 100.0, 4.0)
return 0.1 * (a + b + c) / self.dim + penalty
########################################################################
# List of all of the above classes for benchmark problems.
def sphere_func(x, limit=np.Infinity):
return np.sum(x*x)
########################################################################
def mu_fullsum_func(
mu,
node_vec,
eventmemes,
etimes,
T,
gamma,
alpha,
omega,
W,
beta,
kernel_evaluate,
K_evaluate,
):
'''
'''
# return -evaluate_nonapproximated_loglikelihood_wordsbyusers(node_vec, eventmemes, etimes,
# T, mu, gamma, alpha, omega, W, beta,
# kernel_evaluate, K_evaluate)
ll = 0
## alpha_summedrows=np.sum(alpha, axis=1)
for (eventidx, (infected_u, eventmeme, etime1)) in \
enumerate(izip(node_vec, eventmemes, etimes)):
# ll+=gamma[eventmeme]*mu[infected_u]
ll += event_nonapproximated_logintensity( # etimes, node_vec, eventmemes,
infected_u,
eventmeme,
etime1,
T,
etimes[:eventidx],
node_vec[:eventidx],
eventmemes[:eventidx],
mu,
gamma,
omega,
alpha,
kernel_evaluate,
)
## ll-=alpha_summedrows[int(infected_u)]*K_evaluate(etime1, T, omega)
## if -ll==np.Infinity:
## event_nonapproximated_logintensity(infected_u, eventmeme, etime1, T, etimes[:eventidx], node_vec[:eventidx],
## eventmemes[:eventidx], mu, gamma, omega, alpha, kernel_evaluate)
ll -= T * np.sum(np.outer(mu, gamma))
return -ll
# =====
def event_approximated_logintensity(
infected_u,
eventmeme,
etime1,
T,
etimes,
node_vec,
eventmemes,
mu,
gamma,
omega,
alpha,
kernel_evaluate,
print_summed_elements=False,
):
components = []
added_component = False
ll = 0
if mu[int(infected_u)] * gamma[int(eventmeme)] > 0:
ll += np.log(mu[int(infected_u)] * gamma[int(eventmeme)])
components.append(np.log(mu[int(infected_u)]
* gamma[int(eventmeme)]))
added_component = True
for (eventidx, (etime2, node2, eventmeme2)) in \
enumerate(izip(etimes, node_vec, eventmemes)):
if etime2 < etime1:
if eventmeme2 == eventmeme:
intensity_val = alpha[int(node2), int(infected_u)] \
* kernel_evaluate(etime1, etime2, omega)
if intensity_val > 0:
ll += np.log(intensity_val)
components.append(np.log(intensity_val))
added_component = True
# If there are other components then 0, we can ignore zeros; however,
# if there are no components whatsoever, then we get minus infinity
if not added_component:
ll = -np.Infinity
if print_summed_elements:
print '\t\t\t\t\t\t\t\t\t\t\t[event_approximated_logintensity] intensity=' \
+ '+ '.join(map(lambda x: '%10.6f' % x, components))
return ll
def evaluate_loglikelihood_nowords(
node_vec,
eventmemes,
etimes,
T,
mu,
gamma,
alpha,
omega,
kernel_evaluate,
K_evaluate,
event_logintensity_func,
):
ll = 0
alpha_summedrows = np.sum(alpha, axis=1)
for (eventidx, (infected_u, eventmeme, etime1)) in \
enumerate(izip(node_vec, eventmemes, etimes)):
ll += event_logintensity_func(
infected_u,
eventmeme,
etime1,
T,
etimes[:eventidx],
node_vec[:eventidx],
eventmemes[:eventidx],
mu,
gamma,
omega,
alpha,
kernel_evaluate,
)
ll -= alpha_summedrows[int(infected_u)] * K_evaluate(etime1, T,
omega)
if -ll == np.Infinity:
event_logintensity_func(
infected_u,
eventmeme,
etime1,
T,
etimes[:eventidx],
node_vec[:eventidx],
eventmemes[:eventidx],
mu,
gamma,
omega,
alpha,
kernel_evaluate,
)
ll -= T * np.sum(np.outer(mu, gamma))
return ll
# TODO: need to write a test for this!
def alpha_fullsum_func(
alpha,
node_vec,
eventmemes,
etimes,
T,
mu,
gamma,
omega,
W,
beta,
kernel_evaluate,
K_evaluate,
):
'''
'''
# res=0
# for alphaij_sub in alphaij:
# alpha[indexes[0]][indexes[1]]=alphaij_sub
# res=evaluate_nonapproximated_loglikelihood_wordsbyusers(node_vec, eventmemes, etimes,
# T, mu, gamma, alpha, omega, W, beta,
# kernel_evaluate, K_evaluate)
ll = 0
alpha_summedrows = np.sum(alpha, axis=1)
for (eventidx, (infected_u, eventmeme, etime1)) in \
enumerate(izip(node_vec, eventmemes, etimes)):
ll += event_nonapproximated_logintensity(
infected_u,
eventmeme,
etime1,
T,
etimes[:eventidx],
node_vec[:eventidx],
eventmemes[:eventidx],
mu,
gamma,
omega,
alpha,
kernel_evaluate,
)
ll -= alpha_summedrows[int(infected_u)] * K_evaluate(etime1, T,
omega)
# if -ll==np.Infinity:
# event_nonapproximated_logintensity(infected_u, eventmeme, etime1, T,
# etimes[:eventidx], node_vec[:eventidx], eventmemes[:eventidx],
# mu, gamma, omega, alpha, kernel_evaluate)
#
# ll-=T*np.sum(np.outer(mu, gamma))
return -ll
# =====