{'fraction_non_alphanumeric': 0.03156090826867235, 'fraction_numerical': 0.005307754558004475, 'mean_word_length': 4.709335507541786, 'pattern_counts': {'":': 0, '<': 1, '<?xml version=': 0, '>': 2, 'https://': 2, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
Co-Embedding: Discovering Communities on Bipartite Graphs through Projection

Many datasets take the form of a bipartite graph where two types of nodes are connected by relationships, like the movies watched by a user or the tags associated with a file. The partitioning of the bipartite graph could be used to fasten recommender systems, or reduce the information retrieval system's index size, by identifying groups of items with similar properties. This type of graph is often processed by algorithms using the Vector Space Model representation, where a binary vector represents an item with 0 and 1. The main problem with this representation is the dimension relatedness, like words' synonymity, which is not considered. This article proposes a co-clustering algorithm using items projection, allowing the measurement of features similarity. We evaluated our algorithm on a cluster retrieval task. Over various datasets, our algorithm produced well balanced clusters with coherent items in, leading to high retrieval scores on this task..


Introduction
Many datasets can be represented as a bipartite graph (BPG), making the links between two different types of items. This could be the movies a user watched, the purchases he made, the music he listened at. Outside of user interaction, it could be tags associated with a file, such as the keywords of an article, or the genes with which a molecule interacts.
Community discovery or graph partitioning helps improving scalability in different contexts. Collaborative Filtering Recommender Systems (CF RecSys) work by suggesting new items to a user based on the similarity of its history to the other users' history. Without optimization, a user is compared to all the other users to find those most similar to him. Clustering reduces costs by looking at similar users within the same partition rather than looking at them in the entire dataset (1). Clustering is not limited to users and has similar benefits when clustering items (2), or both together (3). These approaches are based on the clustering hypothesis (4) supposing that similar documents would answer the same information needs. Cluster-based retrieval systems are based on this same hypothesis (5,6). A very large database that cannot be stored in a single server could be split into multiple servers, hosting a particular thematic cluster. A query would be compared to an index with clusters' summary and routed to the most relevant server, reducing the overall number of operations.
There are different approaches to cluster a bipartite graph. The algorithms can be classified into two distinct categories: one-way and two-way partitioning algorithms, with the latter grouping both sides of the graph simultaneously. In the one-way approach, the set of nodes belonging to the same type are clustered, without considering the clusters that would be obtained when clustering the nodes from the other type. The nodes to cluster are often represented into a matrix using the Vector Space Model (VSM) (7), where the nodes of the second type are considered as their features (8) or used to construct the features (9). The resulting matrix can be exploited to cluster items with usual algorithms such as k-means, measure the items' proximity using cosine similarity measure, or project items using dimensionality reduction algorithms (9).
Another possibility is to convert the 2-mode graph into a 1-mode graph by collapsing the graph. The conversion to a unipartite graph is convenient as many classical community detection algorithms can be used (10). The nodes from a single type are preserved and new weighted edges are inferred from the bipartite graph. There are multiple approaches to convert the bipartite graph into a unipartite graph (11,12). However, the main problem is the growing number of edges and the loss of information due to the collapse (10,11).
In contrast, two-way clustering algorithms -also called co-clustering or simultaneous clustering (13) -exploit the raw structure to cluster both types of nodes simultaneously. Two-way approaches lead to better results, even if the goal is to partition only one side of the BPG (13,14) by exploiting synergies between the obtained clusters.
Among co-clustering approaches, the majority of the literature focuses on bi-clustering approaches, where a bicluster is characterized by a particular set of rows and columns when the BPG is represented under the matrix form. Therefore, a bicluster gathers items of heterogeneous type. There exist sub-categories characterized by the possibility to overlap clusters and to assign an item to multiple clusters (15). The majority of the algorithms creates biclusters with exclusive rows and columns (10,16,17). In this situation, the models assume a one-to-one match between sample and feature clusters and strong connectivity, forming blocks when visualizing the matrix with items grouped by clusters. This clustering type is -to some extent -equivalent to finding sub-graphs forming dense structures (10) that could exist without the other groups.
In contrast, the literature covering the case where a cluster gathers items of the same type is limited. While this case seems to correspond to the one-way partitioning, it highly differs from it as a row (column) cluster is expressed as a mixture of column (row) clusters. In contrast, the one-way approach considers features individually. Among this group, we can mention non-negative matrix factorization (NMF) approaches (18,19). This approach offers a more flexible framework than the latent block model leading to a checkerboard representation when re-ordering rows and columns by groups. Nonetheless, this approach assumes that there are latent variables connecting rows to columns; therefore we obtain the same number of row and column clusters.
In this work, we particularly focus on the case where the number of row and column clusters are not necessarily equal. These approaches are more flexible as the number of clusters is not constrained by the reciprocal type of items and increase the number of possible configurations. In this group, we can mention (20) combining a spectral decomposition to a k-means, and (14) based on information theory minimizing the loss of mutual information between clustered and unclustered items. These models require as input the number of clusters to find, limiting their usability without prior knowledge. The work of (21) extends the latent block model to cluster heterogeneous data types (ordinal, continuous, count). Samples are clustered into groups without specific constraints, while features are clustered with features of the same type. The number of feature clusters is automatically inferred and independent from the number of sample clusters, leading to a flexible automatic co-clustering approach.
Most of these approaches are designed for very general cases and do not assume the underlying nature of BPG. More specifically, they do not consider dimension relatedness. If animals are features like [tiger, lion, frog], the distance between their respective binary vectors [1, 0, 0], [0, 1, 0] and [0, 0, 1] is 2 for all possible pairs despite the similarity between tiger and lion. The different features are considered as orthogonal, while it is far from the reality where some characteristics are often correlated, even weakly.
Dimension relatedness has been addressed mainly for textual applications. The works of (22,23) propose using an external database (WordNet and Wikipedia resp.) to measure dimension relatedness. Over a very large corpus, the dimension correlation could be learned, as proposed in the work of (24). However, an external database is not always available, depending on the language used, and the type of objects considered. The work of (25) suggest learning the similarities between features by directly measuring their textual similarity. Feature similarity is derived from the Levenshtein distance between the feature names.
These different textual approaches learn the distances between features, but none between samples. One would like to apply the same treatment to samples and features in a co-clustering approach exploiting the sample-feature duality.
In this article, we propose a co-clustering algorithm that addresses the problem of dimension relatedness. The proposed approach follows a co-embedding process, where each side of the bipartite graph is projected in a low dimensional space. This projection enables to measure items relatedness based on their features' location. The process alternates between projecting each side of the graph, until invariance compared to the previous embedding.
The rest of this article is organized as follows. First, the algorithm is detailed in the following section, then the datasets and evaluation methods are presented. Visual, numerical, and textual results are then presented in the experimental section, followed by possible extensions in the discussion and a conclusion.

Co-Embedding
Notations: A bipartite graph G = (V I , V II , E) is a graph composed of two types of nodes The edges E connecting nodes only exist between nodes of different types E ⊆ V I × V II . The existence of a link between two nodes v I ∈ V I and v II ∈ V II is denoted as and defined similarly for a node of V II .
Sample-Feature Duality: A feature is relative to the sample's type considered. Nodes of V I are features of V II and V II of V I . Therefore, the equations would be written in terms of samples S and features F instead of V I and V II , as our process inverses periodically the roles. As most of the datasets used correspond to (tag, resources) pairs, we would refer to tags T and resources R when a difference needs to be underlined.
Proposed Approach: We address the problem of dimension relatedness for co-clustering a bipartite graph by projecting the items into a low dimensional space. The samples relatedness is measured by comparing their features' location on the embedding space. Based on their similarity, samples are next embedded into another low dimensional space using the t-SNE algorithm (26) which is a key point in the process. Next, samples and features exchange their role to start a new iteration. The process is repeated several times until the neighborhood around each item is stable. The last step of our method is an automated clustering using the Mean-Shift algorithm (27) over the two last co-embedding.
The details of each step will be detailed in this section. First, we start with the t-SNE algorithm to provide an understanding of the embedding properties. Next, we detail how features' relatedness is measured and how it is used to measure samples similarity. Last, we explain the procedure for Mean-Shift clustering concluding the co-clustering process.

t-SNE Embedding
These paragraphs describe the general ideas behind the t-SNE algorithm (26). For a set of n items X, this nonparametric embedding algorithm transforms it into a low dimensional representation Y ∈ R n×d , with d often set to 2 for visualization purposes: The perplexity parameter (perp) controls the number of nearest neighbors in X to preserve in Y . This prevents highly connected items of the graph from having too many neighbors and improves the neighborhood of weakly connected items. The algorithm works by minimizing the Kullback-Leibler divergence between the image matrices of X and Y , obtained respectively using a Gaussian kernel and a t-Student kernel. This kernel asymmetry creates repulsive long-range forces leading to well-separated groups. Another characteristic is the homogeneous scaling over an embedding, allowing to measure similarity the same way independently of the location and the crowdedness.
The perplexity governs the embedding shape, where a large value focuses on large scale structures, while a lower one on details. The understanding of large is relative to the number of items, and could be adapted to tags and resources with perp R and perp T as they do not necessarily have the same size.
As this algorithm tries to preserve local neighborhood relationships, nothing can be said on long-range distances. However, the proximity between items in the embedding can be exploited as an alternative to distances in the high dimensional space.

Representing Samples using their Features Embedding
The binary vector of a sample s is transformed into a vector of probabilities. The feature embedding Y F = {y i } i=1:|F | is used to create this vector by taking into account three factors: the feature's location, the feature's popularity, and the related features. The vector representing s is p(s) = [p(f |s)] f ∈F , where the term concerning a feature f is defined as: where δ(s,fi) |fi| represents the contribution of feature f i contained in s. The normalization constant c(s) ensures that f ∈F p(f |s) = 1. For a feature f i of s with image y i , the kernel redistributes the feature's mass on the neighborhood feature f with image y based on their kernelized distance K(y, y j ). Therefore, the weight p(f |s) can be non-zero even if f is not a feature of s. Mass redistribution assumes that all existing edges are true edges and some edges are missing, i.e. there are no misconnected items, but the information available is incomplete. The kernel allows us to consider the unlinked items with some degree of confidence based on their proximity.

Kernel Choice
The t-SNE embedding uses a t-Student kernel to map items. While it seems a natural kernel choice, this distribution has a long tail, allowing distant items to contribute. In the t-SNE algorithm, this kernel was chosen to create long-range forces for better clusters' separation. As the goal is to identify closely related items, the use of a Gaussian kernel is more adapted, defined as with bandwidth parameter σ. This kernel has the advantage to be more localized and adaptable using σ. σ σ σ's Choice: The perplexity impacts the distances between items within an embedding. Consequently, σ is adapted by looking at the effective distances by:σ where y k-NN is the k-est nearest neighbors of point y, with k = perp and y = d i=1 y 2 i is the Euclidian norm. The use of the median rather than the mean limits the outliers' contribution which would enlarge σ.

Building the Samples Embedding
The t-SNE algorithm requires as input a distance matrix. Therefore, the distances between samples are obtained by measuring the divergence between the samples' probability vector obtained using Eq. (2). We use the Jeffrey-Kullback-Leibler divergence to measure items proximity, with the formulation: with p(s a ) and p(s b ) the vectors of sample s a and s b respectively. We use this divergence instead of the traditional KL because of the symmetry of KL J . The matrix Initialization: At the start, no initial embedding exists yet, which prevents from measuring density. We initialize the first embedding with the d first eigen-vectors of M obtained by SVD. Compared to a random initialization, it fastens the convergence process by starting from an organized state. In pseudocode (1), resources start the role of samples. This is an arbitrary choice and has almost no impact on the final result.
Iteration At each step, the samples' probability density is estimated over the feature's space. Then, samples' divergence matrix is obtained using these probabilities. The embedding step finish by embedding using the t-SNE algorithm to obtain a new sample embedding Y S (t + 1) using the divergence matrix as input. After building the embedding, features and samples exchange their respective roles.
Ending Criterion: The pseudocode (1) iterates k times on each type of item, an arbitrary value around a dozen steps, as the algorithm does not minimize a particular criterion. Nonetheless, the process can be monitored in terms of neighborhood stability, looking at if the neighborhood around a point is unchanged over successive embedding. By denoting N n (Y, i) the set of the n nearest neighbors of i in Y , we compare its neighborhood in Y (t) and Y (t + 1) using the Jaccard similarity by |Nn( Algorithm Complexity: For n samples and m features, the probability estimation requires O(nm 2 ) operations. The divergence measurement requires O(n 2 m) operation to compute n 2 pairs with vectors of size m. Then, the t-SNE embedding complexity is in O(kn 2 ) for k update steps, typically between 100 and 1000, depending on the dataset size and convergence speed. In total, a step described in pseudocode 1 requires O nm(n + m) + kn 2 operations.

Clustering Embeddings
The proposed algorithm leads to clusters' apparition when community structures exist in a dataset. Groups are extracted using the Mean-Shift (MS) clustering algorithm (27). This algorithm follows an iterative process, moving items towards their mode's location, which are positions with maximal probability density. The imageȳ of point y is moved toward its mode following the equation:ȳ starting withȳ = y and using the Gaussian kernel K(.) defined previously, using the bandwidth parameter σ estimated using Eq. (3). After several iteration steps, all items may have converged in some specific locations. A cluster is obtained by gathering all items within a radius . Using MS, tags clusters C T and resources clusters C R are extracted from their respective last embedding Y T and Y R .
Two-Ways Clustering: Mean-Shift is a one-way clustering algorithm as samples and features are clustered independently. Nevertheless, we consider the full process as a two-way co-clustering algorithm as the embeddings are linked together,. The MS algorithm has the advantage of being parameter-free, as the kernel bandwidth σ is adapted to the embedding. The two main advantages of MS is its ability to automatically discover the number of clusters and the uniqueness of the partitioning obtained.
Co-Clusters Relationships: A sample is represented by a mixture of features using Eq. (2). Two samples s a and s b are embedded close to each other area if they have a similar mixture. The features of a sample are not necessarily all located in the same area. Assuming the features of s a are located in k distinct areas, s b is similar to s a only if its features are also located in these k areas. Therefore, we would obtain a co-cluster connected to k features clusters. If s b has no feature in one location or has features in another location out of this k areas, its mixture would be highly dissimilar. KL divergence highly penalizes couples of items where one has a mass where the other has none. If s b has its features located in all these k locations with many features in some of these locations, an asymmetry can appear due to the excess and deficit of mass in the different areas. Depending on the strength of the asymmetry, s a and s b can be located either in the same cluster or in two distinct clusters. A cluster can be characterized by the features clusters it is connected to and the strength of the connection.

Datasets
We propose to evaluate our co-embedding approach over various datasets corresponding to tags associated with resources, as tags allow us to evaluate a group content subjectively. We tried to select for each resource type two datasets to visualize the impact of different data collection processes. Some of the datasets are folksonomies, tagged by non-expert people with uncontrolled vocabulary, while the others are tagged by experts using a specific vocabulary.  (34) for music songs but did not find another equivalent dataset. We used textual datasets for comparison. The NewsGroup20 (35) (NG20) corresponds to news articles covering 20 different topics, and the OHSUMED (36) to abstracts from MedLine papers. The Corel5k, Delicious, IMDB, NewsGroup20 and OHSUMED datasets were gathered on https://cometa.com.
The detailed pre-processing steps are detailed in 6. The largest datasets are sampled and filtered before use as they do not fit in memory. The sampling and filtering steps are also detailed in the local appendix.

Cluster Retrieval Tasks
We propose to evaluate the co-clusters obtained using our method over a cluster-retrieval task, where the goal is to find the cluster where the item's location is. Additionally, we evaluate the ability of the features clusters to serve as a unit of description. The sample's binary vector is replaced by the proportion of features it has in each cluster, providing a compact representation. For a sample s, its description vector is: as well as for a cluster C ∈ C S by: The compressed vectors are denoted by q to avoid confusion with the vectors p defined in Eq. (2). We use the binary features and not the diffused ones here as the goal is to evaluate the partitioning obtained, and not the embedding quality.
Clusters C ∈ C S are sorted by increasing KL divergence D(s, C) = KL(q(s) q(C)). The retrieval accuracy of this task is measured using the Mean Retrieval Rank (MRR), which quickly drops with miss-prediction.
The retrieval task allows us to evaluate the partitioning relevance. This is assessed by the capabilities of sample clusters to gather items with similar connections, and by the ability of feature clusters to serve as a description unit. Cluster partitioning can help to speed up the retrieval process. A user query is often short and inaccurate, which makes impossible an exact search. The query must be compared to all n items of the database to select the most relevant item. By partitioning into k clusters, the search requires k operations to find the best cluster (assuming the correct cluster is well identified), and n k others to find the correct element within the cluster. Therefore, the partitioning can help to reduce the search complexity from O(n) to O(k + n k ), which could be beneficial for very large or distributed databases.

Comparative Algorithm
We compare our algorithm to the spectral co-clustering algorithm presented in (20). The algorithm uses the VSM representation that SVD next decomposes. Then, the singular vectors are clustered using k-Means. The algorithm is adapted by grouping the two types of nodes separately. As this algorithm has to enter the number of clusters to be searched, we use the number of clusters found using our approach. k-Means is a non-deterministic algorithm leading to different results depending on the initialization seed. The algorithm is run 10 times, and the best result is kept for fairness. We choose this algorithm as it has been widely used and has a strong theoretical basis but does not consider dimension relatedness.

Cluster Quality
Not all partitioning with k clusters are equivalent. The proposed task is very easy if a single cluster gathers all the items, and the other clusters are made of very small groups. In contrast, the retrieval task using partitioning with clusters of equivalent size is much harder, as a random choice based on the mass would lead to very poor scores. We define the partitioning entropy as the entropy relative to the clusters' size: where P r(C) = |C| C i ∈C |Ci| , with values in [0, log 2 |C|]. The value in terms of entropy is non-comparable to the number of clusters as it represents the number of bits necessary to encode the information. The value is put to the power of 2 to transform it into a meaningful value. The effective number of cluster k(C) = 2 H(P) ∈ [1, |C|], where a value of 1 is synonymous with a large cluster, while a value close to |C| indicates that the clusters have a similar size. This value better measures the retrieval difficulty, as clusters' size is considered.

Items Representativeness
The items in the identified clusters can be ranked by relevance or representativeness. A sample is relevant if its distribution on the feature space is close to the mean distribution of the cluster to which it belongs to.
We propose to score items based on their KL-divergence from their respective cluster. The KL-divergence could be expressed as KL(A B) = H * (A, B) − H(A), where H * (.) is the cross-entropy that represents the extra cost of coding A with the optimal code of B. For a cluster C ∈ C S , we define the representativeness of sample s ∈ C relatively to C as: A score repr(s, C) ∈ [0, 1] is obtained, where 1 represents the maximal relevance.
This normalization enables us to consider samples' frequency. A low divergence between the item and the cluster is synonymous with high similarity. However, underfrequent items are likely to have a lower divergence than frequent items. By normalizing the divergence with the entropy, items are fairly compared to the cluster average. Fig. 1 and Fig. 2 represent the embedding chronology for keywords and resources respectively, for randomly selected items of the Flickr dataset. The subset is described in Table 2 and the resulting co-embedding is reused in the next experiments.

Evolution over Time
t-SNE is initialized with the previous items' location, allowing to visualize items displacement over time better. Therefore, clusters' positions are approximately preserved over the successive steps. The first keyword embedding (t = 0) is obtained by exploiting the document eigen-vectors obtained by SVD decomposition, while the first document embedding (t = 1) is obtained exploiting this first keyword embedding.
Major structures emerge from the initial mass of items during the first steps (until t = 6 ∼ 7). During the last steps, clusters' shapes are refined. The keyword clusters' locations are stable over time, but clusters tend to densify from step t = 6 to step t = 14, leading to well-separated clusters. Keyword clusters' move from their previous location and some split into several pieces between t = 7 and t = 15. At the end of the process, both embeddings show clusterable structure but differ in their spatial organization. The difference will be detailed in the next paragraphs.   Fig. 3 shows different co-embedding results for the different datasets, where samples' characteristics are presented in Table 2. The majority presents disjoint clusters for both tags and resources. The tag embeddings differ from the resource embeddings as they all show a large central cluster. These clusters correspond to unspecific vocabulary, which occurs in all resources' clusters. There is no such a central cluster for resources' clusters, unless for the unfiltered DBLP subset and Delicious.

Visual Results
Datasets are filtered to fit in memory by discarding rare items as they are the less accurate and would lead to a normalization bias (5.2). We illustrate the difference between the unfiltered (u) and filtered (f) over a DBLP subset related to the payment. The filtering leads to removing many infrequent tags, drastically reducing |T | and |C T |. |R| is unaffected by the filtering, but |C R | is reduced by 1/7, leading to denser clusters. The reduction of |C R | results from removing these infrequent tags that isolated some resources into small clusters.
Some datasets have a different clusters' shape and spatial organization. At the same time, most tag clusters are dense; the Corel5K has very thin clusters. This could be explained by the very low E(|r|), and the small tag collection, leading to very weak connectivity. The Bibsonomy datasets have some of their tag clusters connected to each other. These clusters gather similar vocabulary but with different formatting. By applying text processing methods (steaming and case normalization), these clusters would merge in one.

Cluster Balance
The characteristics of the selected subsets used to build the co-embedding presented in Fig. 3 are detailed in Table 2.  As a general remark, tag clusters are less numerous than resource clusters as observed in the previous figure. This could be explained by the fact that |R| > |T | for all subsets. However, there is no explicit relationship between sample size and clusters number, as DBLP has more resources clusters than most other datasets while having the smallest |R|. Thus, the number of clusters found is likely to depend on the sample intrinsic characteristics.
k (C T ) is almost always larger for CE than for SC, while half of the time for k (C R ). k(C CE ) and k(C SC ) have the same order of magnitude, unless for a few examples like Flickr and Last.fm with a very low k(C SC T ) compared to |C T |, and BibUrl where both k(C SC R ) and k(C SC T ) are much lower than for CE. One reason that might explain the difficulty to identify balanced clusters using the raw binary matrix with SC is the power-law distribution of items. This distribution leads to a very sparse matrix where groups are difficult to identify. Resource occurrences follow a power-law if some resources are more popular therefore more tagged than others, but the phenomenon is more frequent for tags because of the language organization. This might explain why SC gives lower results than CE more frequently over tags than over resources.

Representative Keywords
The top 4 words of each cluster were extracted using Eq. 9 from the clusters identified previously using CE. As a result, the keywords of the largest clusters (denoted Main group) and four other selected clusters are listed in Table 3.

Main Group Description
The main cluster of each subset is mostly made of general words occurring in many different contexts that the dataset cover. In some datasets, it allows to define the global scope (music genres are identified for Last.fm, medical topics for OHSUMED, or web components for BibUrl), but for the majority the media type (music, images, etc.) or the topics covered are difficult to identify.
Cluster Identity Each cluster has a particular identity. For example, for OHSUMED, one group gathers the vocabulary used in studies (where cohorts are compared), and the others concern different disciplines (related to heart, infectiology, and surgery). For Corel5K, each group corresponds to a particular picture (seaside, tundra, locomotion engines, and animals).
A folksonomy includes vocabulary from users that do not necessarily share the same language. Flickr is the most representative dataset, with French, Italian, English and German words each gathered in a specific cluster. This particularity is visible on the other folksonomies BibTex, BibUrl and Delicious with English and German clusters.
In a given dataset, words groups can be of various kinds, out of language consideration. For example, the Last.fm dataset has five clusters with distinct words types and ideas. The main group is about general music type while the 4th gathers sub-music types related to electronic dance music, the 2 nd gathers band names, the 3 rd epochs, and the last road-trip related ideas.
Data Collection Specificity While several datasets have in common the type of tagged resources; the clusters obtained differ in the ideas expressed. This could be explained in a first place by the small overlap between the dataset's vocabulary, but the ideas expressed differ from one dataset to another.
Corel5K gathers timeless tags each representing a specific object or place, while Flickr gathers tags related to art requiring culture to be understood. The difference can be explained by the different goals expected, where Corel5K is designed for Object Recognition, while information retrieval for Flickr.
The largest difference concerns IMDB and MovieLens that both correspond to movies' descriptions with approximately the same number of tags. Movie styles are easily identified on the MovieLens dataset (horror, science-fiction, historical and police movies), while IMDB' clusters group elements that occur in the same context together. Each dataset has a narrowed list of terms, corresponding to the most relevant term for IMDB, and general movies attribute (32) for the MovieLens tag genome, explaining the difference of expressed ideas between the two datasets.

Cluster Retrieval
We tested the cluster retrieval tasks using the clusters obtained previously. In addition, we tried the task in both directions: searching the resource's cluster, and searching the tag's cluster. Table 4 summarizes the retrieval scores for this task. Table 4: Mean Retrieval Rank for resources clusters C R and tag clusters C T using our approach (CE) and the comparative algorithm (SC). Tags clusters have higher retrieval scores than resources clusters with both approaches, ours leading to better MRRs in most cases. The good MRRs are explained by the low number of tag clusters, making the task easier with a smaller choice. The other point explaining these MRRs is many resource clusters, allowing a more detailed description vector, leading to a more accurate retrieval. The argumentation is reversed for resource cluster retrieval, leading to lower MRR scores. The Flickr dataset mentioned for its low k(C SC T ) (1.9) illustrates this argument with the lowest retrieval score M RR(C SC R ) = 20.9%. A low number of tags clusters inevitably leads to a low retrieval rate of the resource clusters. Still, a large number doesn't guarantee the opposite outcome, illustrated by the DBLP dataset, with an acceptable retrieval score using our approach while having the largest number of tag clusters.
The gap between approaches for resource retrieval is larger, with our approach having MRR around 80 ∼ 90%, the spectral clustering has MRR around 50 ∼ 70%. These results make our approach preferable for this particular task, with the additional advantage of providing an intermediate visualization result.

Parameters Choice
Perplexity: As said previously, the perplexity governs the embedding shape by controlling the number of items t-SNE would look at for embedding data. The values we used need to be relatively small as we are interested in local structures to learn items similarity on it. These values are adjusted as a function on the sample size n the following way: This decision rule is very simple and allows a simple parameter selection. Nevertheless, the verification of the produced output is suggested. A too large value would tend to connect the different clusters together, while a smaller value would lead to more clusters, which both can penalize the other embedding.
Relationships between σ and perp: The estimation of σ using Eq. (3) can be explained with two remarks. First, a larger perplexity leads to smaller distances between nearest neighbors (NN), making the choice of σ non-trivial. The direct adaptation to the embedding allows to adapt to the perplexity and to the dataset characteristics. Second, the perplexity governs the number of NN that t-SNE considers around each item. If k < perp, the kernel would underexploit the items' positioning, as only a small fraction of the NN would be considered. On the opposite case where k > perp, the kernel would be too large, and would put weights on items that where not considered by t-SNE. Additionally, a larger σ would lead to a flatter kernel, underexploiting items well positioned. Therefore, the best option is to select k = perp , simplifying σ's choice by adapting it indirectly to the current perplexity.

Normalization
Normalization Bias: In Eq. (2), the contribution of an item is normalized by its frequency, limiting the contribution of highly popular items. In contrast, items with very few links and low frequency have their contribution enhanced. For very low frequency items, their weight is very large, leading to group artefacts, where the unfrequent item is strong enough to gather co-occurring items in a single cluster. To overcome this issue, using a different normalization scheme or filtering the dataset could mitigate the apparition of artefacts.
Weighted Case: Our approach exclusively considers the case where the frequency information is unavailable. Nonetheless, the Eq. (2) can be adapted to consider items' frequency, by replacing fi∈F δ(s,fi) |fi| by fi∈F T F (s,fi) f ∈F C(sj ,f ) is the frequency of feature f i in sample s j and C(s j , f i ) the number of occurrences. If we have words and documents, the normalization the words count within a document is intuitive, allowing to obtain a document vector summing to 1. However, describing a word using the documents that contains it to obtain a word vector is non-trivial as different possibilities exist. One can normalize the word frequency of each document T F (w,r) r ∈R T F (w,r ) , or one can normalize the word count per document over all the corpus C(w,r) r ∈R C(w,r ) . The first option is more balanced, as it gives credit to all documents. Nevertheless, for documents with very few words, it would penalize the final result because it considered inaccurate information. In that case, the second option is more suitable, as it favors the contribution of documents of sufficient size.

Scalability to Large Datasets
Each step of our algorithm runs in O nm(n + m) + kn 2 , unaffordable for very large datasets. Nevertheless, the scalability problem can be bypassed by identifying clusters over a subset of items. This assume that a sampling would only affect clusters' size, but would not affect clusters' number. After the cluster identification phase, the unselected items are assigned to the most relevant cluster, allowing to classify them.
Then, the embedding process could be repeated over the items of a consolidated cluster, leading to a new segmentation level. Some features were previously discarded because of their low frequency within the initial subset because of the filtering process. The addition of these new items allows some of these features to reach the critical frequency, therefore to consider them. Even if the items are very similar, the second co-embedding process is likely to lead to new clusters because of the new features that increase diversity.

Adaptation to Temporal Datasets
A dataset is a snapshot of a database at a given moment. A real-world graph is often dynamic, with new nodes and new edges. Rather than looking at the entire network since origin, the focus can be put over a given period to compare with another one.
The proposed approach can be adapted to temporal datasets using a moving window. The first slice is used to construct a primer co-embedding. Next, the embedding of the new window is obtained using the embeddings of the previous slice to learn items' density. This step is possible only if the previous and current windows share some of their elements, and that new items have already seen features. Otherwise, it would not be possible to evaluate the density. By following this process, it would reduce the number of co-embedding iteration as an already stable embedding is provided to estimate items' density. A minor difficulty concerns cluster tracking over the different windows, as new clusters can emerge, disappear, split or fuse together, adding some complexity.

Conclusion
In this article, we proposed a co-clustering algorithm for bipartite graphs. The algorithm addresses dimension relatedness by projecting features into a low dimensional space, comparing samples based on their mixture of features. The embedding process leads to natural cluster formation for a dataset where community structures exist, clustered using the Mean-Shift algorithm. The algorithm is easy to configure with very few parameters to adjust. We tested our algorithm over a cluster retrieval problem. A better retrieval accuracy with more balanced clusters in a large number of cases was shown than when using a spectral co-clustering algorithm that did not consider the relationship between the dimensions. However, the weakest point of our algorithm is scalability. Nevertheless, clusters could be identified over a subset, and unused items assigned to the closer cluster. The approach could be used to optimize recommender systems and retrieval engines by working at the cluster-level rather than the item-level.
Flickr We used the Flickr dataset (37) (MIRFLICKR-1M) that contains 1 million of images and the corresponding tags. We removed from the described corpus all images with no associated tags. Then, we applied the sampling and filtering steps.
Corel5K The Corel5K dataset (30) contains 5 thousand images associated with tags. The dataset has been obtained on the Cometa website (https://cometa.ujaen.es/datasets/). Each image is associated with a set of tags, where no frequency is available. Due to the limited size of this dataset, no sampling nor filtering have been done.
IMDB The IMDB dataset (31) has been gathered on the Cometa website. Each movie is associated with a set of tags as well as a set of classes, representing the movie types. The bipartite graph is constructed using the tags and movies exclusively, and does not use the movie types. For the experiments, the dataset was sampled and filtered.
MovieLens From the MovieLens project (32), we selected the ml-20m dataset and studied the genome part. The genome is a set of about 1.000 keywords for which the relevance to each movie (∈ [0, 1] has been evaluated. For each document, we preserved all the keywords with relevance equal or greater than 0.5. The subset size has been sampled and filtered for the experiments. Last.fm The Million Song Dataset (34) corresponds to music titles associated with rated attributes in [0, 100]. The dataset is organized into three part: train, test and subset. We worked only on the train part because of the large number of music songs available. As for the MovieLens dataset, we preserved all the attributes with relevance ≥ 80, and discarded the songs with no items. This dataset has been sampled and filtered for the experiments.

NewsGroup20
The NewsGroup20 dataset (35) has been obtained on the Cometa website. For scalability, we only removed the documents with the lowest number of tags. We did not apply the filtering process as the number of tags per document is large, as well as the number of documents including a specific tag. Therefore, the filtering would have no consequence.
OHSUMED The OHSUMED dataset (36) corresponds to medical article abstracts. It has been obtained on the Cometa website without processing.