HIEDS: A Generic and Efficient Approach to Hierarchical Dataset Summarization

1 Introduction

Increasingly many datasets have been made available as open data on the Web. To cope with their explosive growth, open data portals are established, to collect datasets from the Web and provide users with a single point access. Users, when browsing a dataset found in a portal, are usually fed with its metadata but lack for an insight into its contents, thereby having difficulty in determining its relevance to the needs.

To solve it, methods have been proposed to automatically generate small-sized, high-level abstraction of data, to summarize the contents of a dataset for quick inspection. Given data modeled as entity-property-value triples such as Resource Description Framework (RDF), schema-based methods [Benedetti et al., 2014] group entities by their classes (i.e., values of the Type property) and connect groups by relations (i.e., properties with entity values). Such methods, limited by their expressivity, may unfortunately generate identical summaries for datasets in the same domain that share an ontological schema. More expressive methods are partitionbased [Tian et al., 2008], which partition entities into disjoint groups based on all properties beyond Type. However, they may fail to obtain many natural but overlapping groups, e.g., actors and directors.

⇤Corresponding author: Gong Cheng (gcheng@nju.edu.cn).

In this paper, a generic approach called HIEDS is proposed to summarize a dataset. Compared with existing schemabased methods that focus on the Type property, HIEDS exploits all the properties to divide entities into groups, and can also be configured to use a single property. Compared with partition-based methods that aim at disjoint groups, HIEDS allows groups to overlap to configurable degrees. More importantly, HIEDS organizes groups into a hierarchy, to provide abstraction at different granularities that can be incrementally explored. Our technical contribution is twofold.

• ÷ We propose to generate hierarchical dataset summaries. Our generic approach configures coverage of dataset, height of hierarchy, cohesion within groups, overlap between groups, and homogeneity of groups, all of which are formulated in a combinatorial optimization problem.
• ÷ We present an efficient solution to the problem. Our implementation allows approximate results depending on the computational resources available, and thus can serve users with dynamically configured summaries with acceptable latency even for large datasets.

2 Constitution of Summary

We expect the constitution of a dataset summary to exhibit three features. Firstly, a summary should provide multigranular abstraction of data to be incrementally explored, since a single granularity could be either too coarse to offer adequate information or too fine to manage information overload. Secondly, a summary should preserve the structural nature of a dataset, i.e., to consist of not only its divisions but also connections between them. Thirdly, a summary should be comprehensible, i.e., to precisely and concisely characterize divisions and connections by human-readable labels.

To achieve these goals, we propose to iteratively divide the entities in a dataset into subgroups, forming a hierarchical grouping of entities to realize multiple granularities to be incrementally explored, as illustrated in Fig. 1(a). Each group is precisely characterized by a set of property-value pairs that are shared by all the entities in the group. Specifically, the root of the hierarchy (i.e., the only group at the 0-th level) contains all the entities in the dataset. Each group at the lth level is characterized by a set of l property-value pairs, l - 1 of which are inherited from its ancestors in the hierarchy (i.e., groups on the path to the root of the hierarchy)

and are omitted from presentation; it is distinguished from its siblings by the remaining property-value pair as its label, and sibling groups are allowed to overlap (i.e., containing common entities) when some entity has all of these propertyvalue pairs (e.g., a person who is both an actor and a director). The contents of a group are presented as a graph, in which its subgroups are connected by relations, as illustrated in Fig. 1(b); such a relation indicates that some entities in one subgroup have this relation to some entities in the other subgroup. In this way, both entity groups and the connections between them are labeled with concise terms that exactly come from the dataset, ensuring their comprehensibility.

3 Generation of High-quality Summary

Entities in a dataset can be grouped into different hierarchies; different relations can be selected from the dataset to connect groups. These lead to many and various summaries. In this section, we define a high-quality summary from five aspects, and obtain it by building a hierarchy of groups in a top-down manner via iterative subdivisions. Our solution, to be invoked iteratively, deals with a group of entities, and focuses on which subgroups the input group should be divided into, connected by which relations. We formulate a subdivision as a combinatorial optimization problem, and present an efficient solution to find the desired subgroups and relations.

3.1 Quality of Summary

To avoid overloading users with information, an input group should be divided into a limited number of subgroups, connected by selected relations. Their quality is fivefold.

