Python networkx.eigenvector_centrality方法代码示例

# 需要导入模块: import networkx [as 别名]
# 或者: from networkx import eigenvector_centrality [as 别名]
def test_K5(self):
        """Eigenvector centrality: K5"""
        G=networkx.complete_graph(5)
        b=networkx.eigenvector_centrality(G)
        v=math.sqrt(1/5.0)
        b_answer=dict.fromkeys(G,v)
        for n in sorted(G):
            assert_almost_equal(b[n],b_answer[n])
        nstart = dict([(n,1) for n in G])
        b=networkx.eigenvector_centrality(G,nstart=nstart)
        for n in sorted(G):
            assert_almost_equal(b[n],b_answer[n])


        b=networkx.eigenvector_centrality_numpy(G)
        for n in sorted(G):
            assert_almost_equal(b[n],b_answer[n],places=3) 

# 需要导入模块: import networkx [as 别名]
# 或者: from networkx import eigenvector_centrality [as 别名]
def _calc_graph_func(p):
    con, times_chunk, graph_func = p
    vals = []
    now = time.time()
    for run, t in enumerate(times_chunk):
        utils.time_to_go(now, run, len(times_chunk), 10)
        con_t = con[:, :, t]
        g = nx.from_numpy_matrix(con_t)
        if graph_func == 'closeness_centrality':
            x = nx.closeness_centrality(g)
        elif graph_func == 'degree_centrality':
            x = nx.degree_centrality(g)
        elif graph_func == 'eigenvector_centrality':
            x = nx.eigenvector_centrality(g, max_iter=10000)
        elif graph_func == 'katz_centrality':
            x = nx.katz_centrality(g, max_iter=100000)
        else:
            raise Exception('Wrong graph func!')
        vals.append([x[k] for k in range(len(x))])
    vals = np.array(vals)
    return vals, times_chunk 

# 需要导入模块: import networkx [as 别名]
# 或者: from networkx import eigenvector_centrality [as 别名]
def test_K5(self):
        """Eigenvector centrality: K5"""
        G = nx.complete_graph(5)
        b = nx.eigenvector_centrality(G)
        v = math.sqrt(1 / 5.0)
        b_answer = dict.fromkeys(G, v)
        for n in sorted(G):
            assert_almost_equal(b[n], b_answer[n])
        nstart = dict([(n, 1) for n in G])
        b = nx.eigenvector_centrality(G, nstart=nstart)
        for n in sorted(G):
            assert_almost_equal(b[n], b_answer[n])

        b = nx.eigenvector_centrality_numpy(G)
        for n in sorted(G):
            assert_almost_equal(b[n], b_answer[n], places=3) 

# 需要导入模块: import networkx [as 别名]
# 或者: from networkx import eigenvector_centrality [as 别名]
def test_K5(self):
        """Eigenvector centrality: K5"""
        G=nx.complete_graph(5)
        b=nx.eigenvector_centrality(G)
        v=math.sqrt(1/5.0)
        b_answer=dict.fromkeys(G,v)
        for n in sorted(G):
            assert_almost_equal(b[n],b_answer[n])
        nstart = dict([(n,1) for n in G])
        b=nx.eigenvector_centrality(G,nstart=nstart)
        for n in sorted(G):
            assert_almost_equal(b[n],b_answer[n])


        b=nx.eigenvector_centrality_numpy(G)
        for n in sorted(G):
            assert_almost_equal(b[n],b_answer[n],places=3) 

# 需要导入模块: import networkx [as 别名]
# 或者: from networkx import eigenvector_centrality [as 别名]
def test_interact_with_env_replicable_randomagent(self):
    graph = nx.karate_club_graph()
    centrality = nx.eigenvector_centrality(graph)
    sorted_nodes = sorted(
        centrality.keys(), key=lambda k: centrality[k], reverse=True)
    # Infect the 3rd through 5th most central people.
    initial_health_state = [
        1 if index in sorted_nodes[3:6] else 0
        for index in range(len(sorted_nodes))
    ]
    env, agent, _ = set_up_and_observe(
        population_graph=graph,
        initial_health_state=initial_health_state,
        agent_class=infectious_disease_agents.RandomAgent)
    test_util.run_test_simulation(env=env, agent=agent) 

# 需要导入模块: import networkx [as 别名]
# 或者: from networkx import eigenvector_centrality [as 别名]
def test_interact_with_env_replicable_centralityagent(self):
    graph = nx.karate_club_graph()
    centrality = nx.eigenvector_centrality(graph)
    sorted_nodes = sorted(
        centrality.keys(), key=lambda k: centrality[k], reverse=True)
    # Infect the 3rd through 5th most central people.
    initial_health_state = [
        1 if index in sorted_nodes[3:6] else 0
        for index in range(len(sorted_nodes))
    ]
    env, agent, _ = set_up_and_observe(
        population_graph=graph,
        initial_health_state=initial_health_state,
        agent_class=infectious_disease_agents.CentralityAgent)
    test_util.run_test_simulation(env=env, agent=agent) 

