KR20180058981A - Method and apparatus for verifying schema integration and instance validity based on semantic web - Google Patents

Method and apparatus for verifying schema integration and instance validity based on semantic web Download PDF

Info

Publication number
KR20180058981A
KR20180058981A KR1020160158006A KR20160158006A KR20180058981A KR 20180058981 A KR20180058981 A KR 20180058981A KR 1020160158006 A KR1020160158006 A KR 1020160158006A KR 20160158006 A KR20160158006 A KR 20160158006A KR 20180058981 A KR20180058981 A KR 20180058981A
Authority
KR
South Korea
Prior art keywords
class
subject
error
instance
column
Prior art date
Application number
KR1020160158006A
Other languages
Korean (ko)
Inventor
김경선
정주영
Original Assignee
(주) 다이퀘스트
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Application filed by (주) 다이퀘스트 filed Critical (주) 다이퀘스트
Priority to KR1020160158006A priority Critical patent/KR20180058981A/en
Priority to PCT/KR2017/010663 priority patent/WO2018097467A1/en
Publication of KR20180058981A publication Critical patent/KR20180058981A/en

Links

Images

Classifications

    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F16/00—Information retrieval; Database structures therefor; File system structures therefor
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F16/00—Information retrieval; Database structures therefor; File system structures therefor
    • G06F16/20—Information retrieval; Database structures therefor; File system structures therefor of structured data, e.g. relational data
    • G06F16/25—Integrating or interfacing systems involving database management systems
    • G06F16/254—Extract, transform and load [ETL] procedures, e.g. ETL data flows in data warehouses
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F16/00—Information retrieval; Database structures therefor; File system structures therefor
    • G06F16/30—Information retrieval; Database structures therefor; File system structures therefor of unstructured textual data
    • G06F16/36—Creation of semantic tools, e.g. ontology or thesauri
    • G06F16/367—Ontology

Abstract

A semantic web-based schema consistency and instance validity verification method and apparatus capable of providing more accurate search results by automatically detecting errors in schema phase and instance level are provided. The schema conformance and instance validation apparatus of the present invention includes an ontology and a triple assignment unit for acquiring and classifying triples from an ontology schema and a model and storing them in a corresponding column, a class checking unit for checking the validity of a class, A property check performing unit for checking the validity of the property, and an instance check performing unit for checking the instance validity.

Description

[0001] The present invention relates to a semantic web-based schema consistency and instance validation method and apparatus,

The present invention relates to a schema integrity and an instance validity verification method and apparatus based on a semantic web, and more particularly, to a semantic web-based schema integration method and an instance validity verification method that can provide more accurate search results by automatically detecting an error content of a schema step and an instance step And more particularly, to a method and apparatus for schema consistency and instance validation.

Semantic Web is a web-based system that provides a well-defined meaning to information on the web, allowing computers to easily interpret the semantics of documents, thereby automating the tasks of searching, interpreting and integrating information using computers. This paper is organized as follows.

Semantic Web knowledge is represented by ontologies such as Resource Description Framework (RDF) and Web Ontology Language (OWL). An ontology is a collection of RDF triples, each of which consists of the form <subject, predicate, object>. Triples are also called facts. Inference is performed to extend the knowledge expressed in the ontology. The inference technique is disclosed in, for example, Patent Registration No. 10-1133993.

RDF is an abstraction syntax that provides interoperability between applications that exchange machine-understandable information on the Web to process metadata. The RDF data model is a model that describes the information resources on the Web and specifies the relationships between them. The RDF schema provides a way to define the relationship between resource characteristics and resources.

Semantic search, on the other hand, provides objects rather than text. Since semantic search generates the search result by analyzing the meaning based on the knowledge base, the user can provide an accurate search result desired by the user. Regarding semantic search, for example, Patent Registration No. 10-1057072, Patent Registration No. 10-1508583, and Patent Application No. 10-2015-0049581 have been proposed.