Coverage of Data. The subgroups altogether should cover as many entities in the input group as possible, and thus each subgroup should cover a considerable portion. Analogously, selected relations should connect many pairs of entities.

Height of Hierarchy. Steadily dividing groups into large and overlapping subgroups to strive for coverage may generate a deep hierarchy of groups, leading to low efficiency of users' incremental exploration. To achieve a trade-off, subgroups should be not too large but moderate-sized.

Cohesion within Groups. The cohesion of a subgroup measures the extent to which the entities in it form a united whole. It is embodied in the common property-value pairs of the entities in the subgroup, which should not be generic ones shared by a broad range of entities in the dataset.

Overlap between Groups. Sibling subgroups are allowed to overlap, to help generating more natural subgroups. Nevertheless, their overlap should be controllable, to provide users with diverse directions in exploration.

Homogeneity of Groups. To avoid subdivision from different dimensions and reduce cognition burden, users may prefer homogeneous subgroups that are distinguished by different values of the same property. It should be configurable. These five aspects are jointly formalized in the following.

3.2 ProblemFormulation

Let E, P, and V be the sets of all entities, properties, and values in a dataset, respectively. Let R ✓ P be the set of all relations, i.e., properties having entities as values. A dataset is a set of entity descriptions; the description of an entity e 2 E is a set of property-value pairs D(e) ✓ (P ⇥ V ).

When building a hierarchy of entity groups in a top-down manner, a group G ✓ E having been placed at the l-th level of the hierarchy is characterized by a set of l property-value pairs PV (G) ✓ (P ⇥ V ), which are shared and are only shared by the entities in G:

E is the only group at the 0-th level, as the root of the hierarchy and characterized by an empty set of property-value pairs, i.e., PV (E) = ;. When l > 0, among the l property-value pairs in PV (G), l -1 are inherited fromG's ancestors in the hierarchy, and the remaining one that distinguishes G from its siblings is called G's label, denoted by lbl(G) 2 PV (G). As illustrated in Fig. 1(a), the group labeled with Country:US is characterized by ¶Type:Movie, Country:US♦.

In a top-down building process, our solution takes a group G ✓ E as input, and aims to divide it into not more than k subgroups and obtain a high-quality summary as discussed in Sect. 3.1. Since groups are characterized by propertyvalue pairs, generating k subgroups of G amounts to selecting k property-value pairs (other than PV (G)) from descriptions of the entities in G, each as the label of one subgroup.

We formulate it as a combinatorial optimization problem. Specifically, k property-value pairs will be selected from

Prior to selection, from these candidates, those corresponding to small subgroups containing smaller than a threshold proportion of entities are filtered out, to ensure considerable coverage of entities; the remaining candidates are

where ⌧E 2 [0↪ 1) is a parameter to be tuned, and lbl-(pv) returns the candidate subgroup labeled with pv:

Given n = ♣CPV 0 (G)♣, we number the property-value pairs in CPV 0 (G) from pv1 to pvn, and introduce a series of binary variables xi for i = 1▷▷n to indicate whether pvi is selected into a solution to the following combinatorial optimization problem:

In the objective function, modsize(pvi) 2 [0↪ 1] is larger when the proportion of entities in G contained in lbl-(pvi) is closer to 1k , to achieve a trade-off between coverage of entities (which favors large subgroups) and height of hierarchical grouping (which favors small subgroups):

and coh(pvi) 2 [0↪ 1] is larger when pvi is shared by fewer entities in E, indicating a higher cohesion of lbl-(pvi):

According to information theory, coh(pvi) actually measures the normalized information content associated with the probabilistic event that pvi describes an entity in E. Since one single solution can rarely simultaneously maximize modsize and coh, a linear scalarization quantifying a trade-off between them is maximized, with weights ↵↪ β 2 [0↪ 1] to be tuned.

In the constraints, 1© and 2© require that a solution selects at most k property-value pairs; 3© requires that any two generated subgroups lbl-(pvi) and lbl-(pvj) cannot have an overlap larger than a threshold δ 2 [-1↪ 1] to be tuned:

which is in [-1↪ 1] and, according to information theory, actually measures the normalized pointwise mutual information (which is a kind of association) between the probabilistic event that pvi describes an entity in G and the probabilistic event that pvj describes an entity in G.

