~i.@SrSSKJr SSKrSSKJr SSKJr SSKJ r SS/r "S S \5r S r \ "\ S 5r \RS 5r\RS5r\RS5r\R"SS9SSj5r\ \RS55rg)zHFunctions for measuring the quality of a partition (into communities). ) combinationsN) NetworkXError) is_partition)argmap modularitypartition_qualityc,^\rSrSrSrU4SjrSrU=r$) NotAPartitionz0Raised if a given collection is not a partition.c2>USU3n[TU]U5 g)Nz' is not a valid partition of the graph )super__init__)selfG collectionmsg __class__s b/home/mande/repo/quber/.venv/lib/python3.13/site-packages/networkx/algorithms/community/quality.pyrNotAPartition.__init__s! CA3G )__name__ __module__ __qualname____firstlineno____doc__r__static_attributes__ __classcell__)rs@rr r s:rr cT[X5(aX4$[R"S5e)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 TTr)rc.^[U4SjU55$)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># UH$nTRU5R5v M& g7fN)subgraphsize).0blockrs r (intra_community_edges..Ls&?YEqzz% %%''Ys,/)sumr!s` rintra_community_edgesr/=s ?Y? ??rcUR5(a[RO[Rn[R"XUS9R 5$)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_edgesr7Os98MMOOB  Q ; @ @ BBrcB[[R"U5U5$)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`. )r7r complementr!s rinter_community_non_edgesr:os< !q!19 ==rweight) edge_attrsc ^^^^^^^ ^ [U[5(d [U5n[TU5(d [TU5eTR 5mT(aR[ TR TS95m [ TRTS95m[T R55mSTS-- m O@[ TRTS95=m m[T R55nUS- mSUS-- m UUUUU U UU4Sjn[[XQ55$)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;r$c >^[U5m[U4SjTRTT SS955n[U 4SjT55nT(a[U4SjT55OUnUT- T U-U-T -- $)Nc3<># UHupo2T;dM Uv M g7fr'r)r*uvwtcomms rr,=modularity..community_contribution..sX%JrSWi""%Js  r$)datadefaultc3.># UH nTUv M g7fr'r)r*rA out_degrees rr,rEs9DqZ]Dc3.># UH nTUv M g7fr'r)r*rA in_degrees rr,rEs7$QIaL$rJ)setr.edges) communityL_cout_degree_sum in_degree_sumrDrdirectedrLmnormrI resolutionr;s @rcommunity_contribution*modularity..community_contributionsm9~XQWWTW%JXX9D99;C7$77 Qwn4}DtKKKr) isinstancelistrr r2dictrIrLr.valuesdegreemap) r communitiesr;rVdeg_sumrWrSrLrTrUrIs ` `` @@@@@rrrsj k4 ( (;' ; ' 'A{++}}H!,,f,56 F34  !!# $1a4x!%ahhfh&=!>> Yj'')* aK7A:~LL s)7 88rc"0n[U5Hup4UHnX2U'M M UR5(d7[S[US555nUR 5(aUS-nOSn[ U5nXwS- -nUR 5(dUS-nSn Un UR 5Hn X+SX+S:XaU S- n MU S-n M! U [ UR 5- n UR5(aSn X4$X-U- n X4$)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 c3T# UHup[U5[U5-v M g7fr')len)r*p1p2s rr,$partition_quality..:s#- ,F&"CGc"g ,Fs&(r>rr$g) enumerate is_multigraphr.rr2rcrN)rr"node_communityirOnodepossible_inter_community_edgesn total_pairsr/r:ecoverage performances rrrs8`N!), D#$4 - ??  ),- ,8A,F- * & ==?? *a / *)*& AA1u+K ==??  >WWY A$ >A$#7 7 !Q & ! % * %  %s177|3H    -HKW   r)r;r$)r itertoolsrnetworkxr r-networkx.algorithms.community.community_utilsrnetworkx.utils.decoratorsr__all__r r#require_partition _dispatchabler/r7r:rrrrrrys #"F, , -MUD-v6@@"CC>>>@X&n9'n9bW!W!r