Semantic search can provide the objects 'classes', 'properties' and 'instances' defined in the ontology as search results. In semantic search, the definition of relationships between objects is an important factor. Relationships between objects may not exist, may be direct, or indirect. The direct association means that two instances defined on the ontology are directly connected to one attribute, and the indirect association means that two instances defined on the ontology are connected through multiple instances and attributes .

An object of the present invention is to provide a schema integrity and an instance validity verification method and apparatus based on a semantic web that can provide more accurate search results by automatically detecting an error content of a schema step and an instance step.

The apparatus for verifying schema consistency and instance validity according to an embodiment of the present invention includes an ontology and triple assignment unit for acquiring and classifying triples from an ontology schema and a model and storing them in a corresponding column, A class relation checking unit for checking the validity of the relation between the classes, a property checking unit for checking the validity of the property, and an instance checking performing unit for checking the validity of the instance.

The ontology and the triple assignment unit add the first string of the obtained triple to the subject column, the second string to the predicate column, the third string to the object column, In a list of a class list (classList), a property list (propertyList), a subclass map (subClassMap), and an instance list (instanceList) according to the rule of "

In one embodiment, the class inspecting unit displays T in the error / non-existence column only if the class is indicated in the ontology schema, F in the error case, and N in the case of redundancy. The class relationship checking execution part displays T only when the relation of the classes is shown in the ontology schema, F when it is an error, and N when it is duplicated. The property check execution part displays T only when the property is included in the property list (propertyList), displays it as F when it is not included, and changes the value where the error check column is null to N. The instance check execution unit checks whether the subject is included in the instance list and displays it as T or F if it is included and then retrieves the subject value having the rdf: type and object class as the predicate To change the value of the error-free column to null.

In one embodiment, the class checking unit receives a subject value of P: rdf: type, O: owl: Class and checks whether the subject is included in the class list (classList) If it is not included, enter F, and search for the subject value of P: rdf: type, O: owl: Class and add N to the value where the error check column is null. The class relation checker receives the subject value of P: rdf: subClassOf, checks whether the subject and object are included in the sub class map (subClassofMap), and if so, inputs T in the error / If it is F, it searches for the subject value that is P: rdf: type, O: owl: Class and adds N to the value where the True column is null. The property check execution unit checks whether a subject is included in a property list (propertyList) by receiving a subject value of owl: ObjectiveProperty, inputs T in the error or non-existence column if it is included, inputs F if not, P: rdf: type, O: owl: Class and adds N to the value where the error or non-error column is null. The instance check execution unit receives the subject value of P: rdf: type, checks whether the subject is included in the instance list (instanceList), and inputs T into the error / non-existence column if included, P: rdf: type, O: owl: Class and adds N to the value where the error or non-error column is null.

The schema integrity and instance validation apparatus of the present invention can output a triple when the error or non-error column is not T.

According to the present invention, it is possible to automatically detect an error content of a schema step and an instance step so that a system administrator can find an error or redundant syntax. Accordingly, the accuracy of the search result of the search system can be improved.

Figure 1 shows an example of a triple storage.
Figure 2 shows a validation test according to the present invention.
FIG. 3 is an exemplary diagram showing the result of the operation of FIG. 2. FIG.
Figure 4 illustrates the triple acquisition process in the ontology schema and model.
Figure 5 shows a class verification flow diagram according to the present invention.
Figure 6 shows a flowchart of a class relationship verification according to the present invention.
7 shows a property verification flowchart according to the present invention.
Figure 8 shows an instance verification flow diagram in accordance with the present invention.

The triple is generally stored in the form of "Subject", "Predicate", and "Object" (object) as shown in FIG. Hereinafter, a procedure for allocating and verifying triples in each component of the ontology and instance verification apparatus of the present invention will be described with reference to the drawings.

2 shows a configuration of an apparatus for performing an examination according to the present invention. Referring to FIG. 2, the ontology and instance verification apparatus 100 of the present invention includes an ontology and triple allocation unit 110, a class checking unit 120, a class relation checking unit 130, a property checking performing unit 140, and an instance check performing unit 150.

