The concept of the Semantic Web was proposed by Tim Berners Lee, the inventor of the World Wide Web, in 1996. The goal is to convert current information into machine-friendly language. The Semantic Web is not an independent network, but an extension of the current network. It empowers The clear meaning of information makes it possible to share and reuse information, and computers and people can work better together. Simply put, it is known as the repository of information and the language involved in expressing that information. The architecture of the Semantic Web is shown in Figure 1.
- Data layer. XML, which represents extensible markup language consisting of namespaces and schemas, is used to define data structures on the web; Resource Description Framework (RDF), which is used to describe information in the form of a data model, which is composed of three It consists of three parts: subject, predicate and attribute.
- Mode layer. Resource Description Framework Schema (RDFS) serves as a vocabulary language for representing and inferring RDF data models.
- Logical layer. Web Ontology Language (OWL) helps to create semantic web applications and realize the sharing and reuse of information. It is defined as a set of terms used to describe a given domain and draw inferences from it, and can use reasoning Systematic reasoning.
XMLOverview
XML (eXtensible Markup Language) is a markup language designed for documents containing structured and semi-structured information. XML has become the de facto standard for data representation and exchange on the Web, and is an effective way to share data between applications or machines. XML’s Extensibility is the most basic feature that distinguishes XML from other markup languages. Itscore lies in establishing the structure of data representation in a standardized way, leaving the definition of specific tags to user.
However, XML cannot interpret the meaning of its tags, and XML schema can only verify the grammatical legality of XML, but cannot distinguish differences in meaning between XML attributes and elements. Therefore, for the same information content, we can map it into many different XML structures. At the same time, there can be many different interpretations of the same XML structure, and the same application may also make the same interpretation of different XML. explain.
Example:
This XML example describes a library containing three books. Each book has information such as title, author, year of publication, and genre. This information is marked as XML elements and represented by corresponding tags.
<?xml version="1.0" encoding="UTF-8"?>
<library>
<book>
<title>The Catcher in the Rye</title>
<author>J.D. Salinger</author>
<year>1951</year>
<genre>Fiction</genre>
</book>
<book>
<title>To Kill a Mockingbird</title>
<author>Harper Lee</author>
<year>1960</year>
<genre>Fiction</genre>
</book>
<book>
<title>1984</title>
<author>George Orwell</author>
<year>1949</year>
<genre>Fiction</genre>
</book>
</library>
RDFand RDF.schema Overview
The upper layer of the XML layer is the data interoperability layer – Resource Description Framework (RDF) and RDF.schemas. RDF itself does not specify semantics, but it provides each resource description system with the ability to have a semantic structure that can describe its specific requirements. In this sense, RDF is an open metadata framework. This metadata framework defines a data model that describes machine-understandable data semantics. The data model mainly contains the following three object types:
(1) Resources: Resources may be an entire web page; a part of a web page; or an entire collection of pages; or an object that cannot be directly accessed through the web.
(2) Properties: Properties describe specific aspects, characteristics, attributes or relationships of a resource.
(3) Statements: A specific resource and attribute name plus the value of the attribute together constitute an RDF statement.
The three parts of a statement are called: subject, predicate, and object. Essentially,RDF defines object-property-value triples as basic modeling primitives and introduces a standard syntax for them. As shown in the following example:
The above example declares the fact that the author (predicate) of http://www.faqs.org/rfcs/rfc2396.html (subject) is Tim Berners-Lee (object). However, all RDF provides are some very basic modeling primitives. For example, the above example does not clarify what constraints the word author should have (author should be a person) and the fact that Tim Berners-Lee is the name of the author. To describe such facts, more primitives that can express semantics are needed. The RDF Schema specification further defines modeling primitives using RDF. The main classes, characteristics and constraints in RDFS are as follows:
(1) Core categories. Including rdfs:Resource, rdf:Property and rdfs:Class. All things described by RDF expressions are regarded as instances of rdfs:Resource. rdf:Property is a class used to describe all characteristics of rdfs:Resource instances. Finally, rdfs:Class is used to define concepts in RDFS.
(2) Core features. Including rdf:type, rdfs:subClassOf and rdfs:subPropertyOf.
The rdf:type relationship models the instance-of relationship between resources and classes.
The rdfs:subClassOf relationship establishes a hierarchical model of inclusion between classes.
The rdfs:subPropertyOf relationship models the inclusion hierarchical relationship between properties.
(3) Core constraints. Including rdfs:ConstraintResource, rdfs:ConstrainProperty, rdfs:range and rdfs:domain.
rdfs:ConstraintResource defines the classes for all constraints.
rdfs:ConstraintProperty is a subset of rdfs:ConstraintResource and rdf:Property, which includes all properties used to define constraints.
Specifically, rdfs:ConstraintResource can be used to define the following properties:
-
rdfs:domain: used to specify the domain of a certain attribute, that is, which resources the attribute can be applied to.
-
rdfs:range: used to specify the value range of an attribute, that is, what values the attribute can take.
The RDF.schema mechanism provides a basic type system used in RDF models. This type system is somewhat similar to object-oriented programming languages. From the perspective of Description Logic (DL), RDFS is equivalent to TBox (Terminology Box), and RDF is equivalent to ABox (Assertion Box). RDF and RDFS jointly describe the structure used by the previous facts. as the picture shows.
ABox and TBox are two important components of the knowledge base (Knowledge Base). They play different roles in knowledge representation and reasoning.
TBox:
- TBox is a collection of terms that defines the structure of a specific knowledge field and contains the general attributes of concepts and relationships, also called connotative knowledge. In TBox, it usually includes axioms such as the definition of concepts and the inclusion relationships of concepts. For example, the knowledge “a bird is an animal” belongs to TBox.
- TBox reflects the classification or hierarchical structure of knowledge and can form new concepts through existing concepts. For example, through the two concepts of “quick sort” and “selection sort”, we can form an upper-level concept “sort”.
ABox:
- ABox is a collection of assertions, which contains information about specific individuals and is a set of axioms about specific individual facts, also called extensional knowledge. In ABox, instance assertions and relationship assertions are included. For example, the knowledge “Pigeons are a kind of bird” and “Pigeons can fly” belong to ABox.
- ABox reflects the attributes and relationships of specific individuals. It usually contains some specific factual knowledge. This knowledge is often accidental and depends on a specific environment, so it changes frequently.
Simply put, a TBox is a structured part of knowledge that defines the general nature of concepts and relationships. ABox is the instantiation part of knowledge, which contains the attributes and relationship information of specific individuals. Together, these two parts form a complete knowledge base for representing and reasoning about domain-specific knowledge.
Example:
This RDFS instance defines relationships between classes, subclasses, attributes, and individuals through XML syntax. It shows how to use RDFS to build a simple vocabulary and describe individuals and their relationships through RDF.
<?xml version="1.0"?>
<rdf:RDF
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
xmlns:ex="http://example.org/vocabulary#"
>
<!-- Define class -->
<rdfs:Class rdf:ID="Person">
<rdfs:comment>A person is an individual human being.</rdfs:comment>
</rdfs:Class>
<!-- Define subclasses -->
<rdfs:Class rdf:ID="Student">
<rdfs:subClassOf rdf:resource="#Person"/>
<rdfs:comment>A student is a person who studies at an educational institution.</rdfs:comment>
</rdfs:Class>
<!-- Define attributes -->
<rdfs:Property rdf:ID="name">
<rdfs:domain rdf:resource="#Person"/>
<rdfs:range rdf:resource="rdf:Literal"/>
<rdfs:comment>The name of a person.</rdfs:comment>
</rdfs:Property>
<!-- Define individuals -->
<rdf:Description rdf:about="http://example.org/John">
<rdf:type rdf:resource="#Person"/>
<ex:name>John Doe</ex:name>
</rdf:Description>
<rdf:Description rdf:about="http://example.org/Alice">
<rdf:type rdf:resource="#Student"/>
<ex:name>Alice Smith</ex:name>
</rdf:Description>
</rdf:RDF>
1.<?xml version="1.0"?>: Specify the XML version as 1.0.
2.<rdf:RDF ...>: The root element of RDF, used to contain all RDF statements.
3.xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#": Defines the URI of the RDF namespace.
4.xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#": Defines the URI of the RDFS namespace.
5.xmlns:ex="http://example.org/vocabulary#": Define a custom namespace URI for the attributes and classes in the example.
6.<rdfs:Class rdf:ID="Person">: Define a class named "Person".
7.<rdfs:comment>...</rdfs:comment>: Provide comments for classes or attributes.
8.<rdfs:subClassOf rdf:resource="#Person"/>: Define the "Student" class as a subclass of the "Person" class.
9.<rdfs:Property rdf:ID="name">: Define a property named "name".
10.<rdfs:domain rdf:resource="#Person"/>: Specify the domain of the "name" attribute as the "Person" class.
11.<rdfs:range rdf:resource="rdf:Literal"/>: Specify the range of the "name" attribute as literal type.
12.<rdf:Description rdf:about="http://example.org/John">: Define a description about the individual "John".
13.<rdf:type rdf:resource="#Person"/>: Specify the type of "John" individual as "Person".
14.<ex:name>John Doe</ex:name>: Set the value of the "name" attribute to "John Doe" for the "John" individual.
RDF describes resources and relationships between resources through attributes and values, but does not provide a mechanism for describing these attributes and relationships between attributes. RDF.Schema provides this expression mechanism, which describes the usage rules of properties in RDF, defines a domain dictionary for RDF, and organizes the dictionary with a type hierarchy to form a complete semantic space. The RDF data model is essentially an expression of a binary relationship. Since any complex relationship can be decomposed into multiple simple binary relationships, the RDF data model can be used as the basic model for any other complex relationship model.
RDF.schema not only provides a simple machine-understandable semantic model, but also provides a modeling basis for domain-based ontology languages, and allows RDF-based applications to be easily merged with ontologies generated by these ontology languages. This feature of RDF makes the semantic description results based on RDF have the ability to interact with more domain knowledge, and also makes the Web data description based on XML and RDF have good vitality.
The combination of XMLand RDF and its shortcomings
RDF and XML are complementary to each other. First, RDF hopes to standardize the semantics of XML in a standardized and interoperable way. XML documents can reference RDF in a simple way. With RDF, XML descriptions expressing the same fact can be transformed into a unified RDF statement. The combination of XML and RDF can not only achieve semantic-based description of data, but also give full play to the respective advantages of XML and RDF, facilitating the retrieval of Web data and the discovery of related knowledge.
Both XML and RDF can provide certain semantics for the resources they represent. An example is: XML can use “
The RDF model does not have the ability to solve these two problems. Although RDF.Schema can provide a vocabulary for the attributes and types of RDF resources, there may still be semantic conflicts in the semantic description of data based on RDF (the semantic expression capabilities provided by RDF.Schema It is still weak, for example, it cannot clearly distinguish between instances, concepts and meta-ontologies, there is no reference model, and it cannot do Boolean operations, algebraic operations, etc.). In order to solve the above two problems, it is natural to introduce Ontology. Ontology determines the precise meaning of concepts through strict definitions of concepts and the relationships between concepts, representing commonly recognized and shareable knowledge. For Ontology, Author, Creator and Writer are the same concept, while Doctor represents two concepts respectively in universities and hospitals. Therefore, Ontology plays a very important role in the Semantic Web and is the basis for solving Web information sharing and exchange at the semantic level.
OWLOverview
Web Ontology Language OWL (Web Ontology Language) is a language for defining ontologies on the Web. It is an improved revised version that combines DAML + OIL application experience. It is based on RDF and uses XML as a writing tool. Mainly designedto express knowledge information that needs to be processed and manipulated by computer applications. This knowledge information is usually contained in files, such as RDF files. The information in these files is not intended to be directly presented to humans for reading and understanding, but is intended to be read, parsed, reasoned and manipulated by computer programs. OWL can clearly express the meaning of each entry in the vocabulary and the relationship between them. This expression is called ontology. Compared with XML, RDF and RDF.Schema, OWL has more mechanisms to express semantics, so OWL transcends the ability of XML, RDF and RDF.Schema to only express the content of machine-readable documents on the Internet. OWL ontology describes a domain in terms of classes, attributes, and individuals, and can contain rich descriptions of the characteristics of these objects. OWL makes it possible to describe concepts, but it also provides new capabilities. It has a richer set of operators such as intersection, union, and negation. It is based on different logical models that make it possible to define and describe concepts. Therefore, complex concepts can be built into definitions rather than simple concepts. Furthermore, logical models allow the use of reasoners that can check whether all statements and definitions in the ontology are consistent with each other, and can also identify which concepts fit which definitions. Helps maintain hierarchies correctly.
OWL is divided into three sub-languages based on description capabilities: OWL Lite, OWL DL, and OWL Full. The corresponding functions are introduced as follows:
(1) OWL Lite: For users who only need a classification level and simple attribute constraints.
(2) OWL DL: Supports users who need maximum expression on a reasoning system that can guarantee computational completeness and determinability. It includes all constraints of the OWL language, but can be placed under only specific constraints.
(3) OWL Full: Supports users who need maximum expression on syntax-free RDF without computational guarantees. It allows an ontology to add vocabulary to a predefined (RDF, OWL) vocabulary, so that no inference software can support all features of OWL FULL.
The main considerations for users when choosing which language to use are:
(1) When using OWL, the choice between OWL Lite and OWL DL depends on the user’s needs for expressive capabilities. If the user only needs a simple ontology description and does not need too many complex structures and reasoning functions, then OWL Lite may be enough. But if the user needs more expressive capabilities and more complex structures, then OWL DL should be chosen.
(2) The choice between OWL DL and OWL Full mainly depends on the user’s needs for meta-modelling tools. If users need to perform meta-modeling of RDF schema, such as defining classes of classes or attaching attributes to classes, then they need to select OWL Full. Because these functions are not supported in OWL DL.
(3) Compared with OWL DL, when using OWL Full, the predictability of reasoning support is poor, because there is currently no complete implementation of OWL Full, so for complex ontologies and reasoning tasks, using OWL Full may lead to unpredictability. Predicted results. Therefore, if predictability and stability are key factors for the user, OWL DL should be preferred.
The relationship between these three sub-languages and RDF is:
(1) OWL Full can be regarded as an extension of RDF;
(2) OWL Lite and OWL Full can be regarded as a constrained RDF extension;
(3) All OWL documents (Lite, DL, Full) are an RDF document;
(4) All RDF documents are OWL Full documents;
(5) Only some RDF documents are legal OWL Lite and OWL DL documents.
references:
[1] Lin Longcheng. Research on the overview and construction methods of OWL ontology in the Semantic Web [J]. Computer Knowledge and Technology, 2020, 16(12): 203-204.
[2] Li Jianjiang, Zhang Chunhui. Progress in ontology research and its application [J]. Library Forum, 2004, (06): 80-86.
[3] Zhu Lijun, Tao Lan, Huang Chi. Concepts, methods and applications of the Semantic World Wide Web [J]. Computer Engineering and Applications, 2004, (03): 79-83 + 119.
[4] Deng Zhihong, Tang Shiwei, Zhang Ming, Yang Dongqing, Chen Jie. Review of Ontology research [J]. Journal of Peking University (Natural Science Edition), 2002, (05): 730-738.
The knowledge points of the article match the official knowledge files, and you can further learn related knowledge. Algorithm skill tree Home page Overview 57177 people are learning the system