Python numpy.Infinity() 使用实例

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 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 

Example 2

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 

Example 3

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

######################################################################## 

Example 4

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


######################################################################## 

Example 5

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) 

Example 6

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 

Example 7

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 

Example 8

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 

Example 9

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 

Example 10

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 

Example 11

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] 

Example 12

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


######################################################################## 

Example 13

def fitness(self, x, limit=np.Infinity):
        return np.sum(x ** 2) 

Example 14

def fitness(self, x, limit=np.Infinity):
        return np.sum(100.0 * (x[1:] - x[:-1] ** 2) ** 2 + (1.0 - x[:-1]) ** 2) 

Example 15

def fitness(self, x, limit=np.Infinity):
        return np.sum(x ** 2 + 10.0 - 10.0 * np.cos(2 * np.pi * x)) 

Example 16

def fitness(self, x, limit=np.Infinity):
        return np.sum([np.sum(x[:i])**2 for i in range(self.dim)]) 

Example 17

def fitness(self, x, limit=np.Infinity):
        return np.max(np.abs(x)) 

Example 18

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 

Example 19

def fitness(self, x, limit=np.Infinity):
        return np.sum(np.floor(x + 0.5) ** 2) 

Example 20

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 

Example 21

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 

Example 22

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. 

Example 23

def sphere_func(x, limit=np.Infinity):
    return np.sum(x*x)


######################################################################## 

Example 24

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


# ===== 

Example 25

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 

Example 26

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! 

Example 27

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


# ===== 
点赞

发表评论

电子邮件地址不会被公开。 必填项已用*标注