The ontology and instance verification apparatus 100 of the present invention divides a triple into classes, properties, and instances according to a predetermined rule, and identifies three tables (classList, propertyList , and instanceList), and performs an inspection on them, and stores each triple with an error or not, as shown in the right table of FIG. In each column of the triple table, T is normal, F is an error, and N is a duplicate.

The ontology and triple allocation unit 110 obtains and classifies triples from the ontology schema and model, and stores the triples in the corresponding columns. FIG. 4 shows a process in which the ontology and triple allocation unit 110 obtains a triple in an ontology schema and a model and generates a list.

The ontology and triple allocation unit 110 classifies the triple by dividing the subject, the predicate, and the object in the ontology schema and model into spacebars for triple acquisition (step S41). The classified triples are stored in the respective columns. That is, the first string is added to the subject column, the second string is added to the predicate column, and the third string is added to the object column (objectColumn) (step S42). Further, each triple is stored in a corresponding list in accordance with a predetermined rule (step S43). That is, it is determined whether or not each triple matches a condition defined by a predetermined rule and stored in each list, that is, a class list (classList), a property list (propertyList), a subclass map (subClassMap), and an instance list (instanceList). For example, P (predicate): rdf: type, O (object): owl: Class If S (subject) is added to the class list (classList) and P: rdf: type, O: owl: ObjectiveProperty Add S to the property list (propertyList), add S and P to the subclass map (subClassMap) if P: rdfs: subClassOf and S to the instance list (instanceList).

A subclass map (subClassMap) is stored in order to verify an error of a subclass relationship (Class, SubClass). The subclass map (subClassMap) is used to identify the existence of logical errors and errors in the definition of class relations and constraint setting.

Here are some examples of rules for storing triples in a list. The following rules are exemplary, and the invention is not limited to any particular rule of storing triples.

1. Class Rules

Example) dq: golfEvent rdf: type owl: Class.

If the predicate is rdf: type and the object is owl: Class, the dq: golfEvent corresponding to the subject is a class.

2. Property Rules

Example) dq: hasWhy rdfs: domain dq: Shot.

dq: hasWhy rdf: type owl: ObjectiveProperty.

dq: hasWhy rdfs: range dq: Why.

A domain, range, such as dq: hasWhy, and a subject with rdf: type of owl: ObjectiveProperty, are properties.

3. Instance Rules

Example) dq: Video00000558 rdf: type dq: CutefestivalEvent.

dq: CutefestivalEvent rdf: type owl: Class.

If P is rdf: type and O is class as in the above dq: Video00000558, S corresponds to the instance.

4. True Column Rules

If the triple is not abnormal: T,

If the triple has errors: F,

If the triples are duplicates: N

The class checking performing unit 120 checks the validity of the class. The class checking performing unit 120 displays T only when the class is shown in the ontology schema, F when it is an error, and N when it is duplicated.

FIG. 5 shows an example of the operation in the class checking performing unit 120. FIG. The class test performing unit 120 receives the subject value of P: rdf: type and O: owl: Class as "distinct" (step S51) To SQL. The class checking unit 120 checks whether the subject is included in the class list (classList). If so, the class checking unit 120 inputs T in the True column and inputs F if it is not included Step S52). The class test performing unit 120 searches for a subject value having P: rdf: type and O: owl: Class and adds N to the value where the true column is null (step S53) .

The class relationship check execution unit 130 performs a validity check of a relation between classes. Only T if the relationship of classes is shown in the ontology schema, F for error, and N for duplicate.

FIG. 6 shows an example of the operation in the class relationship check execution unit 130. FIG. The class relationship check execution unit 130 receives the subject and object values of P: rdf: subClassOf as "distinct" (step S61). The class relation checker 130 checks whether the subject and the object are included in the subClassofMap. If the subject and the object are included in the subClassofMap, the class relation checker 130 inputs T in the error column or an F (Step S62). The class relation checker 130 searches for a subject value of P: rdf: type and O: owl: Class and adds N to the value where the true column is null (step S63 ).

