+ )i.HRt^RIHt^RIt^RIHt^RIHt^RIH t RR.t !RR ]4t R t ] !] R4t ]PR 4t]PR 4t]PR 4t]P!RR7RRl4t] ]PR44tR#)zHFunctions for measuring the quality of a partition (into communities). ) combinationsN) NetworkXError) is_partition)argmap modularitypartition_qualityc6aa]tRt^toRtV3RltRtVtV;t#) NotAPartitionz0Raised if a given collection is not a partition.c4<V RV 2p\SV`V4R#)z' is not a valid partition of the graph N)super__init__)selfG collectionmsg __class__s&&& c/var/www/html/photoedit/myenv/lib/python3.14/site-packages/networkx/algorithms/community/quality.pyr NotAPartition.__init__s! CA3G ) __name__ __module__ __qualname____firstlineno____doc__r __static_attributes____classdictcell__ __classcell__)r __classdict__s@@rr r s:rr cV\W4'dW3#\P!R4h)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 G)rnxrr partitions&&r_require_partitionr#s):A!!|  S TTrc.a\V3RlV44#)a2Returns 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. c3b<"TF$pSPV4P4xK& R#5iN)subgraphsize).0blockrs& r (intra_community_edges..Ls&?YEqzz% %%''Ys,/)sumr!sf&rintra_community_edgesr.=s ?Y? ??rcVP4'd\PM\Pp\P!WVR7P 4#)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`. ) create_using) is_directedr MultiDiGraph MultiGraphquotient_graphr()rr"MGs&& rinter_community_edgesr6Os98MMOOB  Q ; @ @ BBrcB\\P!V4V4#)aKReturns 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`. )r6r complementr!s&&rinter_community_non_edgesr9os< !q!19 ==rweight) edge_attrsc`aaaaaaa a \V\4'g \V4p\SV4'g \SV4hSP 4oS'da\ SP SR74o \ SPSR74o\S P44o^S^,, o MO\ SPSR74;o o\S P44pV^, o^V^,, o VVVVV V VV3Rlp\\WQ44#)a/ 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 (or sum of all edge weights as in [5]_), $A$ is the adjacency matrix of `G`, $k_i$ is the (weighted) 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 .. [5] Blondel, V.D. et al. "Fast unfolding of communities in large networks" J. Stat. Mech 10008, 1-12 (2008). https://doi.org/10.1088/1742-5468/2008/10/P10008 )r:c <a\V4o\V3RlSPSS ^R744p\V 3RlS44pS'd\V3RlS44MTpVS, S V,V,S ,, #)c3><"TFwrq2S9gKVxK R#5ir&r)r)uvwtcomms& rr+=modularity..community_contribution..sX%JrSWi""%Js  )datadefaultc36<"TFpSV,xK R#5ir&r)r)r? out_degrees& rr+rCs9DqZ]]Dc36<"TFpSV,xK R#5ir&r)r)r? in_degrees& rr+rCs7$QIaLL$rH)setr-edges) communityL_cout_degree_sum in_degree_sumrBrdirectedrJmnormrG resolutionr:s & @rcommunity_contribution*modularity..community_contributionsm9~XQWWTW%JXX9D99;C7$77 Qwn4}DtKKKr) isinstancelistrr r1dictrGrJr-valuesdegreemap) r communitiesr:rTdeg_sumrUrQrJrRrSrGs f&ff @@@@@rrrsj k4 ( (;' ; ' 'A{++}}H!,,f,56 F34  !!# $1a4x!%ahhfh&=!>> Yj'')* aK7A:~LL s)7 88rc/p\V4Fwr4VFpW2V&K K VP4'g=\R\V^444pVP 4'd V^,pM^p\ V4pWw^, ,pVP 4'g V^,p^p Tp VP 4F8p W+^,,W+^,,8Xd V ^, p K/V ^,p K: V \ VP 4, p VP4'dRp W3#W,V, p W3#)aReturns 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 c3\"TF"wr\V4\V4,xK$ R#5ir&)len)r)p1p2s& rr+$partition_quality..:s&- ,F&"CGc"g  ,Fs*,g) enumerate is_multigraphr-rr1rarL)rr"node_communityirMnodepossible_inter_community_edgesn total_pairsr.r9ecoverage performances&& rrrs8`N!), D#$4 - ??  ),- ,8A,F- * & ==?? *a / *)*& AA1u+K ==??  >WWY A$ >A$#7 7 !Q & ! % * %  %s177|3H    -HKW   r))r:rq)r itertoolsrnetworkxr r-networkx.algorithms.community.community_utilsrnetworkx.utils.decoratorsr__all__r r#require_partition _dispatchabler.r6r9rrrrrrys #"F, , -MUD-v6@@"CC>>>@X&n9'n9bW!W!r