LARGE-SCALE ENTITY RESOLUTION FOR SEMANTIC WEB DATA INTEGRATION Gustavo de Assis Costa1,2, José Maria Parente de Oliveira1 1 Divisão de Ciência da Computação, Instituto Tecnológico de Aeronáutica, Brazil Departamento de Informática, Instituto Federal de Educação, Ciência e Tecnologia de Goiás - Campus Jataí, Brazil 2 ABSTRACT Despite all the advances, one of the main challenges for the consolidation of the Web of Data is data integration, a key aspect to semantic web data management. Most of the solutions make use of entity resolution, a task that deals with identifying and linking different manifestations of the same real world object in one or more datasets. However, data are usually incomplete, inconsistent and contain outliers and, to overcome these limitations, it is necessary to explore as much as possible the existent patterns in data. One way to extrapolate the commonly used technique of pair-wise matching is to explore the relationship structure between entities. Moreover, with the billions of RDF triples being published in the Web, scale has become a problem, posing some new challenges. Only recently some works started to consider new strategies that can deal with the problem of entity resolution in high scale datasets. In this paper we describe a Map-Reduce strategy for a relational learning approach that addresses the problem by statistical approximation method using a linear algebra technique. We applied the parallelization in all steps of the approach. Preliminary experiments shows that our strategy scales well with real world semantic datasets, maintaining the effectiveness of results even with the increased number of processed data. KEYWORDS Entity resolution, Semantic Web, Linked Data, Semantic Web Data Integration, Map-Reduce, Relational Learning. 1. INTRODUCTION The amount of data that has been published in the Web of Data has grown quite. As a result, the amount and diversity of data has grown at the same rate, creating a graph of global dimensions formed by billions of RDF triples that represent information from different areas of knowledge. RDF datasets usually reflect the same issues present in relational databases as outliers, duplication, inconsistency, and schema heterogeneity. These kinds of restrictions pose a great hindrance to the effective integration and sharing of Linked Data and consequently for the Semantic Web Data Management. However, the integration of datasets is one of the key points of LOD1 (Linked Open Data). Furthermore, different and isolated descriptions of the same real world entity exist in different datasets and to get the effective semantic of all these information it is necessary to provide ways of predicting new links between them. The task of entity relationship prediction, mentioned in this work as Entity Resolution (ER), has been focus to many works, since entities are key elements for data representation. Also known as Record Linkage (Elmagarmid et al., 2007), De-duplication, Co-reference Resolution, Instance Matching, among others, it has been recognized as an important issue in Semantic Web and Linked Data research community (Getoor and Machanavajjhala, 2012; Nickel et al., 2012; Yilmaz et al., 2011). Our main objective is identify sameAs links between datasets, e.g., connecting data about the Brazilian poet Cora Coralina in Dbpedia, Freebase, etc. This way, the higher amount of information that can be obtained about the poet can compose jointly any query result. In this sense, we can highlight some important challenges. The first is how to deal with semi-structured data. Different semantic description structures can be employed to refer to the same element, as for example, the description of entities of the same type. As an example, in addition to naturally different namespaces 1 http://linkeddata.org/ descriptions, each vocabulary can employ different descriptions to refer to the same structural type. This reflects a classical problem of ontology alignment, which aims to look for mappings between different schemas. A second challenge is related to noise in the data. There are various problems related to literal descriptions of data and to overcome these problems, many different metrics of string matching were proposed. Even taking into account some situations like characters suppression, variation in radical words, among others, existent metrics still cannot resolve problems like attributes without value. In this paper we focus in what we consider the third challenge, scale, more specifically, the large-scale of the Web of Data. The LOD cloud has nowadays about 60 billion RDF triples and this number is still rapidly growing. Handle this amount of information requires techniques that can distribute/parallelize the computation, e.g., Map Reduce paradigm. However, only a few recently works started to consider new strategies that can deal with the problem of entity resolution in high scale RDF datasets, and for all we know no specific work has dealt with large-scale semantic data in a collective entity resolution framework. In (Costa and Oliveira, 2014) we treated these issues with a relational learning approach that addresses the problem by statistical approximation method using a linear algebra technique. Machine learning algorithms are typically robust to both noise and data inconsistencies and are able to efficiently utilize nondeterministic dependencies in the data. Furthermore, a relational machine learning framework allows exploit contextual information that might be too distant in the relational graph, allowing the joint application of relationship patterns between entities and evidences of similarity between their descriptions, what can improve the effectiveness of results. However, despite good results with some high scale datasets this approach still cannot deal with real world large-scale datasets because of evident limitations of memory and processing. Thus, in this paper we perform preliminar analysis of (Costa and Oliveira, 2014) in a large-scale context of real world RDF datasets, using data from BTC 2012 (Billion Triples Challenge) (Harth, 2012). To perform the distributed computation of the proposed approach we consider all of its steps separately. The first step consists in performing a pre-processing of RDF datasets to extract potential matching pairs in order to avoid a large increase in the number of comparisons. We do this through the use of a Map-Reduce (Dean and Ghemawat, 2008) version of an inverted index. From the generated index in the distributed file system we perform a chained pair-wise string comparison using metrics like TF-IDF and Jaro. After that, following with chaining, we generate a matrix entity-attribute with the similarity results as its entries and corresponding to an entity having or not certain attribute or an infix in its URI description. The step of tensor generation is performed jointly with the first step because both of them are conceived directly from the RDF data dumps. In this step the relations between entities are modeled as a tensor and all the problem is formulated as a coupled matrix and tensor factorization. Finally, the factorization computation is performed in a Map-Reduce version of the extended version of RESCAL (Nickel et al., 2011) model, a tensor factorization model for relational learning. The main contributions of our work is propose a large-scale solution for semantic web data integration using a collective entity resolution task that is based in a relational learning framework. For machine learning algorithms, more data does mean better results because, as more data we have, the better the results of prediction. Furthermore, as more relationship patterns between entities could be used, much greater will be the effectiveness of the results. The remainder of this paper is structured as follows: Section 2 presents the preliminaries on the relational learning approach and the tensor factorization model. Section 3 describes our Map-Reduce strategy for largescale entity resolution. In Section 4 experimental results are reported. Section 5 summarizes related works and in Section 6 we conclude. 2. PRELIMINARIES 2.1 Relational Learning Approach The approach is composed of four steps. The first step consists of literal information extraction for each entity in all datasets. Some literal descriptions are more discriminative then others because, from the triple structure, they can represent the most significant information of each element: 1) Attribute values. Correspond to features of an entity (e.g. name/label, birth date, profession). Most approaches explore these values due to the precision when identifying an entity; 2) URI infix. The URIs of a dataset follow a common pattern: the Prefix-Infix(-Suffix) scheme. 3) Predicate: We will use the last token (normalized) of the URI, e.g., “has spouse” for "fb:has_spouse". Considering two datasets A and B with n and m entities respectively, and a brute force algorithm, there will be at least n x m comparisons between instance pairs. It is impractical, especially when dealing with real world datasets, with millions of triples or even larger. To overcome this problem, it was proposed a preprocessing step to obtain the possible matching pairs. An inverted index is built for instances of some key words in the descriptions to efficiently determine potential candidates. The entities sharing the same keys in the index are considered to be candidate matching instances. After literal information extraction, similarity metrics are applied for the candidates and generate the entity-attribute matrix, with its entries corresponding to an entity having or not certain attribute or an infix in its URI description. In the same way, entity-entity relations from datasets are mapped to tensor, with which the coupled factorization is performed. The factor-matrix A computed in the above process can be interpreted as an embedding of the entities into a latent-component space that reflects their similarity over all relations in the domain of discourse. In order to retrieve entities that are similar to a particular entity e with respect to all relations in the data, a clustering is computed in the latent-component space. Initially, however, the rows of A are normalized, such that each row represents the normalized participation of the corresponding entity in the latent components. From feature vectors corresponding to each entity (matrix rows) it is possible to create clusters of similar entities, since matrix A represents entities by their participation in the latent components. The clustering will be determined by the entities' similarity evidences in the relational domain. 2.2 Tensor Factorization Model The key elements of the model are entities and its relations. The entities are given by the set of all resources, classes and blank nodes in the data, while the set of relations consists of all predicates that include relationships between entities. Once these elements were extracted from datasets we set out to the transformation of them into a tensor representation. A tensor is a multidimensional array. More formally, an N-way or Nth-order tensor is an element of the tensor product of N vector spaces, each of which has its own coordinate system. A third-order tensor has three indices as shown in Figure 1a. A first-order tensor is a vector, a second-order tensor is a matrix, and tensors of order three or higher are called higher-order tensors (Kolda and Bader, 2009). Assuming that the relational domain consists of n entities and m relation types, data is modeled as a threeway tensor X of size n × n × m, where the entries on two modes (dimensions) of the tensor correspond to the combined entities of the domain of discourse and the third mode holds the m different types of relations. A tensor entry Xijk= 1 denotes the fact that the k-th relation (i-th entity, j-th entity) exists. Otherwise, for non-existing or unknown relations, Xijk is set to zero. In RESCAL, learning is performed using the latent components of the model (Fig. 1a). The approach employs the rank-r factorization as follows, where each segment is factored as Xk Xk  ARk AT where k = 1, ..., m (1) A is a n × r matrix containing the components of the latent representation of the entities in the domain and Rk is an asymmetric matrix r × r modeling the interactions of the components of the kth latent predicate. The rows of the factor matrices A and R can be considered latent-variable representations of entities that explain the observed variables Xij, the columns can be considered the invented latent features and the entries of the factor matrices specify how much an entity participates in a latent feature. The factor-matrices A and Rk are computed by solving a regularized minimization problem (Nickel et al., 2011) applying an alternating least squares algorithm (RESCAL-ALS), which updates A and Rk iteratively until a convergence criterion is met (linear regression). In order to retrieve entities that are similar to a particular entity e with respect to all relations in the data, it is sufficient to compute a ranking of entities by their similarity to e in A. a) b) Fig. 1. a) Illustration of data representation and factorization in the model and b) A Tensor coupled with a matrix of attributes Once this model assumes that two of the three modes are defined by entities, the process becomes limited to RDF resources. So we used an extension of the model, coupling the entity-attribute matrix with the tensor (Fig. 1b) aiming to perform the factorization (Nickel et al., 2012; Yilmaz et al., 2011). If we include all the literal evidences in the tensor, a huge amount of entries would be wasted, which would lead to an increased runtime since a significantly larger tensor would have to be factorized. So, the idea is to add the predicate-value pairs to a separate entity-attributes matrix D and not to the tensor X. The entity-attributes matrix D is then factorized into D  AV (2) where A is the entities’ latent-component representation of the model and V is an r × l matrix, which provides a latent-component representation of the literals. To include this matrix factorization as an additional constraint on A in the tensor factorization of X, it is necessary to adjust the minimization problem. In figure 2 we show an illustration that depict an example. The latent-component representations of entities A and B will be similar to each other in this example, as both representations reflect that their corresponding entities are related to the same object (wikipedia page) and attribute value. Because of this and their own similarity evidences, C and D will also have similar latent-component between their representations. Consequently, the latent feature vector of A will yield similar values to the latent feature vector of B and as such the likelihood of matching can be predicted correctly. The attribute values are only considered here due to the extension of the model. Considering that ai and aj denote the i-th and j-th row of A and thus are the latent-component representations of the i-th and j-th entity, the products 1) afb:m.05mwy8T R{spouse_s, isMarriedTo} afb:m.0pc9q, 2) afb:m.05mwy8T R{spouse_s, isMarriedTo} a yago:Luiz_Inácio_Lula_da_Silva, 3) ayago:Marisa_Leticia_Lula_da_SilvaT R{spouse_s, isMarriedTo} afb:m.0pc9q 4) ayago:Marisa_Leticia_Lula_da_SilvaT R{spouse_s, isMarriedTo} ayago:Luiz_Inácio_Lula_da_Silva along with the similarities evidences obtained, will contribute to get likelihood of A and B representing the same real world entity. Fig. 2. Illustration with representations of the same real world entities in Freebase and YAGO. The red line indicates the wanted matching. 3. DISTRIBUTED IMPLEMENTATION Map-Reduce (Dean and Ghemawat, 2008) is a programming model and associated infrastructure that provide automatic and reliable parallelization once a computation task is expressed as a series of Map and Reduce operations. Specifically, the Map function reads a <key, value> pair, and emits one or many intermediate <key, value> pairs. The Map-Reduce infrastructure then groups together all values with the same intermediate key, and constructs a <key, ValueList> pair with ValueList containing all values associated with the same key. The Reduce function takes a <key, ValueList> pair and emits one or many new <key, value> pairs. Open-source implementations of Map-Reduce infrastructure are readily available such as the Apache Hadoop project. As can be seen in the algorithm below, we represent the map and function execution in loops of size P, where P is the number of processing units in the cluster. There are four steps in the distributed model for (Costa and Oliveira, 2014) that are depicted in the algorithm : 1) Pre-processing; 2) String Similarity; 3) Matrix and Tensor modeling and 4) Tensor and Matrix coupled factorization. a) Pre-processing - corresponds to the full inverted index generation; b) String similarity - this step has as input the RDF dump and the inverted index; c) Matrix and Tensor modeling - collects all the literal evidences and models it in a matrix, jointly with the modeling of a tensor, with data obtained from RDF datasets; d) Tensor and Matrix Factorization - performs all the operations related to linear algebra of the machine learning algorithm, i.e., among several operations, updating matrices A and R iteratively until a convergence criterion is met. Algorithm 1: Map-Reduce implementation of the approach Input: Datasets composed of RDF triples <subject, predicate, object> Output: Rank reconstructed Xk and factor matrices A and R. We rank the entries of matrix A as basis to their likelihood that entities are similar to some other particular entity e in A. 1: for p = 1, ..., P: 2: for z = 1,..., Z/P triples in datasets: 3: parse triple 4: inverted index ← literals in component <object> 5: end for 6: end for 7: for p = 1, ..., P: 8: for w = 1, ..., W/P index entries: 9: if index w has sharing entities: 10: D [rows] ← entities (subjects or objects) 11: D [columns] ← attribute, URI or predicate Matrix D construction with similarity metrics applied in three groups of values (attributes, URIs and predicates) Sparse matrix where entries are 0 or 1 (has not or has a specific attribute, URI or predicate) 12: for k = 1, ..., K relationships between entities: 13: X [rows] ← entities (subjects or objects) 14: X [columns] ← entities (subjects or objects) 15: X [slices] ← relationship k Tensor X construction with entity-entity relationships forming k sparse matrices where entries are 0 or 1 (has not or has relationship with other entity) 16: end for 17: end for 18: for p = 1, ..., P: 19: for iter = 1, ...maxIter or convergence = true: 20: for k = 1, ..., K/P: 21: 22: 23:  A   DV T    m k 1  X k AR kT  X kT AR k  VV T   Rk  Z Z   R I  T V  AT A  v I   1 1  m k 1 T T T  Bk  C k   A I  where Bk  Rk A ARk , C k  Rk A ARk  1 T T Z vec ( X k ) , where Z  A  A T AT D 24: end for 25: end for 26: end for To be able to analyze the scalability power to large knowledge bases, it is necessary for a learning algorithm to have low computational complexity and low memory usage. The time complexity of performing the inverted index is linear with regard to the number dataset dump files. In this operation we consider the length of query q times the average length L of posting list. Relational data is usually very sparse and we can assume that Xk is a sparse matrix, while A and Rk are dense matrices. With RESCAL model we have linear computational complexity with regard to the number of entities or predicates in the dataset as well as with regard to the number of known facts. The update steps for A and R are linear in the number of predicates m, regardless of the sparsity of X. Table 1. Computational complexity for inverted index and update steps of A, R and D Operation Complexity Inverted index (lines 8 - 17) each X k ARkT and X kT ARk (line 21) each Bk ∧ Ck (line 21) Matrix inversion (A update) (line 21) QR decomposition of A (line 22) Projection (line 22) Matrix inversion (R update) (line 22) (line 22) (line 23) Considering O (unl) as the runtime complexity for the matrix product of a first sparse matrix with a second dense n × l matrix, where u is the number of non-zeros in the first matrix. The operations listed above are iterated only a small number of times until the algorithm converges or a maximum number of iterations is reached. The computational complexity of a sparse implementation of the algorithm is linear in n or m and superlinear only in the model complexity r. Although the O (n5) operations in the update step for Rk can be reduced to O (n3) complexity in the non-regularized case (λ = 0). We must point out that computing the update steps of Rk in this form would be intractable for large-scale data, since it involves the r2 × n2 matrix Z. In this case, RESCAL algorithm use the QR decomposition of A to simplify the update steps for Rk significantly. Another important aspect to consider is that when we add attributes to the factorization, it is obvious to note that the additional operations will increase the runtime of the algorithm. Although, they do not alter the linear scalability, as can be seen in table 1. Due to the sums in the update of A, this step can be computed distributed by using a map-reduce approach. First, the current state of A and Rk is distributed to P available computing nodes. Then, these nodes compute and locally, for those k that have been assigned to them. Given the results of these computations, the master node can reduce the results and compute the matrix inversion, which only involves r × r matrices and the final matrix product. Since the updates of Rk are independent of each other, these steps can be computed in a similar way. Considering memory complexity of the model, in each iteration, only one frontal slice Xk has to be kept in memory. Since sparse matrices usually have a linear memory complexity O(u) with regard to the number of nonzero elements in a matrix, the approach can scale up to billions of known facts. However, the factor matrices are more demanding in terms of memory, especially A, a dense n × r matrix, such that if the domain contains a very large number of entities, some additional technique is necessary. 4. EXPERIMENTAL RESULTS All algorithms have been implemented in Python, using the following APIs: NumPy, RDFLib, NLTK, Scikit-learn and Apache Hadoop, respectively. In order to collect detailed execution statistics and prevent the interference of other jobs on a shared computer cluster, we construct a dedicated Hadoop cluster that hosts up to 24 node machines. These machines are all in the same configuration and all have a 3,8 GHz Intel (R) Core i7 CPU machine with 4 cores and 64 GB RAM. We proceed to perform our preliminary experiments with large-scale datasets, more specifically with datasets from BTC 2012 (Billion Triples Challenge) (Harth, 2012), respectively Datahub, DBpedia, Freebase, Rest and Timbl. These datasets contains approximately 1.4 billion RDF n-quads triples. The first step was to remove provenance information, duplicate triples, RDF blank nodes as well as reification statements. We decided to use the same experimental framework for large datasets as in (Costa and Oliveira, 2014), but with the exception that much more data were applied. In the first round, it was generated a total of approximately 1.5 million sameAs links. The precision achieved was of 85% and the recall was of 72%. The total execution time was about almost one day. In the second round approximately 2.3 million links was generated, but the precision has dropped to 71% and the recall was of 58%. In this round the execution time was about 30 hours. We believe that most of this time was spent with processing similarity metrics due to volume of comparisons, even using the inverted index in pre-processing. An important aspect of our strategy is memory use by the factor matrices that are more demanding in terms of memory, especially A, a dense n × r matrix. Even so, in each iteration of the factorization process only one frontal slice Xk has to be kept in memory. Since sparse matrices usually have a linear memory complexity with regard to the number of nonzero elements in a matrix, the proposed approach scales up to billions of known facts, mainly due to the pre-processing step that prunes not matching pairs. Although we have had reasonable good results it is important to note that we need to plan more detailed experiments and define a baseline to perform an accurate analysis. 5. RELATED WORKS The problem of entity resolution has emerged as an important task to the Web of Data. This same task has been exploited in many different research arenas, and today it is a very active research topic and many approaches have been proposed and evaluated (Köpcke and Rahm, 2010). Just recently some few approaches have started to use the parallelization strategy for entity resolution. Some works addresses the blocking technique using a sorted neighborhood approach (Kolb et al., 2012a) and in (Kolb et al., 2012b, 2012c) it is addressed as a load-balanced entity resolution. The basis of these works is a map function that emits <key, value> pairs and pairs with the same key are processed in the same reducer, and in the reduce function the matching function is performed with all pairs that have the same key. To avoid redundant comparisons (Kolb et al., 2013) addresses a comparison propagation scheme. Like most of the existing works in the scientific literature, none of these approaches addresses graph data, like RDF. RDF is essentially semi-structured data and it is naturally dirty, incomplete and inconsistent. Despite the work in (Papadakis et al., 2014, 2012) take into account the intrinsic issues of semantic web data, they do not address parallelization techniques like Map-Reduce in its approaches. Linda system (Böhm et al., 2012) is an approach that addresses RDF data and its algorithm is based on maintaining X and Y matrices as data structures. Matrix X will contain matching or non-matching results from performed comparisons that are temporarily maintained in matrix Y, and this second contains realvalued similarity values. The algorithm then repeatedly dequeues entity pairs with the highest similarity score from a priority queue. It considers the nearest neighborhood of matching entities as a way to propagate similarities between linked entities. 6. CONCLUSION We have presented a parallel strategy for collective entity resolution supported by a relational learning model. Performing entity resolution using tensor factorization is a currently rarely practiced discipline and a prominent mathematical structure that fit nicely to the dyadic structure of RDF triples. It is one of the key strength of this work, as it allows to include the influence of all the relationship patterns from a dataset. The experimental results showed that the relationship patterns can improve the results, considering that as much more evidences the better the effectiveness. However this has the cost that most of the solutions have to confront, the noise nature of data. ACKNOWLEDGEMENT We would like to thank CAPES, ITA and IFG for the support via DINTER project. REFERENCES Böhm, C., de Melo, G., Naumann, F., Weikum, G., 2012. LINDA: Distributed Web-of-data-scale Entity Matching, in: Proceedings of the 21st ACM International Conference on Information and Knowledge Management, CIKM ’12. ACM, New York, NY, USA, pp. 2104–2108. Costa, G. de A., Oliveira, J.M.P. de, 2014. A Relational Learning Approach for Collective Entity Resolution in the Web of Data, to appear in: Proceedings of the Fifth International Workshop on Consuming Linked Data., CEURWS, Riva del Garda (IT). Dean, J., Ghemawat, S., 2008. Map-Reduce: Simplified Data Processing on Large Clusters. Commun ACM 51, 107–113. Elmagarmid, A.K., Ipeirotis, P.G., Verykios, V.S., 2007. Duplicate Record Detection: A Survey. IEEE Trans. Knowl. Data Eng. 19, 1 –16. Getoor, L., Machanavajjhala, A., 2012. Entity resolution: theory, practice and open challenges. Proc VLDB Endow 5, 2018–2019. Harth, A., 2012. Billion Triples Challenge data set. Kolb, L., Thor, A., Rahm, E., 2012a. Multi-pass sorted neighborhood blocking with Map-Reduce. Comput. Sci. - Res. Dev. 27, 45–63. Kolb, L., Thor, A., Rahm, E., 2012b. Dedoop: Efficient Deduplication with Hadoop. Proc VLDB Endow 5, 1878–1881. Kolb, L., Thor, A., Rahm, E., 2012c. Load Balancing for Map-Reduce-based Entity Resolution, in: Proceedings of the 2012 IEEE 28th International Conference on Data Engineering, ICDE ’12. IEEE Computer Society, Washington, DC, USA, pp. 618–629. Kolb, L., Thor, A., Rahm, E., 2013. Don’T Match Twice: Redundancy-free Similarity Computation with Map-Reduce, in: Proceedings of the Second Workshop on Data Analytics in the Cloud, DanaC ’13. ACM, New York, NY, USA, pp. 1–5. Kolda, T.G., Bader, B.W., 2009. Tensor Decompositions and Applications. SIAM Rev. 51, 455–500. Köpcke, H., Rahm, E., 2010. Frameworks for Entity Matching: A Comparison. Data Knowl Eng 69, 197–210. Nickel, M., Tresp, V., Kriegel, H.-P., 2011. A Three-Way Model for Collective Learning on Multi-Relational Data, in: Getoor, L., Scheffer, T. (Eds.), Proceedings of the 28th International Conference on Machine Learning (ICML11), ICML ’11. ACM, New York, NY, USA, pp. 809–816. Nickel, M., Tresp, V., Kriegel, H.-P., 2012. Factorizing YAGO: scalable machine learning for linked data, in: Proceedings of the 21st International Conference on World Wide Web, WWW ’12. ACM, New York, NY, USA, pp. 271–280. Papadakis, G., Ioannou, E., Niederée, C., Palpanas, T., Nejdl, W., 2012. Beyond 100 Million Entities: Large-scale Blocking-based Resolution for Heterogeneous Data, in: Proceedings of the Fifth ACM International Conference on Web Search and Data Mining, WSDM ’12. ACM, New York, NY, USA, pp. 53–62. Papadakis, G., Koutrika, G., Palpanas, T., Nejdl, W., 2014. Meta-Blocking: Taking Entity Resolution to the Next Level. IEEE Trans. Knowl. Data Eng. 26, 1946–1960. doi:10.1109/TKDE.2013.54 Yilmaz, Y.K., Cemgil, A.-T., Simsekli, U., 2011. Generalised Coupled Tensor Factorisation, in: Shawe-Taylor, J., Zemel, R.S., Bartlett, P.L., Pereira, F.C.N., Weinberger, K.Q. (Eds.), Proceedings of Neural Information Processing Systems (NIPS). Presented at the Annual Conference on Neural Information Processing Systems, Granada, SPAIN, pp. 2151–2159. View publication stats