The property check performing unit 140 performs property validation. The property check performing unit 140 fetches the property that the predicate is rdf: type and the object is owl: ObjectiveProperty. If the property is contained in the property list (propertyList), it is denoted by T. If it is not included, it is denoted by F, and if the true column is null, the value is changed to N to indicate duplication.

FIG. 7 shows an example of an operation in the property check performing unit 140. FIG. The property check execution unit 140 receives a subject value of O: owl: ObjectiveProperty as "distinct" (step S71). The property check performing unit 140 checks whether a subject is included in the property list (propertyList), and inputs T to the true column if it is included, or F if not S72). The property check performing unit 140 searches for a subject value of P: rdf: type and O: owl: Class and adds N to a value where the true column is null (step S73) .

The instance check performing unit 150 performs instance validation. The instance check performing unit 150 checks whether the subject is included in the instance list when the predicate is rdf: type and the object is a class included in the class list (classList) , T if included, F otherwise. The predicate then searches for the subject whose rdf: type and O is the class, and changes the value of the true column to null.

FIG. 8 shows an example of the operation in the instance check performing unit 150. FIG. The instance check performing unit 150 receives a subject value of P: rdf: type as "distinct" (step S81). The instance check performing unit 150 checks whether a subject is included in the instance list. If the subject check list is included in the instance list, the instance check performing unit 150 inputs T in the true column and inputs F if it is not included S82). The instance check performing unit 150 searches for a subject value of P: rdf: type and O: owl: Class and adds N to a value where the true column is null (step S83) .

After validating the triple through such a procedure, the final result is obtained in the form of Fig. Through such a procedure, in the case of a triple configured as shown in the right table of FIG. 3, it is possible to output a case where the True is not T, thereby searching for the error or redundant syntax.

While the present invention has been described with reference to exemplary embodiments, it is to be understood that the invention is not limited to the disclosed exemplary embodiments. That is, within the scope of the present invention, all of the components may be selectively coupled to one or more of them. In addition, although all of the components may be implemented as one independent hardware, some or all of the components may be selectively combined to perform a part or all of the functions in one or a plurality of hardware. As shown in FIG. The codes and code segments constituting the computer program may be easily deduced by those skilled in the art. Such a computer program may be stored in a computer-readable storage medium, readable and executed by a computer, thereby implementing embodiments of the present invention.

It is to be understood that the terms "comprises", "comprising", or "having" as used in the foregoing description mean that a component can be implanted unless specifically stated to the contrary, But should be construed as further including other elements.

The foregoing description is merely illustrative of the technical idea of the present invention, and various changes and modifications may be made by those skilled in the art without departing from the essential characteristics of the present invention. Therefore, the embodiments disclosed in the present invention are intended to illustrate rather than limit the scope of the present invention, and the scope of the technical idea of the present invention is not limited by these embodiments. The scope of protection of the present invention should be construed according to the following claims, and all technical ideas within the scope of equivalents should be construed as falling within the scope of the present invention.

110 ontology and triple assignment,
120 class checking unit,
130 class relation checking part,
140 property test performing unit,
150 Performing Instance Checks.

Claims (10)

