sh1 `SSKrSSKrS/r\R"SS9SSSSSSSS.Sj5rS rg) Nbirankweight) edge_attrsdgư>)alphabetatop_personalizationbottom_personalizationmax_itertolrc SSKn SSKn [U5n [U5U - n [U 5n [U 5nU S:XdUS:Xa[R "S5e[ U5n[ U5nUc U(aSOSnUc U(aSOSnUS:dUS:a[R "S5eUS:dUS:a[R "S5eU RU Vs/sHoRUS5PM sn[S9nU RU Vs/sHoRUS5PM sn[S9n[RRX X[S 9nURS[S 9nS UUS:H'U RRS U RU5- /S/4X4[S 9nURS[S 9nS UUS:H'U RRS U RU5- /S/4X4[S 9nUR!5U-UR!5-nUR"nU R%U [S9U - nUUU--SU- U--n['U5GHQnUnUnUUU--SU- U--nUUU--SU- U--nU R)UU- U R+S U5- 5R5nU[U5U-:aMsU R)UU- U R+S U5- 5R5nU[U5U-:aMUS:XaDUS:Xa>UU R,R/US5- nUU R,R/US5- n[1[3[4R6"X5[9[[4R6"UU5555s $ [R:"U5es snfs snf) upCompute the BiRank score for nodes in a bipartite network. Given the bipartite sets $U$ and $P$, the BiRank algorithm seeks to satisfy the following recursive relationships between the scores of nodes $j \in P$ and $i \in U$: .. math:: p_j = \alpha \sum_{i \in U} \frac{w_{ij}}{\sqrt{d_i}\sqrt{d_j}} u_i + (1 - \alpha) p_j^0 u_i = \beta \sum_{j \in P} \frac{w_{ij}}{\sqrt{d_i}\sqrt{d_j}} p_j + (1 - \beta) u_i^0 where * $p_j$ and $u_i$ are the BiRank scores of nodes $j \in P$ and $i \in U$. * $w_{ij}$ is the weight of the edge between nodes $i \in U$ and $j \in P$ (With a value of 0 if no edge exists). * $d_i$ and $d_j$ are the weighted degrees of nodes $i \in U$ and $j \in P$, respectively. * $p_j^0$ and $u_i^0$ are personalization values that can encode a priori weights for the nodes $j \in P$ and $i \in U$, respectively. Akin to the personalization vector used by PageRank. * $\alpha$ and $\beta$ are damping hyperparameters applying to nodes in $P$ and $U$ respectively. They can take values in the interval $[0, 1]$, and are analogous to those used by PageRank. Below are two use cases for this algorithm. 1. Personalized Recommendation System Given a bipartite graph representing users and items, BiRank can be used as a collaborative filtering algorithm to recommend items to users. Previous ratings are encoded as edge weights, and the specific ratings of an individual user on a set of items is used as the personalization vector over items. See the example below for an implementation of this on a toy dataset provided in [1]_. 2. Popularity Prediction Given a bipartite graph representing user interactions with items, e.g. commits to a GitHub repository, BiRank can be used to predict the popularity of a given item. Edge weights should encode the strength of the interaction signal. This could be a raw count, or weighted by a time decay function like that specified in Eq. (15) of [1]_. The personalization vectors can be used to encode existing popularity signals, for example, the monthly download count of a repository's package. Parameters ---------- G : graph A bipartite network nodes : iterable of nodes Container with all nodes belonging to the first bipartite node set ('top'). The nodes in this set use the hyperparameter `alpha`, and the personalization dictionary `top_personalization`. The nodes in the second bipartite node set ('bottom') are automatically determined by taking the complement of 'top' with respect to the graph `G`. alpha : float, optional (default=0.80 if top_personalization not empty, else 1) Damping factor for the 'top' nodes. Must be in the interval $[0, 1]$. Larger alpha and beta generally reduce the effect of the personalizations and increase the number of iterations before convergence. Choice of value is largely dependent on use case, and experimentation is recommended. beta : float, optional (default=0.80 if bottom_personalization not empty, else 1) Damping factor for the 'bottom' nodes. Must be in the interval $[0, 1]$. Larger alpha and beta generally reduce the effect of the personalizations and increase the number of iterations before convergence. Choice of value is largely dependent on use case, and experimentation is recommended. top_personalization : dict, optional (default=None) Dictionary keyed by nodes in 'top' to that node's personalization value. Unspecified nodes in 'top' will be assigned a personalization value of 0. Personalization values are used to encode a priori weights for a given node, and should be non-negative. bottom_personalization : dict, optional (default=None) Dictionary keyed by nodes in 'bottom' to that node's personalization value. Unspecified nodes in 'bottom' will be assigned a personalization value of 0. Personalization values are used to encode a priori weights for a given node, and should be non-negative. max_iter : int, optional (default=100) Maximum number of iterations in power method eigenvalue solver. tol : float, optional (default=1.0e-6) Error tolerance used to check convergence in power method solver. The iteration will stop after a tolerance of both ``len(top) * tol`` and ``len(bottom) * tol`` is reached for nodes in 'top' and 'bottom' respectively. weight : string or None, optional (default='weight') Edge data key to use as weight. Returns ------- birank : dictionary Dictionary keyed by node to that node's BiRank score. Raises ------ NetworkXAlgorithmError If the parameters `alpha` or `beta` are not in the interval [0, 1], if either of the bipartite sets are empty, or if negative values are provided in the personalization dictionaries. PowerIterationFailedConvergence If the algorithm fails to converge to the specified tolerance within the specified number of iterations of the power iteration method. Examples -------- Construct a bipartite graph with user-item ratings and use BiRank to recommend items to a user (user 1). The example below uses the `rating` edge attribute as the weight of the edges. The `top_personalization` vector is used to encode the user's previous ratings on items. Creation of graph, bipartite sets for the example. >>> elist = [ ... ("u1", "p1", 5), ... ("u2", "p1", 5), ... ("u2", "p2", 4), ... ("u3", "p1", 3), ... ("u3", "p3", 2), ... ] >>> G = nx.Graph() >>> G.add_weighted_edges_from(elist, weight="rating") >>> product_nodes = ("p1", "p2", "p3") >>> user = "u1" First, we create a personalization vector for the user based on on their ratings of past items. In this case they have only rated one item (p1, with a rating of 5) in the past. >>> user_personalization = { ... product: rating ... for _, product, rating in G.edges(nbunch=user, data="rating") ... } >>> user_personalization {'p1': 5} Calculate the BiRank score of all nodes in the graph, filter for the items that the user has not rated yet, and sort the results by score. >>> user_birank_results = nx.bipartite.birank( ... G, product_nodes, top_personalization=user_personalization, weight="rating" ... ) >>> user_birank_results = filter( ... lambda item: item[0][0] == "p" and user not in G.neighbors(item[0]), ... user_birank_results.items(), ... ) >>> user_birank_results = sorted( ... user_birank_results, key=lambda item: item[1], reverse=True ... ) >>> user_recommendations = { ... product: round(score, 5) for product, score in user_birank_results ... } >>> user_recommendations {'p2': 1.44818, 'p3': 1.04811} We find that user 1 should be recommended item p2 over item p3. This is due to the fact that user 2 rated also rated p1 highly, while user 3 did not. Thus user 2's tastes are inferred to be similar to user 1's, and carry more weight in the recommendation. See Also -------- :func:`~networkx.algorithms.link_analysis.pagerank_alg.pagerank` :func:`~networkx.algorithms.link_analysis.hits_alg.hits` :func:`~networkx.algorithms.bipartite.centrality.betweenness_centrality` :func:`~networkx.algorithms.bipartite.basic.sets` :func:`~networkx.algorithms.bipartite.basic.is_bipartite` Notes ----- The `nodes` input parameter must contain all nodes in one bipartite node set, but the dictionary returned contains all nodes from both bipartite node sets. See :mod:`bipartite documentation ` for further details on how bipartite graphs are handled in NetworkX. In the case a personalization dictionary is not provided for top (bottom) `alpha` (`beta`) will default to 1. This is because a damping factor without a non-zero entry in the personalization vector will lead to the algorithm converging to the zero vector. References ---------- .. [1] Xiangnan He, Ming Gao, Min-Yen Kan, and Dingxian Wang. 2017. BiRank: Towards Ranking on Bipartite Graphs. IEEE Trans. on Knowl. and Data Eng. 29, 1 (January 2017), 57–71. https://arxiv.org/pdf/1708.04396 rNzRThe BiRank algorithm requires a bipartite graph with at least onenode in each set.g?z$alpha must be in the interval [0, 1]z#beta must be in the interval [0, 1])dtype)rr)axisrg?)shaper)numpyscipysetlennxNetworkXAlgorithmError_clean_personalization_dictarraygetfloat bipartitebiadjacency_matrixsumsparse dia_arraysqrttocsrTonesrangeabsolutemaximumlinalgnormdictzip itertoolschainmapPowerIterationFailedConvergence) Gnodesrrr r r r rnpsptopbottom top_count bottom_countnp0u0W p_degreesD_p u_degreesD_uSS_Tpu_p_lastu_lasterr_uerr_ps /Users/tiagomarins/Projetos/claudeai/copy_bank/venv/lib/python3.13/site-packages/networkx/algorithms/bipartite/link_analysis.pyrrsf e*C Vc\FCIv;LA~*''   66IJ89OP }* |,s! qyEAI''(NOO ax4!8''(MNN #>#Q**1a0#>e LB VDV--a3VDE RB ''3U'SA1E*I #Ii1n ))    " " #aS)$  C 1E*I #Ii1n ))    " " #aS)*  C a#))+%A ##C  ')3A A!d(b(A8_ S1W Ub 0 0 AENa$h"_ , VaZ2::c6+BBCGGI CFSL  VaZ2::c6+BBCGGI CFSL  A:$!)BIINN1a((ABIINN1a((A  ,c%A9N.O P  /8 , ,X 66q?Ds OOcUc0$[SUR555(a[R"S5eUR 5VVs0sHupUS:wdM X_M snn$s snnf)z}Filter out zero values from the personalization dictionary, handle case where None is passed, ensure values are non-negative.c3*# UH oS:v M g7f)rN).0values rI ._clean_personalization_dict..:s ;":19":sz,Personalization values must be non-negative.r)anyvaluesrritems)personalizationnoderNs rIrr5sj  ;/"8"8": ;;;''(VWW+:+@+@+B Q+BKDeqjKDK+B QQ Qs  A.$A.)r,networkxr__all__ _dispatchablerrrLrIrZsQ *X&    i7'i7X RrY