RDF和OWL之间的区别是什么?

I am trying to grasp the concept of Semantic Web. I am finding it hard to understand what exactly is the difference between RDF and OWL. Is OWL an extension of RDF or these two are totally different technologies?

我正在努力掌握语义网的概念。我发现很难理解RDF和OWL之间到底有什么区别。OWL是RDF的扩展，还是这两种完全不同的技术?

13 个解决方案

#1

The semantic web comes in layers. This is a quick summary of the ones I think you're interested in.

语义web是分层的。这是对我认为你感兴趣的内容的快速总结。

Update: Please note that RDFS is used to define the structure of the data, not OWL. OWL describes semantic relationships which normal programming, such as a C struct, isn't fussed about and is closer to AI research & set theory.

更新:请注意，RDFS用于定义数据的结构，而不是OWL。OWL描述了正常编程(如C结构)的语义关系，并不是很复杂，更接近人工智能研究和集合理论。

Triples & URIs

三元组和uri

Subject - Predicate - Object

These describe a single fact. Generally URI's are used for the subject and predicate. The object is either another URI or a literal such as a number or string. Literals can have a type (which is also a URI), and they can also have a language. Yes, this means triples can have up to 5 bits of data!

这些描述了一个事实。一般来说，URI是用于主语和谓语的。对象是另一个URI或文本，例如数字或字符串。文字可以有一种类型(它也是一个URI)，而且它们也可以有一种语言。是的，这意味着三元组可以有多达5比特的数据!

For example a triple might describe the fact that Charles is Harrys father.

例如，一个三倍的人可能会说查尔斯是哈利的父亲。

<http://example.com/person/harry> <http://familyontology.net/1.0#hasFather> <http://example.com/person/charles> .

Triples are database normalization taken to a logical extreme. They have the advantage that you can load triples from many sources into one database with no reconfiguration.

三元组是将数据库标准化带到逻辑的极端。它们的优势是，您可以从多个源加载三元组到一个没有重新配置的数据库。

RDF and RDFS

RDF和RDFS

The next layer is RDF - The Resource Description Framework. RDF defines some extra structure to triples. The most important thing RDF defines is a predicate called "rdf:type". This is used to say that things are of certain types. Everyone uses rdf:type which makes it very useful.

下一层是RDF -资源描述框架。RDF为三元组定义了一些额外的结构。RDF定义的最重要的东西是一个称为“RDF:type”的谓词。这是用来说明事物是特定类型的。每个人都使用rdf:类型使它非常有用。

RDFS (RDF Schema) defines some classes which represent the concept of subjects, objects, predicates etc. This means you can start making statements about classes of thing, and types of relationship. At the most simple level you can state things like http://familyontology.net/1.0#hasFather is a relationship between a person and a person. It also allows you to describe in human readable text the meaning of a relationship or a class. This is a schema. It tells you legal uses of various classes and relationships. It is also used to indicate that a class or property is a sub-type of a more general type. For example "HumanParent" is a subclass of "Person". "Loves" is a sub-class of "Knows".

RDFS (RDF Schema)定义了一些表示主题、对象、谓词等概念的类，这意味着您可以开始对类的类和类型的关系进行声明。在最简单的层次上，你可以声明如下:http://familyontology.net/1.0#hasFather是一个人与一个人的关系。它还允许您在人类可读文本中描述关系或类的含义。这是一个模式。它告诉你各种类别和关系的合法用途。它还用于指示类或属性是更通用类型的子类型。例如，“HumanParent”是“Person”的子类。“爱”是“知道”的一个子类。

RDF Serialisations

RDF连载

RDF can be exported in a number of file formats. The most common is RDF+XML but this has some weaknesses.

RDF可以以多种文件格式导出。最常见的是RDF+XML，但它有一些缺点。

N3 is a non-XML format which is easier to read, and there's some subsets (Turtle and N-Triples) which are stricter.

N3是一种更易于阅读的非xml格式，有一些子集(Turtle和N-Triples)更严格。

It's important to know that RDF is a way of working with triples, NOT the file formats.

重要的是要知道RDF是一种处理三元组的方法，而不是文件格式。

XSD

XSD

XSD is a namespace mostly used to describe property types, like dates, integers and so forth. It's generally seen in RDF data identifying the specific type of a literal. It's also used in XML schemas, which is a slightly different kettle of fish.

XSD是一个名称空间，主要用于描述属性类型，比如日期、整数等等。在RDF数据中，通常可以看到特定类型的文字。它也用于XML模式，这是一种略有不同的鱼类。

OWL

猫头鹰

OWL adds semantics to the schema. It allows you to specify far more about the properties and classes. It is also expressed in triples. For example, it can indicate that "If A isMarriedTo B" then this implies "B isMarriedTo A". Or that if "C isAncestorOf D" and "D isAncestorOf E" then "C isAncestorOf B". Another useful thing owl adds is the ability to say two things are the same, this is very helpful for joining up data expressed in different schemas. You can say that relationship "sired" in one schema is owl:sameAs "fathered" in some other schema. You can also use it to say two things are the same, such as the "Elvis Presley" on wikipedia is the same one on the BBC. This is very exciting as it means you can start joining up data from multiple sites (this is "Linked Data").

