| ID |
Question |
Name |
Answer |
| Hu2007discovering question 1 by lebo |
In Definition 3, a mapping m is a 5-tuple <id,u,v,t,f>, where u is an element of the relational schema, v is an element of the ontology, t is a relationship (e.g., equivalence or subsumption), and f is a confidence measure. Phase II of the matching process views each element of the relational schema and ontology as a "virtual document" that is compared to the other elements' "virtual documents" using the the TF/IDF cosine measure. In a mapping m, id, u, v, and f are providing in this process.
- How is t (equivalence/subsumption) determined for a given mapping?
- Does the use the subsequent third Phase, Validity Mapping Consistency, indicate a lack of confidence in the previous stage's ability to match? What else "doesn't make sense" in the matching that hasn't been filtered out?
|
Tim Lebo |
- The authors specify that a mapping m contains a relationship t that holds between the u and v. I think this definition is confusing as the authors never make use of this t. Simple mappings seem to find equivalence relationships, and contextual mappings seem to find subsumption relationships. Personally, I think that it would be useful if the system allowed human users re-run certain phases, and to make adjustments between runs. Phase 3 checks the consistency of attribute/property mappings, and this could be facilitated if users could step in and clarify the relation/class mappings (to specify equivalence, subsumption, &c.).
- As I mentioned in the preceding item, the consistency checking phase checks the consistency of mappings between, assuming (or provided) that the relation/class mappings have been computed correctly. I think the unspoken assumption is that relation/class mappings are more likely to be correct (and this is probably reasonable, particularly if the Des function has access to good descriptions, and if the number of entity relations in the database and classes in the ontology is small). So, I don't think that the presence of Phase 3 indicates a lack of confidence so much as a recognition that attribute/property matching is more difficult than relation/class matching, but is easier in the presence of the latter.
|
| Joshua Taylor Discovering Simple Mappings Gregory Todd Williams 1 |
The definition of a mapping (Definition 3) is stated in such a way as to allow mappings from R to P and from A to C. Is this just a sloppy definition? In figure 1 just below definition 3, a mapping from "Paper" in R to "Journal Paper" in O is shown with "Paper" subsuming "Journal Paper". Of what use is this mapping given the stated direction of subsumption? If the relation subsumes the class, aren't we unable to say anything about the class that a tuple in the relation belongs to? |
Gregory Todd Williams |
|
| Joshua Taylor Discovering Simple Mappings Gregory Todd Williams 2 |
In section 4.1, it is stated that entities are partitioned "in the relational schema and the ontology" into four groups. However, it seems that object properties (denoted PO) belong to groups 2-3. Is this correct? If so, can these groups accurately be called partitions? Does this diminish the claim that these partitions "limit the searching space of candidate mappings"? |
Gregory Todd Williams |
|
| Joshua Taylor Discovering Simple Mappings Joshua Shinavier 1 |
A basic premise of this work is that finding mappings between RDB schemas and ontologies is an effective way to achieve interoperability on the Web. Is this in fact the case? In what circumstances would discovering mappings between a given RDB schema and a given ontology be worthwhile? In such a scenario, are there advantages to the presented technique, versus translating the RDB schema to an ontology (e.g. using a tool like D2R) and then using existing ontology-to-ontology mapping techniques? Do the sources mentioned in the section on Related Work motivate this solution? |
Joshua Shinavier |
|
| Joshua Taylor presents Discovering Simple Mappings Between Relational Database Schemas and Ontologies Jesse Weaver |
Line 3 in the algorithm presented in Table 1 iterates over all of disjoint subclasses of class v. What if class v has subclasses that are not disjoint? How would it handle this condition? Also, line 9 of the same algorithm uses a threshold τ. What value of τ is used in the second experiment (generating contextual mappings)? |
Jesse Weaver |
As_presented,_I_do_not_think_that_ContextMatch_would_be_capable_of_handling_non-disjoint_subclasses_in_the_expected_manner._It_also_wouldn't_seem_to_handle_individuals_whose_most_specific_class_are_not_leaves. |
| Joshua Taylor presents Discovering Simple Mappings Between Relational Database Schemas and Ontologies Jesse Weaver 2 |
Figure 5 shows Marson achieving an average F1-Measure of less than 0.8 in four out of the five cases shown. How good is an average F1-Measure of 0.8? How good is an average F1-Measure in the range of 0.7 to 0.9? |
Jesse Weaver |
|
| Joshua Taylor presents Discovering Simple Mappings Between Relational Database Schemas and Ontologies Joshua Taylor 1 |
What's up with this evaluation? Is the system really only being compared against one other system? |
Joshua A. Taylor |
The Marson system is compared against the 2006 Ronto system which was developed by a team disjoint with the authors. The comparison with the Simple, VDoc, Valid systems seems a bit odd. The authors have developed a four-phase process for generating mappings, and have a reason for designing each phase. They then compared their system against crippled versions of itself. It is not particularly surprising, in my opinion, that it tends to come out on top (although, in the case of OBSERVER/Bibiography, the Valid system even does a little better). Rather than having shown that Marson is a good system (compared to other systems in the world), it seems that the combination of techniques present in Marson is better (usually) than a subset of those techniques. |
| Mappings RDB Ontology Ankesh |
- In section 4.1 the paper says n-arity relationship should be reified as a group of binary relationships. I couldn't create a clear picture how this would be done, especially what would the namings of the relations be. Would it be the attribute name that is not part of primary key? What does reified mean here? How would tokens be affected?
- In section 4.3, paper validates relationship between attribute id in author and hasID in ontology. I couldn't understand why would they be mapped in first place? Because from (2) VD(id) would contain Des(author) where as from (4) VD(hasID) would contain Des(Paper). What is confident mapping (good confidence measure)? Could you help with a better example for validation?
- In section 4.4, the algorithm distinguishes categorical attribute to non-categorical. However, it isn't clear to me how do we determine if an attribute is categorical? A naive description can be any attribute not part of primary key is categorical. Can this be correct?
|
Ankesh Khandelwal |
- An example from Wikipedia, particularly http://en.wikipedia.org/wiki/Relation_(mathematics) :
An example of a ternary or triadic relation (i.e., between three individuals) is: "X was-introduced-to Y by Z", where (X,Y,Z) is a 3-tuple of persons; for example, "Beatrice Wood was-introduced-to Henri-Pierre Roché by Marcel Duchamp" is true, while "Karl Marx was-introduced-to Friedrich Engels by Queen Victoria" is false. This (somewhat contrived) relation could be represented using a relational database. It would be a "relationship relation", and each row would store an X, a Y, and a Z. In order to represent this relationship using a triple based model, it is necessary to introduce some sort of "introducing event" objects which correspond to the rows of the table, and which would be the domain of three properties, say, introduction_event:person1, introduction_event:person2, and introduction_event:introducer. A similar thing has to happen if the database contains a Person table with three attributes, name, birthdate, and gender; the difference is that it does not seem strange to us to introduce Person objects—they're just people.
- The authors are using this example to show how the validation process would eliminate an inconsistent mapping. (Their language is a bit unclear, though.) Presumably the mapping between hasID and id would be discovered based on the results of Des(hasID) and Des(id). Though in this example "hasID" and "id" are distinct tokens, they might, in reality, have some more complex descriptions which have some similarity. If this isn't the case, it is hard to imagine the authors' system overcoming any lexical differences in terminologies that arise between databases and ontologies.
- Immediately below 'ContextMatch, the authors write "In lines 6–8, the algorithm repeatedly examines each attribute in the relation ((to determine)) whether it is a categorical attribute or not." Based on the way that they use the categorical attributes, a categorical attribute is one in which a partitioning of instances based on their attribute values corresponds to some partitioning of the disjoint subclasses of the class at hand.
|
| Mappings RDB Ontology Shangguan 1 |
In Section_4.1 the paper classifies relations in RDB into 4 disjoint types -SER/WER/RRR/SRR. But the author fails to make it clear about how to know which type a specific relation belongs to? For example, the paper treated Author as SER while Writes as RRR, which is quite intuitive. What about the other situations in which there are huge number of relations or the definition of relations are much more complicated? |
Zhenning Shangguan |
|
| Mappings RDB Ontology Shangguan 2 |
In Section_4.2, the paper gave Formulae (3) to create the virtual document for Classes in Ontologies, and stated that "In brief, for a class, its virtual document is its local description..." However, there are usually a variety of ways to define classes in an ontology, e.g., using equivalentClass, disjointClass, etc. Is it still appropriate to say that VD(C) = Des(C) if class C is defined by equivalance or disjointness? |
Zhenning Shangguan |
|