An ontology and a triple allocation unit for acquiring and classifying triples from an ontology schema and a model,
A class checking unit for checking the validity of the class,
A class relation check performing unit for checking the validity of the relation between the classes,
A property check performing unit for checking the validity of the property,
Instance check performing unit for checking instance validity
The schema validity and instance validation apparatus comprising: 2. The apparatus of claim 1, wherein the ontology and the triple allocation unit comprise:
The first string of the acquired triple is added to the subject column, the second string is added to the predicate column, the third string is added to the object column, and each triple is added to the class list in a list of one of a class list, a property list, a sub class map, and an instance list. 3. The method of claim 2,
The class checking unit displays T in the error / non-existence column only when the class is indicated in the ontology schema, F in the error case and N in the case of duplication,
The class relation checker displays T only when the relation of the classes is indicated in the ontology schema, F when the relation is an error, and N if it is redundant,
The property check performing unit displays T only when the property is included in the property list (propertyList), displays it as F when the property is not included, and changes the value where the error check column is null to N,
The instance checking unit checks whether the subject is included in the instance list. If the subject is included in the instance list, the instance checking unit displays T or F, and if the predicate is rdf: type and the subject is a class, And changes the value of the error or non-null column to null. The method of claim 3,
The class checking unit receives a subject value of P: rdf: type and O: owl: Class and checks whether the subject is included in the class list (classList) If it does not, enter F, and search for the subject value of P: rdf: type, O: owl: Class, add N to the value where the error-
The class relation checker receives the subject and object value of P: rdf: subClassOf to check whether the subject and object are included in the sub class map (subClassofMap). If the subject and object are included in the sub class map (subClassoMap) If there is no F, enter F, and search for the subject value of P: rdf: type, O: owl: Class, add N to the value where the True column is null,
The property check performing unit receives the subject value having the object owl: ObjectiveProperty and checks whether the subject is included in the property list (propertyList). If it is included, T is input to the error / non-existence column. , P: rdf: type, O: owl: Class, adds N to the value where the error or non-error column is null,
The instance checker receives a subject value of P: rdf: type and checks whether the subject is included in the instance list. If the subject checker is included in the instance list, T is input to the error / non-existence column. , P: rdf: type, and O: owl: Class, and adds N to the value where the error or non-error column is null. 5. The method according to any one of claims 1 to 4,
And outputs a triple when the error or non-error column is not T. A method for verifying schema integrity and instance validity based on a semantic web,
An ontology and a triple allocation step of acquiring and classifying triples from an ontology schema and a model and storing them in corresponding columns,
A class checking step to validate the class,
A class relationship checking step of checking the validity of a relation between the classes,
A property checking step for validating the property,
Instance check step to validate instances
And validating the schema validity and instance validity. 7. The method of claim 6, wherein the ontology and triple allocation step comprises:
The first string of the acquired triple is added to the subject column, the second string is added to the predicate column, the third string is added to the object column, and each triple is added to the class list and the attribute is stored in a list of one of a class list, a property list, a sub class map and an instance list. 8. The method of claim 7,
The class checking step displays T in the error / non-existence column only if the class is indicated in the ontology schema, F in the error case and N in the case of redundancy,
The class relationship checking step displays T only when the relation of the classes is indicated in the ontology schema, F when the relation is an error, N when the relation is overlapped,
The property checking step displays T only when the property is included in the property list (propertyList), F when it is not included, and changes the value where the error or non-error column is null to N,
The instance checking step checks whether the subject is included in the instance list. If the subject is included in the instance list, it is indicated as T or F if the subject is included. Then, the subject is judged as rdf: type, And the value of null or invalid column is changed to null. 9. The method of claim 8,
In the class checking step, a subject value of P: rdf: type and O: owl: Class is received to check whether the subject is included in the class list (classList) If it does not, enter F, and search for the subject value of P: rdf: type, O: owl: Class, add N to the value where the error-
In the class-relationship checking step, the subject and object value of P: rdf: subClassOf are received and it is checked whether the subject and the object are included in the sub class map (subClassofMap). If included, T is entered in the error / If there is no F, enter F, and search for the subject value of P: rdf: type, O: owl: Class, add N to the value where the True column is null,
In the property checking step, the subject is received with a subject value of owl: ObjectiveProperty to check whether the subject is included in the property list (propertyList). If included, T is input to the error / non-existence column. , P: rdf: type, O: owl: Class, adds N to the value where the error or non-error column is null,
In the instance checking step, a subject value of P: rdf: type is received and it is checked whether the subject is included in the instance list (InstanceList). If it is included, T is entered in the error or non-existence column. , P: rdf: type, and O: owl: Class, and adds N to the null or invalid column. 10. The method according to any one of claims 6 to 9,
And outputting a triple when the error or non-error column is not T.
KR1020160158006A 2016-11-25 2016-11-25 Method and apparatus for verifying schema integration and instance validity based on semantic web KR20180058981A (en)

Priority Applications (2)