If homogeneous subgroups labeled with the same property are required, we extend Eq. (5) by adding a new constraint:

where pi↪ pj 2 P are the properties in pvi↪ pvj , respectively. Last but not least, every ordered pair of generated subgroups Gi and Gj are connected by relations selected from

those connecting entities in Gi to entities in Gj:

A relation r 2 CR(Gi↪Gj) will be selected if it connects more than a threshold number of entity pairs fromGi to Gj:

where ⌧R 2 [0↪ 1] is a parameter to be tuned.

3.3 Problem Solution

The combinatorial optimization problem in Eq. (5) (and (9)) can be seen as a multidimensional knapsack problem (MKP), which is NP-hard [Kellerer et al., 2004]. Specifically, each candidate property-value pair pvi is treated as an item in MKP, and ↵·modsize(pvi)+β ·coh(pvi) is seen as its profit; 2©and 3©(and 4©, when necessary) formmultiple constraints in which the weight of an item is 1 in 2©, and is 1 (presence) or 0 (absence) in 3© (and 4©). We solve it using a greedy strategy, considering candidate property-value pairs one after the other and selecting one into the solution if that would not violate any constraint. Candidates are sorted in decreasing order of the following heuristic [Kellerer et al., 2004]:

where cons(pvi) is the number of constraints where pvi (i.e., xi) presents, i.e., with a weight of 1.

Even with a greedy strategy, an efficient implementation is non-trivial because some operations above are computationally expensive over a large dataset. The following implementation manipulates inverted indexes, and allows approximate results depending on the computational resources available.

Finding Candidates. Considering efficiency, our implementation refers to a group via the set of property-value pairs characterizing it, not explicitly storing the entities in it but retrieving them when needed. So given G, or more precisely PV (G), CPV 0 (G) is obtained using Algorithm 1, which retrieves the entities in G based on PV (G) (line 2) and then collects and filters their property-value pairs (line 3-10).

Specifically, to retrieve the entities in G, an inverted index idxE is created based on Lucene (lucene.apache.org), which is usually used in information retrieval to index terms in documents. In idxE, each entity e 2 E and each property-value pair in D(e) are indexed as a document and a term in the document, respectively. Then, the entities in G are obtained by submitting to idxE a conjunctive query consisting of the property-value pairs in PV (G) as clauses (line 2).

The entities in lbl-(pv) are obtained in a similar way (line 6). Its size is checked according to Eq. (3) (line 7). We notice that ♣lbl-(pv)♣  freq(pv), inspiring us to precompute freq for each property-value pair in the dataset; then, the precomputed freq(pv) is checked (line 5) before line 67, since that is very fast and may save a query against idxE.

We limit the size of CPV 0 (G) to a maximum of θE (line 9-10), depending on the computational resources available, to ensure that the resulting MKP will be solved in a reasonable time. To avoid missing subgroups containing important entities due to the limit, the entities retrieved in line 2 are sorted in order of importance, which is measured by PageRank in a directed entity-relation graph derived from the

Algorithm 1: Computing CPV 0 (G)

