dataesr/scientific-paragraphs-categorization huggingface dataset:
Propagating Annotations Attribute propagation has been first studied in the context of part-whole relations in Object-Centered systems  [50]  and in Description Logics  [51] , where attributes of parts can be considered attributes of wholes and vice versa. In  [50]  authors describe an attribute propagation mechanism in Object-Oriented databases that exploits the part-whole relations. Two types of propagation is outlined invariant and trans f ormational, where the latter is typically used to aggregate attributes of parts to obtain an attribute for the whole (e. g. , a car's weight is the sum the weight of all its components). Metadata propagation has been explored in digital library research. In  [52]  authors accelerate the curation of shared research work products through propagation of basic metadata, such as authorship, subject, or publication date, from the research articles to their supplementary material (data, visualisations, charts).
Such propagation may result in incorrect annotations (e. g. , not all charts of a paper may have been authored by the same person). Authors propose that inaccuracies are later corrected via manual curation. Propagating annotations of data artefacts to other data artefacts by exploiting provenance has been studied in the context of databases. In DBNotes  [53]  authors track query results to corresponding source tuples for Select-Project-Join-Union queries. DBNotes uses set union to gather all annotations over source tuples to obtain an annotation set for the result. In  [54]  authors describe a logic-based approach, which exploits semantics of relational query operators to propagate of schema-level semantic annotations through queries. Rules for propagation of annotations through each relational operator is represented as a logic constraint.
Authors speculate that such an approach can find applicability in semi-automated annotation of workflows. What sets LabelFlow apart from annotation propagation over white-box database provenance is that it operates over grey box provenance. In a scientific workflow setting, data structures and computations are diverse, hence we cannot make the restrictive assumptions on the structure of data (as relations and tuples), and the kinds of data-processing (relational queries). On the other hand our empirical analysis on workflows and the Motif categorisation has shown that certain types of computation (data adapters) are not entirely arbitrary, and their operation can be made explicit in a rough-cut manner through semantics annotations specifying, from which inputs to which outputs value-copying occurs.
• For a workflow or group of workflows identify provenance querying hooks, these are input parameters that can be permuted at run time, or processor configurations determined during workflow design. Create a labelling vector that is comprised of label definitions that would carry this information. In our case this was simply a subset of the AVM metadata profile. We think the most suitable user group to build labelling functions are developers who build the library of analytical processors for workflow systems. These re-usable processors are called Components in Taverna, Tools in Galaxy and Modules in Vistrails. Within Taverna a Component is an analytical or data adaptation step wrapped into a sub-workflow. If the component that a developer has built performs an analytical or data retrieval task, then the developer can also build the associated labelling function.
Functional dependencies (FDs) provide valuable knowledge on the relations between the attributes of a data table. A functional dependency holds when the values of an attribute can be determined by another. It is shown that FDs can be expressed in terms of partitions of tuples that are in agreement w. r. t. the values taken by some subsets of attributes. To extend the use of FDs, several generalizations are proposed. In this work, we study approximate-matching dependencies that generalize FDs by relaxing the constraints on the attributes, i. e. agreement is based on a similarity relation rather than on equality. Such dependencies are attracting attention in the database field since they allow to uncrisp the basic notion of FDs, and can be applied in many different fields, e. g. data quality, data mining, behavior analysis, data cleaning or data partition.
Introduction In the relational database model, functional dependencies (FDs) are among the most popular types of dependencies, since they indicate a functional relation between sets of attributes  [1, 2, 3] : the values of a set of attributes are check the consistency of a database but also to guide the database design  [4]. However, the definition of FDs is too strict for several useful tasks, for instance, when one should deal with imprecision in the data, i. e. errors and uncertainty in real-world data. To overcome this problem, different generalizations of FDs have been defined. These generalizations can be classified according to 10 the criteria by which they relax the equality condition of FDs  [5]. According to this classification, two main strategies are presented: "extent relaxation" and "attribute relaxation" (in agreement with the terminology introduced in  [5] ).
Characterizing and computing FDs are strongly related to lattice theory. For example, lattice characterizations of a set of FDs are studied in  [6, 7, 8, 15 9 ]. Following the same line, a characterization of FDs within Formal Concept Analysis (FCA) is proposed in  [10]. In the last case, the original data table is turned into a formal context (i. e. binary table) and implications of this context are in one-to-one correspondence with the set of FDs. However, the resulting formal context has a quadratic number of objects w. r. t. the original dataset.
Notation We deal with datasets which are sets of tuples. Let U be a set of attributes and Dom be a set of values (a domain). For the sake of simplicity, we assume that Dom is a numerical set. A tuple t is a function t : U → Dom and then 50 a table T is a set of tuples. Usually a table is presented as a matrix, as in the table of Example 1, where the set of tuples (or objects) is T = {t 1 , t 2 , t 3 , t 4 } and U = {a, b, c, d} is the set of attributes. Sometimes the set notation is omitted and we write ab instead of {a, b}. The functional notation allows to associate an attribute with its value. We define the functional notation of a tuple for a set of attributes X as follows, assuming that there exists a total ordering on U. Given a tuple t ∈ T and X = {x 1 , x 2 ,. , x n } ⊆ U, we have: t[X] = t(x 1 ), t(x 2 ),.
Generalizations of Functional Dependencies Functional dependencies tell us which attributes are determined by other attributes. As such, FDs are mainly used in databases to determine which 90 attributes are the keys of a dataset, i. e. the minimal sets of attributes (if any) determining all other attributes. This information is necessary for maintaining the consistency of the whole database. This information can also be useful in data analysis or in data classification, because of the the semantics attached to the "determined by" relationship.
95 However, in practical applications, we usually have datasets that contain imprecise or uncertain information. Here, we are not meaning false information, but information that may contain errors. For example, let us consider a dataset containing information about the name and social security number (SSN) of citizens. Although SSN is supposed to be unique for every individual, 100 it appears that sometimes SSN is shared by more than one individual. In such a case, the FD ''social security number → name, surname'' would not hold, although we know that SSN does determine an individual. This is a case where FDs reveal inconsistencies or errors in a database. Actually, here we rely on prior domain knowledge on the dataset, i. e. SSN is attached to a unique indi-105 vidual. Without this previous assumption, the fact that a FD such as ''social security number → name, surname'' does not hold, would not give us any relevant information.
In some other cases, FDs may fail in providing us interesting information. For example, let us consider a dataset containing information about which brand 110 of beer and TV sitcom are preferred by customers, involving attributes such as customer id, beer brand, tv sitcom. Now, assume that people preferring a specific brand of beer, say beer X, also prefer sitcom X in an overwhelming 95% of cases. This means that there are 5% of the cases in which a customer preferring beer X will prefer sitcom Y for example. These few cases prevent 115 the FD beer brand → sitcom from holding, even if this dependency holds in a very large majority of the cases in the dataset. To overcome the limitations of FDs, several generalizations of FDs have been introduced. These generalizations can be divided into two main groups  [5] , depending on the strategy to relax the semantics of FDs.
Extent-Relaxing Dependencies The general assumption in this category is that a FD does not necessarily hold in the whole dataset. A FD X → Y holds in a table T if and only if it 125 holds for all pairs of tuples in T. This is precisely the "for all" condition that should be relaxed, i. e. the extent of the table in which this condition must hold. An extent-relaxed FD holds in a table T if and only if it holds in a fraction of all the pairs of tuples in T. There are many different ways to relax the "universal" condition. A threshold can be given as a percentage (e. g. Approximate a number of tuples for each attribute (e. g. Numerical Dependencies  [20] ), or as a probability (e. g. Probabilistic functional dependencies  [21].
Houston Approximate Dependencies  [18]  can be likened to association rules  [23]. The validity of association rules depends on certain metrics such as confidence and support. Confidence measures the proportion of the whole dataset in which an 140 association rule holds. An association rule R having a confidence of 100% is in fact an implication. Another way of interpreting the semantics of confidence is the following: when an association rule has a confidence of x%, then removing the 100-x% of the tuples which are not in agreement allows the association rule to become an implication. This idea of counting the number of tuples in which 145 a given dependency holds, or, more precisely, the minimal number of tuples to be removed to allow a FD to hold, is the main idea underlying "Approximate Dependencies".
g. a distance function among the values appearing in the dataset. Secondly, "order-like dependencies" are such that two values must be ordered instead of being somehow similar or close. order-like dependencies can be studied in the framework of FCA as shown 175 in  [24]. However, for the sake of simplicity and clarity we will not discuss further these dependencies in the present paper. Attribute-relaxing dependencies are present in the database literature. An extension of Codd's relational model in which attribute domains are equipped with similarity relations is presented in  [25]. Fuzzy attribute implications in 180 FCA are also related with this sort of dependencies, as fully explained in  [26]. In the remainder of this section, we detail so-called "Neighborhood Dependencies" and "Differential Dependencies".
Neighborhood Dependencies Neighborhood Dependencies (NDs) were defined to express regularities in Let δ ∈ [0, 1] be a threshold, and let a, b ∈ T [x]. Then, θ x (a, b) ≥ δ is a neighborhood predicate on the attribute x. We still use the same notation θ x to indicate a neighborhood predicate, where the threshold is tacitly assumed. We 195 suppose that each attribute x ∈ U has a related threshold δ and an associated comparison operator which may be, obviously, different for each attribute. This predicate induces a relation on the set of tuples T w. r. t. θ and according to a set of attributes X ⊆ U. Pair of tuples t, t ∈ T are said to be related according to a set of attributes X ⊆ U, denoted by (t θ X t ), if: tθ X t ⇔ x∈X θ x (t[x], t [x]) A neighborhood dependency θ X → θ Y holds in a dataset T iff: ∀t, t ∈ T : x∈X θ x (t[x], t [x]) → y∈Y θ y (t[y], t [y]) This can be rewritten as: ∀t, t ∈ T : t θ X t → t θ Y t This dependency holds for each pair of tuples t, t , if all the neighborhood predicates for the attributes x ∈ X evaluate to true, then all the neighborhood predicates for the attributes y ∈ Y evaluate to true as well.
Differential Dependencies Differential Dependencies were defined to extend the notion of equality in FDs  [28]  They can be used to detect violations or inconsistencies in datasets, to optimize queries, to partition data in parts that are somehow similar or detect A differential function over an attribute x ∈ X and a pair of tuples t, t is a Boolean function that evaluates true when a constraint on the values θ(t[X], t [X]) holds. A constraint can be specified by the comparison operators =, <, >, ≤, ≥ and a threshold δ, e. g. θ(t[x], t [x]) ≤ δ (also simply rewritten differential function θ also induces a relation among the set of tuples according to a set of attributes X ⊆ U as with neighborhood dependency (previous subsection).
Characterization of Dependencies within Pattern Structures Thanks to the formalism of pattern structures, approximate-matching dependencies can be characterized (and computed) in an elegant manner, as it is shown in  [12]. Firstly, the description of an attribute m ∈ M is given by δ(m) = G/θ m which is given by the set of tolerance blocks w. r. t. θ m and 335 G = T. As symmetric relations can be ordered (see Definitions 5 and 6) then descriptions can be ordered within a lattice. A dataset can be represented as a pattern structure (M, (D, ), δ) where M is the set of original attributes, and (D, ) is the set of sets of blocks of tolerance over G provided with the meet operation introduced in Definition 6. An example of concept formation is given as follows. Consider the table in Example 1. Starting from the set {a, c} ⊆ M and assuming that t i θ m t j ⇐⇒ |t i (m) -t j (m)| ≤ 2 for all attributes: Proof.
Computing Attribute-Relaxing Dependencies with Binarization in FCA In  [11]  it is shown how a binarization of a table dataset can be defined. This process consists in creating a formal context such that the set of attributes is the same as that of the dataset (U), whereas the set of objects is the set of 365 all pairs of tuples P air(T ) = {t i , t j | i < j}. We have that ((t i , t j ), m) ∈ I (for all m ∈ U) if and only if t i (x) = t j (x). In Figure  1  we have the example of a dataset (left) and this binarization (middle). The corresponding formal context is, then, K = (P air(T ), U, I). Binarization is also defined in  [2]  and  [4]  as agree sets, which are pairs of tuples that agree in all the values of a given set 370 of attributes, and disagree in all the rest of them. This binarization stated that an implication X → Y holds in the formal context K = (P air(T ), U, I) if and only if the functional dependency X → Y holds in T.
It turns out that the same relationship that exists between implications and functional dependencies, also exists between similarity dependencies and implications in this new generalization of a binarized formal context. This means that the implication X → Y holds in the formal context K θ = (P air(T ), U, I θ ) 385 if and only if the similarity dependency X → Y holds in the dataset T. The proof is quite straightforward: Proposition 3. Let T be a dataset, and U the set of its attributes. The similarity dependency X → Y (X, Y ⊆ U) holds in T if and only if the implication X → Y holds in the formal context K θ = (P air(T ), U, I θ ).
395 In the literature, pattern structures have been defined over various description spaces (partitions, intervals, graphs, etc. , see  [29] ). When an "equivalent" data representation can be given by a formal context, one needs to understand which one is the best in terms of efficiency. By "equivalent" data representation, we mean that they derive isomorphic concept lattices. For example, 400 starting from a numerical dataset,  [30]  shows that n-dimensional closed intervals can be characterized in two different ways: (i) with a pattern structure having a meet-semi-lattice of intervals as a description space, and (ii) with a formal context obtained with an interordinal scaling. Depending on the original dataset characteristics (number of tuples, number of attributes, distribution 405 of attribute domains, etc.
), one data representations is preferred to the other. The aim of the present section is to provide discussion elements on the feasibility and scalability of extracting similarity dependencies with pattern structures and from an "equivalent" derived formal context. a formal context built thanks to the binarization of a dataset (yielding a quadratic number of objects). We also showed that partition pattern structures  [11]  can be adapted to produce a concept lattice isomorphic to the one raised from binarization. Thus we have here two ways for characterizing similarity dependencies with FCA. In this section, we experiment with both methods to highlight their 415 strengths and weaknesses. We used an Intel Xeon machine with 6 cores running at 2. 27GHz and 32GB of RAM machines, and all algorithms are implemented in C++ and compiled with the -O3 optimization.
Dataset Description and Experimental Settings We experimented with 3 datasets from the UCI machine learning repository 420 and 3 datasets from the JASA data archive, namely the diagnosis 1 , contraceptive 2 , servo 3 , caulkins 4 , hughes-r 5 , and pglw00 6 datasets, described in Table  2. With the exception of caulkins and hughes-r, all datasets were used without modification. In caulkins, some of the columns were ignored. Specifically, we did not considered the columns with redundant information about the weight of 425 the entry -there were two columns indicating this weight, one with the original information and another with its correspondent gram representation; we used the gram representation-and the column containing the value "gram" for every object. In hughes-r, we added four columns to encode the information of the first three columns.
435 The discretization procedure to turn a dataset into a binary formal context is achieved via a simple script: for any two objects in T , it gives the attributes from M for which those objects agree, i. e. have similar values. Moreover, a context can be clarified, i. e. the same rows and columns are fused in a fused respectively in a unique row and column  [10]. Clarification has no effect on the calculation 440 of dependencies but can significantly reduce the size of the formal context. However, both non-clarified and clarified contexts were used in the experiments. An implementation of the addIntent 7 algorithm  [31]  is used to build the concept lattice from which similarity dependencies can be characterized. To proceed with pattern structures, each attribute m ∈ M of the original 445 dataset is described by tolerance blocks of objects from T which depends on the chosen similarity parameter θ m.
Experimental results We process each dataset as follows: (i) with the standard addIntent algorithm we build the concept lattice of the derived formal context ; (ii) with a modified addIntent algorithm we build the pattern concept lattice of the pattern 465 structure. Table  2  reports the execution times for building those lattices. For non-clarified and clarified formal contexts, execution times report a sum of the binarization/clarification time and the execution of the AddIntent algorithm, respectively. For pattern structures, the execution times take into account the transformation of the numerical dataset as a pattern structure as well as its 470 processing. It should be noticed that that for the six datasets, there are different number of numerical and categorical attributes. The similarity parameter is used only for both kind of attributes, however for categorical attributes, θvalues are always 0 (equality).
Computing with Pattern Structures Can Be Very Efficient An interesting exception occurs with the dataset pglw00. It contains 17995 (10 4 ) objects meaning that the creation of the formal context should contain 495 more than 10 8 objects (roughly 161 millions). This sheer size of elements makes prohibitive the calculation of the formal context and the clarified formal context. For example, consider that each object can be represented by only a single integer variable with size 8 bytes, then the whole context would have a size of around 12 GB of memory (best case). This is particularly interesting considering 500 that the formal context contains only 6 attributes, meaning that the concept lattice can only contain up to 64 formal concepts (which it does). Through the use of pattern structures we can obtain the formal concepts of pglw00 in less than a minute and the size of the concept lattice in a compact notation is 13 MB of memory.
This makes clear that, while the use of binarization and clarification 505 of the dataset is very useful for small datasets, for slightly larger ones (consider that pglw00 is only 1 order of magnitude larger than caulkins or contraceptive), this technique is no longer feasible. In our previous work, we showed that functional dependencies which are similarity dependencies with θ = 0 can be characterized either with a formal 510 context or a partition pattern structure. It was clear that pattern structures were more efficient for finding functional dependencies. In the present work, this result is less straightforward. The main reason is the following: when dealing with functional dependencies, patterns correspond to partitions, and an object can belong to only one block of the partition. For similarity dependencies, an 515 object can belong to several blocks of tolerance (components).
The Importance of Numerical Attributes 520 For the dataset caulkins we can see that, in average, a pattern intent contains 551 components. This means that, in average, we should make more than 300K set intersection computations to obtain a single closure. This explains the fact that, even with parallelization, the calculation of the caulkins dataset concept lattice using partition pattern structures takes over 5 hours. On the 525 other side, pgwl00, while containing 10 times more objects, has an average of 88 components per intent meaning around 8K intersections per closure computation. This is due to the fact that pgwl00 only has one numerical attribute and half the total number of attributes than caulkins. If we compare caulkins with hughes-r having both the same number of attributes, we can see how the 530 processing of the hughes-r dataset requires a fraction of the time for processing caulkins.
It is worth noticing that even when hughes-r has a quarter of the number of caulkins's objects (401 and 1685, respectively), this do not explains the difference in computation time and number of formal concepts. In fact, the clarified formal contexts for both datasets have similar sizes (1146 × 12 for 535 caulkins and 1054 × 12 for hughes-r ). Furthermore, it cannot even be explained in terms of the density of the formal context for which we have a small difference as shown in Table  2. The only factor which explain this difference is established in the number of numerical attributes, which for caulkins are 9 out of 12 or three times those 540 of hughes-r with 3 out of 12 numerical attributes. In general, a numerical attribute with a given θ-value generates a partition with more components and less elements per component than a categorical attribute, which yields a partition with less larger components.
565 Finally, under the evidence shown by the experimental results, we can conclude that the use of pattern structures is of critical importance for mining similarity dependencies in medium-large datasets, where binarization and clarification are not possible due to computational limitations. Nevertheless, for sufficiently small datasets, the evidence shows that using standard FCA is a 570 far better option. We have also shown how setting the values of θ can greatly influence the output of our algorithm. The scripts and binaries necessary to replicate the experiments are freely available on-line 9.