Application Number Priority Date Filing Date Title
KR1020160158006A KR20180058981A (en) 2016-11-25 2016-11-25 Method and apparatus for verifying schema integration and instance validity based on semantic web
PCT/KR2017/010663 WO2018097467A1 (en) 2016-11-25 2017-09-27 Method and apparatus for verification of schema integrity and instance validity based on semantic web

Applications Claiming Priority (1)

Application Number Priority Date Filing Date Title
KR1020160158006A KR20180058981A (en) 2016-11-25 2016-11-25 Method and apparatus for verifying schema integration and instance validity based on semantic web

Publications (1)

Publication Number Publication Date
KR20180058981A true KR20180058981A (en) 2018-06-04

Family

ID=62196229

Family Applications (1)

Application Number Title Priority Date Filing Date
KR1020160158006A KR20180058981A (en) 2016-11-25 2016-11-25 Method and apparatus for verifying schema integration and instance validity based on semantic web

Country Status (2)

Country Link
KR (1) KR20180058981A (en)
WO (1) WO2018097467A1 (en)

Family Cites Families (5)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
KR100993288B1 (en) * 2008-12-15 2010-11-09 한국과학기술정보연구원 System and Method for Efficient Reasoning Using View in DBMS-based RDF Triple Store
US8484141B2 (en) * 2010-02-02 2013-07-09 International Business Machines Corporation Evaluating ontologies
KR101133993B1 (en) * 2010-11-02 2012-04-09 한국과학기술정보연구원 Method for storing triple for inference verification and steady-increasing inference and apparatus thereof, apparatus for indexing dependency of inference and method for verifying dependency of inference
JP2017521748A (en) * 2014-05-12 2017-08-03 セマンティック・テクノロジーズ・プロプライエタリー・リミテッド Method and apparatus for generating an estimated ontology
KR101664701B1 (en) * 2015-06-12 2016-10-11 한국전력공사 Apparatus and method for verifying validity of cim-xml file

Also Published As

Publication number Publication date
WO2018097467A1 (en) 2018-05-31

Similar Documents

Publication Publication Date Title
Kontokostas et al. Test-driven evaluation of linked data quality
US9582556B2 (en) Automatic generation of an extract, transform, load (ETL) job
CA2779087C (en) Managing record format information
Berry et al. The case for dumb requirements engineering tools
US9547638B2 (en) Data logging for rule specifications
US9613074B2 (en) Data generation for performance evaluation
US8515999B2 (en) Method and system providing document semantic validation and reporting of schema violations
US11397575B2 (en) Microservices graph generation
CN106484739A (en) The structure comparative approach of data base and device
US20160162539A1 (en) Computer executable method of generating analysis data and apparatus performing the same and storage medium for the same
US20230085956A1 (en) System and Method for Semantic Metadata Extensions in API Governance using Validation Rulesets
WO2021022703A1 (en) Software project reconstruction method and device, and computer device and storage medium
Lakshen et al. Challenges in quality assessment of Arabic DBpedia
EP4226240A1 (en) Natural language processing of api specifications for automatic artifact generation
EP3168791A1 (en) Method and system for data validation in knowledge extraction apparatus
KR20180058981A (en) Method and apparatus for verifying schema integration and instance validity based on semantic web
KR102217092B1 (en) Method and apparatus for providing quality information of application
Almendros‐Jiménez et al. Automatic property‐based testing and path validation of XQuery programs
Cherix et al. Lessons learned—the case of crocus: Cluster-based ontology data cleansing
Westphal Quality assurance of RDB2RDF mappings
Borgida et al. Understanding Document Data Sources Using Ontologies with Referring Expressions
Zemmouchi-Ghomari et al. Ontology assessment based on linked data principles
Borgida et al. Accessing Document Data Sources using Referring Expression Types.
Ali Schematron-based Semantic Constraints Specification Framework and Validation Rules Engine for JSON
Dasser et al. Reconciliation of Point-of-Interest Locations on OpenStreetMap

Legal Events

Date Code Title Description
A201 Request for examination
E902 Notification of reason for refusal
E601 Decision to refuse application