Data: PV (G). Result: CPV 0 (G). 1 CPV 0 (G) ;; 2 G Query idxE with a conjunction of PV (G); 3 for the i-th entity ei 2 G do 4 foreach pv 2 D(ei) do 5 if freq(pv) ♣G♣ ≥ ⌧E then 6 lbl-(pv) Query idxE with a conjunction of PV (G) [ ¶pv♦; 7 if ⌧E  ♣lbl-(pv)♣ ♣G♣ < 1 then 8 CPV 0 (G) CPV 0 (G) [ ¶pv♦; 9 if ♣CPV 0 (G)♣ = θE then 10 Break the outermost loop; 11 return CPV 0 (G);

dataset, where vertices are the entities in E and an arc connects ei 2 E to ej 2 E if ej is a property value of ei, i.e., ei has a relation to ej . PageRank scores are precomputed and added to idxE, to be used by Lucene's sorting function.

Establishing Constraints. To establish the constraints, whereas 1©2©4©are trivial, 3©checks every pair of propertyvalue pairs in CPV 0 (G) and computes, for each pair, ovlp(pvi↪ pvj) according to Eq. (8). That involves lbl-(pvi), lbl-(pvj), and lbl-(pvi) \ lbl-(pvj), which are obtained by querying idxE with a conjunction of PV (G) [ ¶pvi♦, PV (G) [ ¶pvj♦, and PV (G) [ ¶pvi↪ pvj♦, respectively.

Computing Heuristic Function. In Eq. (12), cons(pvi) is obtained by going over all the constraints; to compute modsize(pvi) according to Eq. (6), lbl-(pvi) is obtained by querying idxE as described above; coh(pvi) is obtained according to Eq. (7) based on the precomputed freq(pvi).

Selecting Relations. Given two subgroups Gi and Gj, or more precisely PV (Gi) and PV (Gj), relations connecting them are found using Algorithm 2, which retrieves candidate relations CR(Gi↪Gj) based on PV (Gi) and PV (Gj) (line 2-4) and then selects those satisfying Eq. (11) (line 5-9).

Specifically, an inverted index idxR is created based on Lucene, in which each entity-relation-entity triple he↪ r↪ e0 i 2 (E⇥R⇥E) in the dataset subject to hr↪ e0 i 2 D(e) is indexed as a document with three fields: each property-value pair in D(e) is indexed as a term in the field FS, r is indexed as a term in the field FR, and each property-value pair in D(e0 ) is indexed as a term in the field FT . Then, the relations in CR(Gi↪Gj) are obtained by submitting to idxR a conjunctive query consisting of the property-value pairs in PV (Gi) for FS and those in PV (Gj) for FT as clauses (line 2), and collecting FR of the retrieved results (line 3-4).

The set of entity-relation-entity triples in the numerator of Eq. (11) is obtained (as Tm) by querying idxR in a similar way (line 5). Its size is checked according to Eq. (11) (line 67), where ♣Gi♣ and ♣Gj ♣ have been computed in Algorithm 1.

We limit the number of relations to a maximum of θR (line 8-9), depending on the computational resources available. To avoid missing relations connecting important enti- Algorithm 2: Finding Relations that Satisfy Eq. (11)

Data: PV (Gi) and PV (Gj). Result: Subset of CR(Gi↪Gj) that satisfy Eq. (11). 1 Rij ;; 2 T Query idxR with a conjunction of PV (Gi) for FS and a conjunction of PV (Gj) for FT ; 3 for the m-th result in T do 4 rm FR of the m-th result; 5 Tm Query idxR with a conjunction of PV (Gi) for FS, PV (Gj) for FT , and rm for FR; 6 if ♣Tm♣ min(♣Gi♣↪♣Gj♣) ≥ ⌧R then 7 Rij Rij [ ¶rm♦; 8 if m = θR then 9 Break the loop; 10 return Rij;

ties due to the limit, the results retrieved in line 2 (which are entity-relation-entity triples) are sorted in order of the total PageRank score of the two entities. Scores are precomputed and added to idxR, to be used by Lucene's sorting function.

4 Experiments

We have implemented an online prototype of our HIEDS approach. 1 In this section, we empirically study the quality of summaries for real-world RDF datasets generated by HIEDS under various configurations, compare it with a baseline method, and report its running time.

4.1 Datasets

Two extensively used RDF datasets were tested.

• ÷ SWDF 2 (Semantic Web Dog Food) offers 200K entityproperty-value triples describing 20K entities in the research domain (e.g., papers, researchers).
• ÷ LinkedMDB 3 offers 6M entity-property-value triples describing 0.6Mmovie-related entities (e.g., actors).

4.2 Metrics

Given a hierarchical grouping of entities generated by HIEDS, three metrics were measured: weighted average coverage, average cohesion, and height.

For each non-leaf group G in a hierarchical grouping, the coverage of G achieved by its subgroups sg(G) is the proportion of G covered by the union of sg(G):

The weighted average coverage of a hierarchical grouping, in [0↪ 1], is the average of coverage achieved over all the non-leaf groups (NLG) weighted by the logarithm of their sizes:

1 http://ws.nju.edu.cn/hieds/

2 http://data.semanticweb.org/

3 http://data.linkedmdb.org/

average cohesion

average cohesion

(c) SWDF (s.t. 4©).

(d) LinkedMDB (s.t. 4©).

Figure 2: Weighted average coverage (x-axis), average cohesion (y-axis), and height (diameter), under different k↪ ↵↪ β.

average cohesion

The average cohesion of a hierarchical grouping, in [0↪ 1], is the average of cohesion of all the non-root groups (NRG):

which reuses coh defined by Eq. (7); lbl(G) is the propertyvalue pair that labels G.

The height of a hierarchical grouping is the number of edges on a longest path between the root and a leaf.

4.3 Results and Discussion

In this experiment, groups were iteratively subdivided until each leaf group contained not more than 50 entities. We fixed θE = +1 and ⌧E = 0▷01 (c.f. Algorithm 1), to focus on the effects of other parameters.

Effects of ↵, β, k, and 4©. Firstly we tested the effects of ↵ and β (c.f. Eq. (5)), k (i.e., the maximum number of subgroups of each non-leaf group), and whether to consider constraint 4© (c.f. Eq. (9)), under fixed δ = 0 (c.f. Eq. (5)) for simplicity. Figure 2 shows the weighted average coverage, average cohesion, and height of hierarchical grouping generated under different settings of k, corresponding to different curves; the six points in each curve corresponded to different values of ↵ from 0.0 to 1.0 in 0.2 increments and β = 1 - ↵.

In Fig. 2(a) and 2(b) where constraint 4© was not introduced, when increasing ↵ relative to β, weighted average coverage rose rapidly and average cohesion fell gradually, because a large value of ↵ would favor large groups covering many entities whose cohesion was relatively low. However, weighted average coverage was below 0.5 under all the configurations on both datasets, being not very large, because except for Type, the two datasets lacked categorical properties that could induce groups of a considerable size; it would motivate us to seek novel ways of characterizing a group beyond property-value pairs in future work. When increasing k, both weighted average coverage and average cohesion were improved, because more small, cohesive groups were added to the summary; however, for those benefits, users had to spend more time reading many groups (and relations connecting them) at a time. Similar results were observed when constraint 4©was introduced to require homogeneous subgroups, as shown in Fig. 2(c) and 2(d).

Height was generally very small in the experiment because the size of group decreased exponentially with height, and thus would not bore users with too much interaction. On SWDF it was usually 2-4, and on LinkedMDB 3-5.

Effects of δ. Then we tested the effects of δ, under fixed k = 7 and not introducing constraint 4© for simplicity. Figure 3 shows the weighted average coverage, average cohesion, and height of hierarchical grouping generated under different settings of δ, corresponding to different curves; the six points in each curve corresponded to different values of ↵ from 0.0 to 1.0 in 0.2 increments and β = 1 - ↵.

Under the same value of ↵ and β, weighted average coverage was generally larger and average cohesion was slightly lower when δ was larger, because the allowed degree of overlap between groups was raised so that some large groups of relatively low cohesion were added to the summary.

Since larger values of δ led to more large groups, the height of hierarchical grouping rose accordingly. It hit a peak of 6 on LinkedMDB when ↵ ≥ 0▷6 and δ = 0▷5.

Comparison with Baseline. We compared HIEDS with LODeX [Benedetti et al., 2014], a baseline schema-based method for summarizing a dataset. LODeX grouped entities by their classes, and the k largest groups would form a summary; it could be conceived as a specific configuration of HIEDS that was biased towards coverage. The flat grouping it generated achieved higher coverage than HIEDS, as shown in Fig. 2. However, the cohesion of those groups was rather low, like Type:Person on LinkedMDB describing an overly broad concept. The results also included notably overlapping groups offering redundant information, like Type:Person and Type:Chair on SWDF; by comparison, HIEDS could be configured to control the degree of allowed overlap.

4.4 Running Time

We tested the running time of HIEDS on an Intel E3-1225 v3 with 30G memory for our Java program. All the relevant data resided in the memory, expect for Lucene indexes on disk. In HIEDS, groups were iteratively subdivided until each leaf group contained not more than 50 entities; the following parameters were fixed for simplicity: ↵ = β = 0▷5, δ = 0, ⌧E = ⌧R = 0▷01, k = 7, and not introducing constraint 4©.

Note that the running time of HIEDS is not explicitly related to ↵, β, δ, or ⌧R, though it may be affected by ⌧E and k.

Figure 4 shows the running time under different values of θE and θR (c.f. Algorithm 1 and 2, respectively) from 20 to 200 in 20 increments. The running time generally increased linearly when increasing θE and θR; in practice, they could be tuned depending on the computational resources available to an application, to achieve a trade-off between quality of summary and running time. When θE = θR = 200, HIEDS took only 4s to compute all the iterations and generate a hierarchical summary for SWDF, but took 163s for LinkedMDB, mostly used to establish constraint 3©which queried the inverted index idxE for every pair of candidate property-value pairs in CPV 0 .

Actually, since a hierarchical summary was to be incrementally explored, it might be not necessary to compute all the iterations; an iteration could be computed just prior to exploring it, and thus a more important metric would be the average running time per iteration. As shown in Fig. 4, when θE = θR = 200, the averages were 0.5s and 7s for SWDF and LinkedMDB, respectively; it would be even faster under smaller values of θE and θR, or by parallelizing our implementation, thereby being capable of serving users with dynamically configured summaries with acceptable latency.

5 RelatedWork

Dataset Summarization. To summarize a dataset for quick inspection, schema-based methods group entities by their classes and connect groups by relations, to form a conceptual graph (or a set of tables [Yan et al., 2016]) as a high-level abstraction of data. Such a small-sized graph focuses on classes and relations either frequently used [Basse et al., 2010; B¨ohm et al., 2012] or centrally located [Presutti et al., 2011; Christodoulou et al., 2013] in the data, and its visualization is often associated with statistical information such as frequency of classes and relations [Benedetti et al., 2014; Palmonari et al., 2015]. By comparison, partition-based methods exploit all the properties beyond Type to group entities. Partition is based on commonly related entities [Khatchadourian and Consens, 2010], common relations [Tian et al., 2008], or a variety of features [Campinas et al., 2013]. Whereas both schema- and partition-based methods generate flat summaries, our HIEDS approach organizes groups into a hierarchy providing multi-granular abstraction of data to be incrementally explored. As a generic approach, HIEDS can be configured to either generate homogeneous groups based on a single property like schema-based methods (which only use Type) or exploit all the properties like partition-based methods; HIEDS can also be configured to allow different degrees of overlap between groups, and thus can generate natural but overlapping groups whereas partition-based methods require disjoint groups.

Different from the above browsing-oriented methods, summaries have also been generated to help efficiently answering structured queries posed to a dataset [Rietveld et al., 2014; Dolby et al., 2007] or testing whether a query has any answers against a dataset [ ˇCebiri´c et al., 2015]. Compared with our work, these query-oriented methods pursue different goals, and their techniques are orthogonal to ours.

Ontology Summarization. The ontological schema of a dataset may also be very large; its summary will be used in ontology search engines for quick inspection. Existing methods adopt extractive strategies, to select a subset of salient classes and properties [Wu et al., 2008; Peroni et al., 2008] or their descriptions [Zhang et al., 2007; Troullinou et al., 2015] from an ontology. By comparison, we deal with not the schema but the contents of a dataset. Our HIEDS approach adopts non-extractive strategies, to not extract a subset but generate a high-level abstraction of data.

Faceted Search. Faceted search also provides incremental exploration of a set of entities. It often assumes that a user enters a query stating a precise information need, and thus selects facets biased towards the query [Roy et al., 2008], whereas our HIEDS approach is query-independent and addresses browsing-related concerns. Compared with existing browsing-oriented methods [Wagner et al., 2011], HIEDS is distinguished not only by its generic nature comprising five aspects and the efficient implementation thereof, but also by its consideration of relations connecting groups in a summary.

6 Conclusion

To summarize the contents of a dataset for quick inspection, our HIEDS approach integrates five configurable aspects into a combinatorial optimization problem to solve, and generates a hierarchical grouping of entities connected by relations to be incrementally explored. It finds applications in open data portals, and our efficient implementation is proven to serve users with dynamically configured summaries with acceptable latency. We plan to extend our online prototype and develop such a portal featuring dataset summaries generated by HIEDS, and conduct a user study based on that.

Our work can be improved in several directions. It would be useful to seek novel ways of characterizing a group beyond property-value pairs, and to find an index-free implementation that directly operates against a SPARQL endpoint. Besides, it would be interesting to explore how to summarize a dataset covering a wide range of topics like DBpedia, which has not been effectively resolved by existing methods.

Acknowledgments

This work was supported in part by the 863 Program under Grant 2015AA015406, in part by the NSFC under Grant 61572247 and 61223003, and in part by the Fundamental Research Funds for the Central Universities.