OWL为模式添加了语义。它允许您指定更多的属性和类。它也用三元组表示。例如，它可以表明“如果A与B结婚”，那么这就意味着“B是结婚的”。或者如果"C isAncestorOf D"和"D isAncestorOf E"那么"C isAncestorOf B"owl补充的另一个有用的东西是，说两件事情的能力是一样的，这对于连接以不同模式表达的数据非常有帮助。您可以说，在一个模式中“sired”关系是owl:sameAs“在其他模式中”。你也可以用它来表示两件事是一样的，比如在*上的“猫王”是同一个人。这非常令人兴奋，因为这意味着您可以开始从多个站点连接数据(这是“链接数据”)。

You can also use the OWL to infer implicit facts, such as "C isAncestorOf E".

你也可以用猫头鹰来推断隐含的事实，比如“C isAncestorOf E”。

#2

In short:

简而言之:

• RDF defines how to write stuff
• RDF定义了如何写东西。
• OWL defines what to write
• OWL定义了要写什么。

As previous poster wrote, RDF is a specification which tells you how to define triples.

正如前面的海报所写，RDF是一个规范，它告诉您如何定义三元组。

The problem is that RDF allows you to define everything, so you could compose a declaration like this:

问题是RDF允许您定义所有东西，因此您可以编写这样的声明:

| subject | predicate | object |
|---------|-----------|--------|
| Alex    | Eats      | Apples |
| Apples  | Eats      | Apples |
| Apples  | Apples    | Apples |

These triples form valid RDF documents.

这些三元组形成有效的RDF文档。

But, semantically, you understand that these statements are incorrect and RDF cannot help you to validate what you have written.

但是，从语义上来说，您理解这些语句是不正确的，RDF不能帮助您验证所写的内容。

This is not a valid ontology.

这不是一个有效的本体。

OWL specification defines exactly what you can write with RDF in order to have valid ontology.

OWL规范明确定义了可以用RDF编写的内容，以便具有有效的本体。

Ontologies can have several properties.

本体可以有多个属性。

Thats why OWL (ver 1) defines several versions like OWL DL, OWL Lite, OWL Full.

这就是为什么OWL (ver 1)定义了几个版本，比如OWL DL, OWL Lite, OWL Full。

#3

RDF, RDFS and OWL are means to express increasingly complex information or knowledge. All of them can be serialised in RDF/XML syntax (or any other RDF serialisation syntax like Turtle or N3 for instance).

RDF、RDFS和OWL是表达日益复杂的信息或知识的手段。它们都可以序列化为RDF/XML语法(或者任何其他RDF序列化语法，比如Turtle或N3)。

These technologies are related and supposed to be interoperable, yet they have different origins that's maybe why the relation between them is complicated to grasp. The choice on one or the other depends on how much complexity the situation you are modelling requires.

这些技术是相互关联的，应该是可互操作的，但它们的起源却不同，这也许就是为什么它们之间的关系是复杂的。选择一个或另一个取决于您所建模的情况需要多少复杂性。

Summary of expressivity

总结表达能力

RDF: Straightforward representation, focused on the instances and on the mapping to their types (rdf:type). It is possible to define custom properties to link data and creating triples. RDF data are queried with SPARQL. Example of RDF serialised in Turtle:

RDF:直截了当的表示，关注于实例和映射到它们的类型(RDF:类型)。可以定义自定义属性来链接数据和创建三元组。RDF数据用SPARQL查询。RDF序列化的例子:

@prefix : <http://www.example.org/> .
:john    rdf:type           :Man .
:john    :livesIn  "New-York" .
:livesIn    rdf:type    rdf:Property .

---

RDFS: Some situations are not easily modelled by RDF alone, it is sometimes interesting to represent more complex relations like subclasses (the type of a type) for example. RDFS provides special means to represent such cases, with constructs like rdfs:subClassOf, rdfs:range or rdfs:domain. Ideally, a reasoner can understand the RDFS semantics and expand the number of triples based on the relations: For instance if you have the triples John a Man and Man rdfs:subClassOf Human then you should generate as well the triple John a Human. Note that this is not possible to do with RDF alone. RDFS data are queried using SPARQL. Example of RDFS serialised in Turtle:

RDFS:有些情况不容易由RDF单独建模，有时候表示更复杂的关系，比如子类(类型的类型)是很有趣的。RDFS提供了特殊的方法来表示这种情况，如RDFS:subClassOf、RDFS:range或RDFS:domain。理想情况下，推理者可以理解RDFS语义，并根据关系扩展三元组的数量:例如，如果您有一个三元组(John a Man和Man RDFS:subClassOf Human)，那么您也应该生成一个人的三重John。注意，这是不可能单独使用RDF的。使用SPARQL查询RDFS数据。RDFS在甲鱼中序列化的例子:

@prefix : <http://www.example.org/> .
:john    rdf:type           :Man .
:Man    rdfs:subClassOf    :Human .
:john    :livesIn  "New-York" .
:livesIn    rdf:type    rdf:Property .
# After reasoning
:john    rdf:type    :Human .

---

OWL: The highest level of expressivity. Relation between classes can be formally modelled based on description logics (mathematical theory). OWL relies heavily on the reasoner, it is possible to express complex constructs such as chained properties for instance or restriction between classes. OWL serves to build ontologies or schema on the top of RDF datasets. As OWL can be serialised as RDF/XML, it is theoretically possible to query it via SPARQL, yet it is much more intuitive to query an OWL ontology with a DL query (which is usually a standard OWL class expression). Example of OWL constructs serialised in Turtle.

猫头鹰:*的表达能力。类之间的关系可以用描述逻辑(数学理论)来正式建模。OWL在很大程度上依赖于推理者，它可以表达复杂的结构，例如在类之间进行实例或限制的链接属性。OWL用于在RDF数据集的顶部构建本体或模式。由于OWL可以被序列化为RDF/XML，理论上可以通过SPARQL查询它，但是用DL查询(通常是标准的OWL类表达式)查询OWL本体更直观。OWL构造的例子，在海龟中序列化。

@prefix : <http://www.example.org/> .
:livesIn    rdf:type    owl:DatatypeProperty .
:Human    rdf:type    owl:Class .
:Man   rdf:type    owl:Class .
:Man    rdfs:subClassOf    :Human .
:John    rdf:type    :Man . 
:John    rdf:type    owl:NamedIndividual .

#4

Firstly, an as has been pointed out before, owl can be serialised in RDF.

首先，正如前面所指出的，owl可以序列化为RDF。

Secondly, OWL adds ontological capability to RDF (which on its own only provides extremely limited capability for formal knownledge representation), by providing the apparatus to define the components of your triple using formal computable first order description logic. That is what posters here mean by when they talk about "semantic richness".

其次，OWL将本体功能添加到RDF(它本身仅为正式的知识表示提供了极其有限的功能)，通过提供设备来定义您的三重使用的组件，使用正式的可计算的一阶描述逻辑。这就是海报的含义，当他们谈论“语义丰富”的时候。

Thirdly, it's important to realise that in OWL-Full (for OWL 1) rdfs:class and owl:class are equivalent and in OWL-DL, owl:class is a subclass of rdfs:class. In effect, this means that you can use an OWL ontology as a schema for RDF (which does not formally require schemata).

第三，在OWL- full (OWL 1) rdfs:class和OWL:类是等价的，在OWL- dl中，OWL:类是rdfs的子类:类。实际上，这意味着您可以使用OWL本体作为RDF的模式(它不正式需要schemata)。

I hope that helps to clarify further.

我希望这有助于进一步阐明。

#5

I personally found this slide deck quite useful and understandable: http://www.slideshare.net/rlovinger/rdf-and-owl

我个人觉得这个幻灯片很有用，可以理解:http://www.slideshare.net/rlovinger/rdf-and-owl。

#6

RDFS allows you to express the relationships between things by standardizing on a flexible, triple-based format and then providing a vocabulary ("keywords" such as rdf:type or rdfs:subClassOf) which can be used to say things.

RDFS允许您通过对一种灵活的、基于第三方的格式进行标准化来表达事物之间的关系，然后提供一个词汇表(“关键字”，例如rdf:type或RDFS:subClassOf)，它可以用来表示事情。

OWL is similar, but bigger, better, and badder. OWL lets you say much more about your data model, it shows you how to work efficiently with database queries and automatic reasoners, and it provides useful annotations for bringing your data models into the real world.

猫头鹰很相似，但更大，更好，更坏。OWL允许您更详细地介绍您的数据模型，它向您展示了如何高效地使用数据库查询和自动推理器，并为将数据模型引入到现实世界提供了有用的注释。

1st Difference: Vocabulary

Of the differences between RDFS and OWL, the most important is just that OWL provides a far, far larger vocabulary that you can use to say things.

在RDFS和OWL之间的区别中，最重要的是OWL提供了一个更大的词汇表，您可以用它来表达事情。

For example, OWL includes all your old friends from RDFS such as rdfs:type, rdfs:domain, and rdfs:subPropertyOf. However, OWL also gives you new and better friends! For example, OWL lets you describe you data in terms of set operations:

例如，OWL包括来自RDFS的所有老朋友，比如RDFS:type、RDFS:domain和RDFS:subPropertyOf。然而，猫头鹰也给你新的和更好的朋友!例如，OWL允许您以集合操作的方式描述您的数据:

Example:Mother    owl:unionOf     (Example:Parent, Example:Woman)

It lets you define equivalences across databases:

它允许您跨数据库定义相等性:

AcmeCompany:JohnSmith  owl:sameAs    PersonalDatabase:JohnQSmith

It lets you restrict property values:

它允许您限制属性值:

Example:MyState     owl:allValuesFrom     (State:NewYork, State:California, …)

in fact, OWL provides so much new, sophisticated vocabulary to use in data modeling and reasoning that gets its own lesson!

事实上，OWL提供了这么多新的、复杂的词汇表，用于数据建模和推理，得到了自己的教训!

2nd Difference: Rigidity

Another major difference is that unlike RDFS, OWL not only tells you how you can use certain vocabulary, it actually tells you how you cannot use it. By contrast, RDFS gives you an anything goes world in which you can add pretty much any triple you want.

另一个主要的区别是，与RDFS不同的是，OWL不仅告诉您如何使用特定的词汇，它实际上告诉您如何使用它。相比之下，RDFS给您提供了一个可以添加任意三倍的东西的世界。

For example, in RDFS, anything you feel like can be an instance of rdfs:Class. You might decide to say that Beagle is an rdfs:Class and then say that Fido is an instance of Beagle:

例如，在RDFS中，您想要的任何东西都可以是RDFS的实例:类。你可能会说Beagle是一个rdfs:类，然后说Fido是Beagle的一个实例:

Example: Beagle    rdf:Type    rdfs:Class

Example:Fido    rdf:Type    Example: Beagle

Next, you might decide that you would like to say things about beagles, perhaps you want to say that Beagle is an instance of dogs bred in England:

接下来，你可能会想说关于小猎犬的事，也许你想说小猎犬是在英格兰长大的狗的例子:

Example:Beagle    rdf:Type    Example:BreedsBredInEngland

Example: BreedsBredInEngland    rdf:Type    rdfs:Class

The interesting thing in this example is that Example:Beagle is being used as both a class and an instance. Beagle is a class that Fido is a member of, but Beagle is itself a member of another class: Things Bred in England.

本例中有趣的事情是:Beagle被用作类和实例。Beagle是Fido的成员，但是Beagle本身就是另一个类的成员:在英国长大的东西。

In RDFS, all this is perfectly legal because RDFS doesn't really constrain which statements you can and cannot insert. In OWL, by contrast, or at least in some flavors of OWL, the above statements are actually not legal: you're simply not allowed to say that something can be both a class and an instance.

在RDFS中，所有这一切都是完全合法的，因为RDFS并没有真正约束您可以和不能插入的语句。相比之下，在OWL中，或者至少在某些类型的OWL中，上述语句实际上是不合法的:您不能说某些东西可以同时是类和实例。

This is then a second major difference between RDFS and OWL. RDFS enables a free-for-all, anything goes kind of world full of the Wild West, Speak-Easies, and Salvador Dali. The world of OWL imposes a much more rigid structure.

这是RDFS和OWL之间的第二个主要区别。RDFS支持一个*的世界，任何东西都是充满了狂野西部、地下酒吧和萨尔瓦多·达利(Salvador Dali)的世界。猫头鹰的世界结构更加严格。

3rd Difference: Annotations, the meta-meta-data

Suppose that you've spent the last hour building an ontology that describes your radio manufacturing business. During lunch, your task is to build an ontology for your clock manufacturing business. This afternoon, after a nice coffee, your boss now tells you that you'll have to build an ontology for your highly profitable clock-radio business. Is there a way to easily reuse the morning's work?

假设您花了最后一个小时构建了一个描述您的无线电制造业务的本体。在午餐期间，您的任务是为您的时钟制造业务构建一个本体。今天下午，在喝了一杯好咖啡之后，你的老板告诉你，你必须为你高利润的时钟收音机业务建立一个本体论。是否有一种方法可以方便地重用早晨的工作?

OWL makes doing things like this very, very easy. Owl:Import is what you would use in the clock-radio situation, but OWL also gives you a rich variety of annotations such as owl:versionInfo, owl:backwardsCompatibleWith, and owl:deprecatedProperty, which can easily be used link data models together into a mutually coherent whole.

猫头鹰做的事情非常非常简单。Owl:导入是在clock-radio环境中使用的，但是Owl也提供了丰富的注释，比如Owl: versionInfo、Owl: backwardsCompatibleWith和Owl: deprecatedProperty，它可以很容易地将链接数据模型组合成一个相互协调的整体。

Unlike RDFS, OWL is sure to satisfy all of your meta-meta-data-modeling needs.

与RDFS不同，OWL肯定能够满足所有元数据建模需求。

Conclusion

OWL gives you a much larger vocabulary to play with, which makes it easy to say anything you might want to say about your data model. It even allows you to tailor what you say based on the computational realities of today's computers and to optimize for particular applications (for search queries, for example.) Further, OWL allows you to easily express the relationships between different ontologies using a standard annotation framework.

