Python 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


# =====