U 9%e-@sdZddlmZddlZddlmZddlmZddlm Z ddl m Z dd gZ Gd d d eZ d d Ze edZejddZejddZddZdddZedd ZdS)zHFunctions for measuring the quality of a partition (into communities). ) combinationsN) NetworkXError) is_partition)not_implemented_for)argmap modularitypartition_qualitycs eZdZdZfddZZS) NotAPartitionz0Raised if a given collection is not a partition.cs|d|}t|dS)Nz' is not a valid partition of the graph )super__init__)selfGZ collectionmsg __class__d/var/www/html/Darija-Ai-API/env/lib/python3.8/site-packages/networkx/algorithms/community/quality.pyr szNotAPartition.__init__)__name__ __module__ __qualname____doc__r __classcell__rrrrr sr cCs t||r||fStddS)aDecorator to check that a valid partition is input to a function Raises :exc:`networkx.NetworkXError` if the partition is not valid. This decorator should be used on functions whose first two arguments are a graph and a partition of the nodes of that graph (in that order):: >>> @require_partition ... def foo(G, partition): ... print("partition is valid!") ... >>> G = nx.complete_graph(5) >>> partition = [{0, 1}, {2, 3}, {4}] >>> foo(G, partition) partition is valid! >>> partition = [{0}, {2, 3}, {4}] >>> foo(G, partition) Traceback (most recent call last): ... networkx.exception.NetworkXError: `partition` is not a valid partition of the nodes of G >>> partition = [{0, 1}, {1, 2, 3}, {4}] >>> foo(G, partition) Traceback (most recent call last): ... networkx.exception.NetworkXError: `partition` is not a valid partition of the nodes of G z6`partition` is not a valid partition of the nodes of GN)rnxrr partitionrrr_require_partitions r)rcstfdd|DS)aRReturns the number of intra-community edges for a partition of `G`. Parameters ---------- G : NetworkX graph. partition : iterable of sets of nodes This must be a partition of the nodes of `G`. The "intra-community edges" are those edges joining a pair of nodes in the same block of the partition. c3s|]}|VqdSN)Zsubgraphsize).0blockr rr Msz(intra_community_edges..)sumrrr!rintra_community_edges>sr$cCs(|rtjntj}tj|||dS)aReturns the number of inter-community edges for a partition of `G`. according to the given partition of the nodes of `G`. Parameters ---------- G : NetworkX graph. partition : iterable of sets of nodes This must be a partition of the nodes of `G`. The *inter-community edges* are those edges joining a pair of nodes in different blocks of the partition. Implementation note: this function creates an intermediate graph that may require the same amount of memory as that of `G`. )Z create_using) is_directedrZ MultiDiGraphZ MultiGraphZquotient_graphr)r rZMGrrrinter_community_edgesPsr&cCstt||S)aReturns the number of inter-community non-edges according to the given partition of the nodes of `G`. Parameters ---------- G : NetworkX graph. partition : iterable of sets of nodes This must be a partition of the nodes of `G`. A *non-edge* is a pair of nodes (undirected if `G` is undirected) that are not adjacent in `G`. The *inter-community non-edges* are those non-edges on a pair of nodes in different blocks of the partition. Implementation note: this function creates two intermediate graphs, which may require up to twice the amount of memory as required to store `G`. )r&rZ complementrrrrinter_community_non_edgespsr'weightrcst|tst|}t|s&t|rltjdtjdt ddn4tj dt }|dd|dfdd}tt ||S)aN Returns the modularity of the given partition of the graph. Modularity is defined in [1]_ as .. math:: Q = \frac{1}{2m} \sum_{ij} \left( A_{ij} - \gamma\frac{k_ik_j}{2m}\right) \delta(c_i,c_j) where $m$ is the number of edges, $A$ is the adjacency matrix of `G`, $k_i$ is the degree of $i$, $\gamma$ is the resolution parameter, and $\delta(c_i, c_j)$ is 1 if $i$ and $j$ are in the same community else 0. According to [2]_ (and verified by some algebra) this can be reduced to .. math:: Q = \sum_{c=1}^{n} \left[ \frac{L_c}{m} - \gamma\left( \frac{k_c}{2m} \right) ^2 \right] where the sum iterates over all communities $c$, $m$ is the number of edges, $L_c$ is the number of intra-community links for community $c$, $k_c$ is the sum of degrees of the nodes in community $c$, and $\gamma$ is the resolution parameter. The resolution parameter sets an arbitrary tradeoff between intra-group edges and inter-group edges. More complex grouping patterns can be discovered by analyzing the same network with multiple values of gamma and then combining the results [3]_. That said, it is very common to simply use gamma=1. More on the choice of gamma is in [4]_. The second formula is the one actually used in calculation of the modularity. For directed graphs the second formula replaces $k_c$ with $k^{in}_c k^{out}_c$. Parameters ---------- G : NetworkX Graph communities : list or iterable of set of nodes These node sets must represent a partition of G's nodes. weight : string or None, optional (default="weight") The edge attribute that holds the numerical value used as a weight. If None or an edge does not have that attribute, then that edge has weight 1. resolution : float (default=1) If resolution is less than 1, modularity favors larger communities. Greater than 1 favors smaller communities. Returns ------- Q : float The modularity of the partition. Raises ------ NotAPartition If `communities` is not a partition of the nodes of `G`. Examples -------- >>> G = nx.barbell_graph(3, 0) >>> nx.community.modularity(G, [{0, 1, 2}, {3, 4, 5}]) 0.35714285714285715 >>> nx.community.modularity(G, nx.community.label_propagation_communities(G)) 0.35714285714285715 References ---------- .. [1] M. E. J. Newman "Networks: An Introduction", page 224. Oxford University Press, 2011. .. [2] Clauset, Aaron, Mark EJ Newman, and Cristopher Moore. "Finding community structure in very large networks." Phys. Rev. E 70.6 (2004). .. [3] Reichardt and Bornholdt "Statistical Mechanics of Community Detection" Phys. Rev. E 74, 016110, 2006. https://doi.org/10.1103/PhysRevE.74.016110 .. [4] M. E. J. Newman, "Equivalence between modularity optimization and maximum likelihood methods for community detection" Phys. Rev. E 94, 052315, 2016. https://doi.org/10.1103/PhysRevE.94.052315 )r(rcsvt|tfddjddD}tfddD}rZtfddDn|}|||S)Nc3s |]\}}}|kr|VqdSrr)ruvwtZcommrrr"sz=modularity..community_contribution..r)datadefaultc3s|]}|VqdSrrrr*) out_degreerrr"sc3s|]}|VqdSrrr0) in_degreerrr"s)setr#edges) communityZL_cZout_degree_sumZ in_degree_sumr Zdirectedr2mZnormr1 resolutionr(r-rcommunity_contributions "z*modularity..community_contribution) isinstancelistrr r%dictr1r2r#valuesZdegreemap)r Z communitiesr(r8Zdeg_sumr9rr6rrs Q       cCsi}t|D]\}}|D] }|||<qq |sZtddt|dD}|r^|d9}nd}t|}||d}|s|d}d} |} |D].} || d|| dkr| d7} q| d8} q| t|j} |rd} n | | |} | | fS)aSReturns the coverage and performance of a partition of G. The *coverage* of a partition is the ratio of the number of intra-community edges to the total number of edges in the graph. The *performance* of a partition is the number of intra-community edges plus inter-community non-edges divided by the total number of potential edges. This algorithm has complexity $O(C^2 + L)$ where C is the number of communities and L is the number of links. Parameters ---------- G : NetworkX graph partition : sequence Partition of the nodes of `G`, represented as a sequence of sets of nodes (blocks). Each block of the partition represents a community. Returns ------- (float, float) The (coverage, performance) tuple of the partition, as defined above. Raises ------ NetworkXError If `partition` is not a valid partition of the nodes of `G`. Notes ----- If `G` is a multigraph; - for coverage, the multiplicity of edges is counted - for performance, the result is -1 (total number of possible edges is not defined) References ---------- .. [1] Santo Fortunato. "Community Detection in Graphs". *Physical Reports*, Volume 486, Issue 3--5 pp. 75--174 css"|]\}}t|t|VqdSr)len)rp1p2rrrr"4sz$partition_quality..r)rrg) enumerateZ is_multigraphr#rr%r?r4)r rZnode_communityir5nodeZpossible_inter_community_edgesnZ total_pairsr$r'eZcoverageZ performancerrrrs4.       )r(r)r itertoolsrZnetworkxrrZ-networkx.algorithms.community.community_utilsrZnetworkx.utilsrZnetworkx.utils.decoratorsr__all__r rZrequire_partition _dispatchr$r&r'rrrrrrs$     "    n