OWL为您提供了一个更大的词汇表，这使得您可以很容易地对您的数据模型说些什么。它甚至允许您根据当前计算机的计算现实和优化特定应用程序(例如搜索查询)来定制您所说的内容。此外，OWL允许您使用标准的注释框架轻松地表达不同本体之间的关系。

All these are advantages as compared to RDFS, and are typically worth the extra effort it takes to familiarize yourself with them.

所有这些都是与RDFS相比的优点，并且通常值得您为熟悉它们而付出额外的努力。

Source : RDFS vs. OWL

来源:RDFS与OWL。

#7

RDF is a way to define a triple 'subject','predicate', 'value'. For example, if I want to say,

RDF是一种定义三重“主语”、“谓词”、“值”的方法。例如，如果我想说，

"my name is Pierre"

“我的名字叫皮埃尔”

I would write

我将会写

<mail:[e-mail]> <foaf:name> "Pierre"

See the <foaf:name> ? it is part of the FOAF ontology. An ontology is a formal way to describe the properties, the classes of a given subject and OWL is a (RDF) way to define an ontology.

看< foaf:name >吗?它是FOAF本体的一部分。本体是描述属性的正式方法，给定主题和OWL的类是定义本体的一种(RDF)方法。

You use C++, Java, etc... to define a Class, a subclass, a field, etc...

使用c++、Java等…定义一个类、一个子类、一个字段等等。

class Person
{
    String email_as_id;
    String name;
}

RDF uses OWL to define these kinds of statements.

RDF使用OWL来定义这些类型的语句。

Another place to ask this kind of question: http://www.semanticoverflow.com/

另一个问这个问题的地方是:http://www.semanticoverflow.com/。

#8

I am trying to grasp the concept of Semantic Web. I am finding it hard to understand what exactly is the difference between RDF and OWL. Is OWL an extension of RDF or these two are totally different technologies?

我正在努力掌握语义网的概念。我发现很难理解RDF和OWL之间到底有什么区别。OWL是RDF的扩展，还是这两种完全不同的技术?

In short, yes you could say that OWL is an extension of RDF.

简而言之，是的，你可以说OWL是RDF的扩展。

In more detail, with RDF you can describe a directed graph by defining subject-predicate-object triples. The subject and the object are the nodes, the predicate is the edge, or by other words, the predicate describes the relation between the subject and the object. For example :Tolkien :wrote :LordOfTheRings or :LordOfTheRings :author :Tolkien, etc... Linked data systems use these triples to describe knowledge graphs, and they provide ways to store them, query them. Now these are huge systems, but you can use RDF by smaller projects. Every application has a domain specific language (or by DDD terms ubiquitous language). You can describe that language in your ontology/vocabulary, so you can describe the domain model of your application with a graph, which you can visualize show it to business ppl, talk about business decisions based on the model, and build the application on top of that. You can bind the vocab of your application to the data it returns and to a vocabulary known by the search engines, like microdata (for example you can use HTML with RDFA to do this), and so search engines can find your applications easily, because the knowledge about what it does will be machine processable. This is how semantic web works. (At least this is how I imagine it.)

更详细地说，使用RDF，您可以通过定义主题-谓词-对象三元组来描述一个有向图。主语和宾语是节点，谓语是边缘，也就是说谓语描述主语和宾语之间的关系。例如:托尔金:写着:洛尔多夫斯或:洛尔多夫斯:作者:托尔金，等等……关联数据系统使用这些三元组来描述知识图，并提供存储它们的方法，查询它们。现在这些都是巨大的系统，但是您可以通过较小的项目来使用RDF。每个应用程序都有一个特定于领域的语言(或者DDD术语通用语言)。您可以在您的本体/词汇表中描述该语言，因此您可以用图形来描述应用程序的域模型，您可以将其可视化显示给business ppl，讨论基于模型的业务决策，并在此基础上构建应用程序。你可以将词汇的应用程序绑定到的数据返回和词汇的搜索引擎,像微数据(例如您可以使用HTML与RDFA这么做),所以搜索引擎可以很容易地找到您的应用程序,因为它将机器可处理的知识。这就是语义网的工作原理。(至少我是这么想的。)

Now to describe object oriented applications you need types, classes, properties, instances, etc... With RDF you can describe only objects. RDFS (RDF schema) helps you to describe classes, inheritance (based on objects ofc.), but it is too broad. To define constraints (for example one kid per chinese family) you need another vocab. OWL (web ontology language) does this job. OWL is an ontology which you can use to describe web applications. It integrates the XSD simpleTypes.
So RDF -> RDFS -> OWL -> MyWebApp is the order to describe your web application in a more and more specific way.

现在，要描述面向对象的应用程序，您需要类型、类、属性、实例等等。使用RDF，您只能描述对象。RDFS (RDF schema)帮助您描述类、继承(基于c的对象)，但是它太宽了。要定义约束(例如每个中国家庭的一个孩子)，您需要另一个vocab。OWL (web本体语言)完成这项工作。OWL是一种可以用来描述web应用程序的本体。它集成了XSD simpletype。所以RDF -> RDFS -> OWL -> MyWebApp是一种以更具体的方式描述你的web应用程序的命令。