# 需要导入模块: import networkx [as 别名]
# 或者: from networkx import eigenvector_centrality [as 别名]
def test_centrality_treatment_ordering_correct(self):
    # Initialize a small example graph and sort nodes by their centrality.
    graph = nx.karate_club_graph()
    centrality = nx.eigenvector_centrality(graph)
    sorted_nodes = sorted(
        centrality.keys(),
        key=lambda k: centrality[k],
        reverse=True)

    # Infect the 3rd through 5th most central people.  We expect these people to
    # be the 1st through 3rd people to receive treatment.
    initial_health_state = [
        1 if index in sorted_nodes[3:6] else 0
        for index in range(len(sorted_nodes))]

    # Initialize an environment with that initial health state and a centrality
    # agent.
    env, agent = instantiate_environment_and_agent(
        agent_class=infectious_disease_agents.CentralityAgent,
        population_graph=graph,
        initial_health_state=initial_health_state)

    # Confirm that the infected people are sorted by centrality in the agent's
    # action.  We expect 3rd the through 5th most central people to be the 1st
    # through 3rd people to receive treatment.
    observation = env._get_observable_state()
    action = agent.act(observation, False)
    self.assertEqual(sorted_nodes[3:6], action[:3].tolist()) 

# 需要导入模块: import networkx [as 别名]
# 或者: from networkx import eigenvector_centrality [as 别名]
def _triage(self, observation):
    """Returns person indices ordered from first to last person to treat.

    Infected people are prioritized above non-infected people, and infected
    people are ranked according to their centrality in the contact graph.

    Args:
      observation: An observation from a Dict Space with 'health_states' and
        'population_graph' keys.  The 'health_states' observation contains the
        health states of the population, and the 'population_graph' observation
        contains the contact graph over which disease spreads.

    Returns:
      A numpy array of population indices representing the triage order.
    """
    infections = _infection_indicator(
        observation['health_states'], self.initial_params.infectious_index)
    centrality = nx.eigenvector_centrality(observation['population_graph'])

    # Negate because lower scores are treated first. Note that centrality is a
    # dict that maps from node-keys to centrality values, and it happens
    # that the node keys are zero-counted contiguouos integers, which is
    # required for the following enumeration-based indexing to work out.  This
    # condition is checked by the assertion immediately below.
    assert list(
        observation['population_graph'].nodes()) == list(
            range(observation['population_graph'].number_of_nodes()))
    triage_scores = np.array([
        -infection * centrality[i] for i, infection in enumerate(infections)])

    max_treatments = len(self.action_space.nvec)
    return np.argsort(triage_scores)[:max_treatments] 

# 需要导入模块: import networkx [as 别名]
# 或者: from networkx import eigenvector_centrality [as 别名]
def test_maxiter(self):
        G=networkx.path_graph(3)
        b=networkx.eigenvector_centrality(G,max_iter=0) 

# 需要导入模块: import networkx [as 别名]
# 或者: from networkx import eigenvector_centrality [as 别名]
def test_eigenvector_centrality_weighted(self):
        G=self.G
        p=networkx.eigenvector_centrality(G)
        for (a,b) in zip(list(p.values()),self.G.evc):
            assert_almost_equal(a,b,places=4) 

# 需要导入模块: import networkx [as 别名]
# 或者: from networkx import eigenvector_centrality [as 别名]
def test_eigenvector_centrality_unweighted(self):
        G=self.H
        p=networkx.eigenvector_centrality(G)
        for (a,b) in zip(list(p.values()),self.G.evc):
            assert_almost_equal(a,b,places=4) 

# 需要导入模块: import networkx [as 别名]
# 或者: from networkx import eigenvector_centrality [as 别名]
def test_multigraph(self):
        e = networkx.eigenvector_centrality(networkx.MultiGraph()) 

# 需要导入模块: import networkx [as 别名]
# 或者: from networkx import eigenvector_centrality [as 别名]
def test_P3(self):
        """Eigenvector centrality: P3"""
        G = nx.path_graph(3)
        b_answer = {0: 0.5, 1: 0.7071, 2: 0.5}
        b = nx.eigenvector_centrality_numpy(G)
        for n in sorted(G):
            assert_almost_equal(b[n], b_answer[n], places=4)
        b = nx.eigenvector_centrality(G)
        for n in sorted(G):
            assert_almost_equal(b[n], b_answer[n], places=4) 

# 需要导入模块: import networkx [as 别名]
# 或者: from networkx import eigenvector_centrality [as 别名]
def test_maxiter(self):
        G = nx.path_graph(3)
        b = nx.eigenvector_centrality(G, max_iter=0) 

# 需要导入模块: import networkx [as 别名]
# 或者: from networkx import eigenvector_centrality [as 别名]
def test_eigenvector_centrality_weighted(self):
        G = self.G
        p = nx.eigenvector_centrality(G)
        for (a, b) in zip(list(p.values()), self.G.evc):
            assert_almost_equal(a, b, places=4)