#9

When you are using the term RDF you have to distinguish two things:

当你使用RDF这个术语时你必须区分两件事:

1. You can refer to RDF as a concept:

   您可以将RDF看作一个概念:

   A way of describing things/logic/anything using collections of triples.

   用三元组来描述事物/逻辑/任何东西的一种方法。

   Example:

   例子:

   "Anna has apples." "Apples are healthy."

   “安娜苹果。”“苹果是健康的。”

   Above you have two triples that describe two resources "Anna" and "apples". The concept of RDF (Resource Description Framework) is that you can describe resources (anything) with sets of only 3 words (terms). At this level you don't care about how you are storing information, whether you have a string of 3 words, or a painting on a wall, or a table with 3 columns etc.

   上面有两个三元组描述两个资源“Anna”和“苹果”。RDF(资源描述框架)的概念是，您可以用3个词(术语)来描述资源(任何东西)。在这个层次上，你不关心你是如何存储信息的，你是否有一个3个单词的字符串，或者墙上的画，或者一个有3个列的表格等等。

   At this conceptual level the only thing that is important is that you can represent anything that you want using triple statements.

   在这个概念层次上，唯一重要的是你可以用三重陈述来表示任何你想要的东西。

2. You can refer to RDF as a vocabulary

   您可以将RDF称为词汇表。

   A vocabulary is just a collection of term definitions stored in a file or somewhere. These defined terms have the purpose of being generally reused in other descriptions so people can describe data (resources) more easily and in a standard manner.

   词汇表只是存储在文件或某个地方的术语定义的集合。这些定义的术语的目的是在其他描述中重用，这样人们就可以更容易地以标准的方式描述数据(资源)。

   On the web you can find some standard vocabularies like:

   在网上你可以找到一些标准的词汇:

   RDF (https://www.w3.org/1999/02/22-rdf-syntax-ns)

   RDF(https://www.w3.org/1999/02/22-rdf-syntax-ns)

   RDFS (https://www.w3.org/2000/01/rdf-schema#)

   RDFS(https://www.w3.org/2000/01/rdf-schema)

   OWL (https://www.w3.org/2002/07/owl)

   猫头鹰(https://www.w3.org/2002/07/owl)

   The RDF vocubalary defines terms that help you to describe (at the most basic level as possible) individuals/instances of classes. Example: rdf:type, rdf:Property.

   RDF vocubalary定义了一些术语，它们帮助您描述(在最基本的级别上)类的个体/实例。例如:rdf:type,rdf:财产。

   With rdf:type you can describe that some resource is an instance of a class:

   使用rdf:您可以描述一些资源是类的实例:

    <http://foo.com/anna> rdf:type <http://foo.com/teacher> 
   

   So the RDF vocabulary has terms that are targeting basic descriptions of class instances and some other descriptions (like the triple statement definition, or the predicate definition... in general things that are realted to the RDF concept).

   因此，RDF词汇表有针对类实例的基本描述和一些其他描述(如三重语句定义或谓词定义)的术语。一般来说，这些都是RDF概念。

   The RDFS vocabulary has term definitions that help you describe classes and relationships between them. RDFS vocabulary doesn't care about instances of classes (individuals) like the RDF vocabulary. Example: the rdfs:subClassOf property which you can use to describe that a class A is subclass of class B.

   RDFS词汇表有术语定义，可以帮助您描述它们之间的类和关系。RDFS词汇表并不关心类的实例(个人)，比如RDF词汇表。示例:rdfs:subClassOf属性，您可以用它来描述a类是B类的子类。

   The RDF and the RDFS vocabularies are dependent to one another. RDF defines it's terms using RDFS, and RDFS uses RDF for defining it's own terms.

   RDF和RDFS词汇表相互依赖。RDF用RDFS定义它的术语，RDFS使用RDF定义它自己的术语。

   The RDF/RDFS vocabularies provide terms that can be used to create very basic descriptions of resources. If you want to have more complex and accurate descriptions you have to use the OWL vocabulary.

   RDF/RDFS词汇表提供了可以用来创建对资源的基本描述的术语。如果你想要更复杂和准确的描述，你必须使用OWL词汇。

The OWL vocabulary comes with a set of new terms targeting more detailed descriptions. These term are defined using terms from RDF/RDFS vocabularies.

OWL词汇附带了一组新的术语，目标是更详细的描述。这些术语是使用RDF/RDFS词汇表定义的。

owl:ObjectProperty a rdfs:Class ;
                   rdfs:label "ObjectProperty" ;
                   rdfs:comment "The class of object properties." ;
                   rdfs:isDefinedBy <http://www.w3.org/2002/07/owl#> ;
                   rdfs:subClassOf rdf:Property .

owl:DatatypeProperty a rdfs:Class ;
                     rdfs:label "DatatypeProperty" ;
                     rdfs:comment "The class of data properties." ;
                     rdfs:isDefinedBy <http://www.w3.org/2002/07/owl#> ;
                     rdfs:subClassOf rdf:Property .

 owl:TransitiveProperty a rdfs:Class ;
                        rdfs:label "TransitiveProperty" ;
                        rdfs:comment "The class of transitive properties." ;
                        rdfs:isDefinedBy <http://www.w3.org/2002/07/owl#> ;
                        rdfs:subClassOf owl:ObjectProperty .

As you can see above the OWL vocabulary extends the concept of rdf:Property by creating new types of Properties that are less abstract and can provide more accurate descriptions of resources.

正如您在OWL词汇表中看到的，扩展了rdf的概念:通过创建不那么抽象的新属性类型，可以提供更准确的资源描述。

Conclusions:

结论:

1. RDF is a concept or a way of describing resources using sets of triples.
2. RDF是一种使用三元组来描述资源的概念或方法。
3. RDF triples can be stored in different formats (XML/RDF, Turtle etc.)
4. RDF三元组可以以不同的格式存储(XML/RDF、Turtle等)。
5. The concept of RDF is the base model of all semantic web technologies and structures (like vocabularies).
6. RDF的概念是所有语义web技术和结构(如词汇表)的基础模型。
7. RDF is also a vocabulary that along with the RDFS vocabulary provides a set of terms that can be used for creating general/abstract descriptions of resources.
8. RDF也是一个词汇表，与RDFS词汇表一起提供了一组术语，可用于创建资源的一般/抽象描述。
9. OWL is a vocabulary built with RDF and RDFS vocabularies that provide new terms for creating more detailed descriptions of resources.
10. OWL是用RDF和RDFS词汇表构建的词汇表，它们为创建更详细的资源描述提供了新的术语。
11. All semantic web vocabularies (RDF, RDFS, OWL etc) are built by respecting the RDF concept.
12. 所有语义web词汇(RDF、RDFS、OWL等)都是通过尊重RDF概念构建的。
13. And of course the OWL vocabulary has behind the scenes all kind of complex logic and concepts which define the Web Ontology Language. The OWL vocabulary is just a way of using all that logic in practice.
14. 当然，OWL词汇背后隐藏着各种复杂的逻辑和概念，它们定义了Web本体语言。OWL词汇只是在实践中使用所有逻辑的一种方式。

#10

In the WC3 document object model, a document is an abstract thing: an element with text, comments, attributes, and other elements nested within it.

在WC3文档对象模型中，文档是一个抽象的东西:包含文本、注释、属性和嵌套在其中的其他元素的元素。

In the semantic web, we deal with a set of "triples". Each triple is:

在语义web中，我们处理一组“三元组”。每个三元组是:

• a subject, the thing the triple is about, the id, the database primary key - a URI; and
• 一个主题，三倍的东西，id，数据库主键，一个URI;和
• the predicate, the "verb", the "property", the "database column" - another URI; and
• 谓词、“谓词”、“属性”、“数据库列”——另一个URI;和
• the object, an atomic value or some URI.
• 对象，一个原子值或一些URI。

OWL is to the semantic web as Schemas are to the W3C document object model. It documents what the various URIs mean and specify how they are used in a formal way that can be checked by a machine. A semantic web may or may not be valid with respect to the OWL that applies to it, just as a document may or may not be valid with respect to a schema.

OWL对于语义web来说就像模式对于W3C文档对象模型一样。它记录了各种uri的含义，并指定了如何以一种正式的方式使用它们，从而可以通过机器进行检查。语义web可能或可能不适用于适用于它的OWL，就像文档可能或可能对模式无效一样。

RDF is to the semantic web as XML is to the DOM - it's a serialisation of a set of triples.

RDF对于语义web来说就像XML对于DOM一样——它是一组三元组的序列化。

Of course, RDF is usually serialised as an XML documents ... but it's important to understand that RDF is not the same thing as "the XML serialisation of RDF".

当然，RDF通常被序列化为XML文档……但重要的是要理解RDF与“RDF的XML序列化”不一样。

Likewise, OWL can be serialised using OWL/XML, or (sorry about this) it can be expressed as RDF, which itself is usually serialised as XML.

同样，OWL可以使用OWL/XML进行序列化，或者(不好意思)可以表示为RDF，它本身通常是序列化为XML的。

#11

The basic semantic web stack has been explained a lot already in this thread. I'd like to focus on the initial question and compare RDF to OWL.

基本的语义web栈已经在这个线程中得到了大量的解释。我想集中讨论最初的问题，并将RDF与OWL进行比较。

• OWL is a super-set of RDF & RDF-S (on top)
• OWL是一组超集RDF和RDF- s(在顶部)
• OWL allows to effectively working with RDF & RDF-S
• OWL允许有效地使用RDF和RDF- s。
• OWL has some extended vocabulary
  • classes & individuals ("instances")
  • 类和个人(“实例”)
  • properties & data-types ("predicates")
  • 属性和数据类型(谓词)
• OWL拥有一些扩展的词汇表类和个人(“实例”)属性和数据类型(“谓词”)
• OWL is required for proper reasoning and inference
• 正确推理和推理需要猫头鹰。
• OWL comes in three dialects lite, description logic & full
• 猫头鹰有三种方言，描述逻辑和饱满。

Using OWL is essential to get more meaning (reasoning & inference) by just knowing a few facts. This "dynamically created" information can further be used for accordant queries like in SPARQL.

使用OWL是获得更多的意义(推理和推理)的关键，通过了解一些事实。这种“动态创建的”信息可以进一步用于类似SPARQL的协调查询。

Some examples will show that that actually works with OWL - these have been taken from my talk about the basics of semantic web at the TYPO3camp Mallorca, Spain in 2015.

一些例子表明，这实际上与OWL有关——这些都是我在2015年西班牙马略卡(Mallorca)的网站上从我关于语义网的基础知识的讨论中获得的。

equivalents by rules

Spaniard: Person and (inhabitantOf some SpanishCity)

This means that a Spaniard must be a Person (and thus inherits all properties in the inferencing part) and must live in at least one (or more) SpanishCity.

这意味着西班牙人必须是一个人(因此继承了推断部分的所有属性)，并且必须生活在至少一个(或更多)西班牙城市。

meaning of properties

<Palma isPartOf Mallorca>
<Mallorca contains Palma>

The example shows the result of applying inverseOf to the properties isPartOf and contains.

该示例展示了应用逆函数的结果，并将其包含在属性isPartOf中。

• inverse
• 逆
• symmetric
• 对称的
• transitive
• 传递
• disjoint
• 不相交的
• ...
• …

cardinalities of properties

<:hasParent owl:cardinality “2“^^xsd:integer>

This defines that each Thing (in this scenario most probably a Human) has exactly two parents - the cardinality is assigned to the hasParent property.

这定义了每个东西(在这个场景中很可能是一个人)恰好有两个父节点——将基数分配给hasParent属性。

• minimum
• 最低
• maximum
• 最大
• exact
• 确切的

#12

The Resource Description Framework (RDF) is a powerful formal knowledge representation language and a fundamental standard of the Semantic Web. It has its own vocabulary that defines core concepts and relations (e.g., rdf:type corresponds to the isA relationship), and a data model that enables machine-interpretable statements in the form of subject-predicate-object (resource-property-value) triples, called RDF triples, such as picture-depicts-book. The extension of the RDF vocabulary with concepts required to create controlled vocabularies and basic ontologies is called RDF Schema or RDF Vocabulary Description Language (RDFS). RDFS makes it possible to write statements about classes and resources, and express taxonomical structures, such as via superclass-subclass relationships.

资源描述框架(Resource Description Framework, RDF)是一种强大的形式知识表示语言，是语义Web的基本标准。它有自己的词汇表来定义核心概念和关系(例如，rdf:类型与isA关系相对应)，以及一种数据模型，它能够以主语-谓词-对象(resource-property-value)三元组的形式(称为rdf三元组)(如图片-描述-book)的形式提供机器可解释的语句。RDF词汇表的扩展需要创建受控词汇表和基本本体，这被称为RDF Schema或RDF词汇描述语言(RDFS)。RDFS可以编写关于类和资源的语句，并表示分类结构，比如通过超类-子类关系。

Complex knowledge domains require more capabilities than what is available in RDFS, which led to the introduction of OWL. OWL supports relationships between classes (union, intersection, disjointness, equivalence), property cardinality constraints (minimum, maximum, exact number, e.g., every person has exactly one father), rich typing of properties, characteristics of properties and special properties (transitive, symmetric, functional, inverse functional, e.g., A ex:hasAncestor B and B ex:hasAncestor C implies that A ex:hasAncestor C), specifying that a given property is a unique key for instances of a particular class, and domain and range restrictions for properties.

复杂的知识领域需要比RDFS中可用的更多的功能，这导致了OWL的引入。OWL支持类之间的关系(联盟,十字路口,剥离,等价)财产基数约束(最小值,最大值,确切数字,例如,每个人都有一个父亲),丰富的属性,输入的特征属性和特殊属性(逆函数传递、对称、功能,例如,例:hasAncestor B和B例:hasAncestor C意味着,例:hasAncestor C),指定一个给定的属性是一个独特的关键一个特定类的实例,和领域和范围限制属性。

#13

The best answer is to read the book from one of the pioneers of Semantic Web itself "The Semantic Web for working Ontologists", by James Hendler. If you are looking for a quick crash course. Check this udemy course:

最好的答案是，由詹姆斯·亨德勒(James Hendler)将这本书从语义网的先驱之一“语义网”中读出来。如果你正在寻找速成速成课程。检查这udemy课程:

https://www.udemy.com/semantic-web/?couponCode=HALFOFF

https://www.udemy.com/semantic-web/?couponCode=HALFOFF