OWL - Science topic

Probably completion in a real world application is a strongly domain depending task. And starting from the fact that I am not aware of the specific knowledge represented here, I would speculate that OWL should be a good option, considering that its deductive capabilities can help in completion, at least by obtaining new items, not explicitly defined, and preserving the consistence, by regularly checking.

Can be argued that complexity will be a concern when rising the graph order/size, but you always can easily move from and OWL to other representation, keeping those nodes/edges obtained by deduction. On the other hand, you could consider apply "light weight ontology languages", but it's always depending on domain.

I suggest to be a bit more descriptive, and, BTW, include other keywords, like graph completion, in order to attract the attention the related to the problem specialists.

Hi Carsten,

not sure about most "convincing" and what it means. In the sense of practicality or impact? It is also a vast domain, including manufacturing, digital twins, biology, medicine (there are many biomedical ontologies for example from bigger taxonomic structures to simple domain ontologies, obo foundry), research knowledge graphs etc.

In my project we build a knowledge base of systems and electronic engineering. Including means of ontology, reasoning, a distributed database, expert system, and constraint propagation.

One of the applications is to make estimations and predictions of future systems, and interactively explore different configurations, structures of systems, solution spaces and properties while simultaneously considering the system context. An example is looking at the effects the tweaking of neural net parameters might have.

This is just one example from what we do.

The state is often ontologies are developed by few specialized experts and often not reused by others, leaving them hanging, or siloed and just used for a personalized project. Then others do not want to share of their own knowledge or do not connect to the other graph. At least this seems to be two aspects of what I can see it.

Knowledge Graph Construction looks promising. I am currently looking into the boundaries and how it might scale. Also considering the quality of the constructed graph regarding the commitment to an ontology or proper semantic structures in general.

But I agree, overall outwardly it looks shy in comparison to the ML hype. There seem to be a couple of reasons which are multi-faceted. It was also discussed on one of the last ISWC conferences.

FYI I recently came across one workshop covering this theme/topic:

Greetings, and have a nice day!

-Frank

hi,

The W3C Web Ontology Language (OWL) is a Semantic Web language designed to represent rich and complex knowledge about things, groups of things, and relations between things.

OWL Full allows free mixing of OWL with RDF Schema and, like RDF Schema, does not enforce a strict separation of classes, properties, individuals and data values. OWL DL puts constraints on the mixing with RDF and requires disjointness of classes, properties, individuals and data values.

Kindly refer this link:

Best wishes..

Check this book :

@ Thanks for your reply. While "Python is just another language" it has from my experience some advantages which make it favorable in a scientific context:

- possibility of interactive usage (e.g. via Jupyter-Notebooks)

- plenty of science-relevant libraries (numpy, sympy, pytorch, ...)

- comparatively low entrance barrier to getting started (e.g. for undergraduate-students from subjects other than computer science)

To prevent misunderstandings: I do not claim that Python is the perfect language. It definitely has weaknesses (such as execution speed).

My point is: If there were more (and better supported) python-tools for semantic-related tasks available and the existing ones were better known, this would significantly foster the development and the applicability of semantic technologies such as ontologies, reasoners and rule-processors.

I expect the scientific world would benefit from such a development because suitable management of available knowledge is one of its core-challenges and having more and easier tools available to tackle that challenge would consequently result in more and better research results.

Even if we discount for "hype-factor": Machine Learning (or numerical AI) techniques have had tremendous success (both in quality and quantity) in many research disciplines and Python-based libraries and interfaces take a large part of the credit for that. I think a similar development could happen with semantic technologies (aka symbolic AI).

Dear Researcher,

Please refer to the below links for GeoNetwork Metadata plugins @ OWL Resources. I think this might be helpful.

https://trac.osgeo.org/geonetwork/wiki/rdfstore

Dear João Guimarães

This article using SKOS tool might be helpful, have a look:

Hope this helps.

Kind Regards

Qamar Ul Islam

Thank You Luis Ramos I will definitely read this article.

Dear Abdul Sattar

You may read the article below, which I think can help you . Please, if still interested, send me an email by RG, since it is in private mode due to copyright.

Sincerely,

Luis

I realize this is an old question but in case you are looking for a resource for future classes, I’ve just completed a new version of the Pizza tutorial. It has everything that the original one did plus it has been updated to be consistent with the latest Protége UI. I also added new sections to address concepts and tools such as IRIs, SPARQL, SWRL, SHACL, etc. The latest version can be found on my blog at: https://www.michaeldebellis.com/post/new-protege-pizza-tutorial

Frank Haferkorn Thanks, I will read it and try it.

You may use code generation functionality to generate code. It will generate at least a skeleton of the code which can be converted to a working code by inserting instances.

This link maybe useful for you:

http://ceur-ws.org/Vol-576/paper1.pdf

Dear Sir,

I have the same problem. Have you solved it yet?, please help me!

Thanks in advance!

I met the same problem. Could you please tell me do you have the solution now?

Dear all,

our team experienced the same issues you mentioned (e.g. lack of availability of easy to use OWL libraries outside Java or Python); we also had strict requirements w.r.t. memory usage and computational resources in general, which are not really the main focus of most available OWL implementations.

Since no tool met our necessities, we recently built our own OWL library, named Cowl: http://sisinflab.poliba.it/swottools/cowl

It is a C API for working with OWL 2 ontologies, which focuses on portability, memory efficiency and performance. It is open source and free to use. Contributions are, of course, welcome!

Additional resources are on Youtube; enter barry smith ontology into the search field.

If I can remember.

To get x that is a subclass of y.

SELECT ?x ?y

WHERE { ?x rdfs:subClassOf ?y.

?x rdf:type owl:Class. ## or rdfs:Class??

}

To get object property of ?x

SELECT ?x ?y ?p ?q

WHERE { ?x rdfs:subClassOf ?y.

?x ?p ?q.

?p rdf:type owl:ObjectProperty.

}

Sometimes, we don't have to specify every constraint. For example, the above. You don't have to specify ?x rdf:type owl:Class ...because it exists already with subclass property.

I don't know this helps you or not. I don't use SPARQL for many years.

Best wishes.

You should start from stating which OWL You will be using for modelling ontology - 1.0 or 2.X, which will determine language expressivity. In other words I switched from OWL 1.0 to 2.0 due to the fact that I can combine DL and FOL constructs which in many cases saves the day for my solutions reasoning paths. Additionally with DL You cannot infer object properties (connect two individuals with object property using reasoner). If You use OWL 2.0 RL You will be able to extend capabilities of Your constructors which will enrich much of the reasoning capabilities.

Morning Markus,

Jena is a really good framework: often updated, many tools such as TDB (Triple Store) or Fuseki (Endpoint), wide community, ...

In particular, OntModel class in Jena does specify that you work with an Ontology Model (OWL structured) and allows reasoning.

You then need to choose if you want to work with a live server (TDB/Fuseki) coupled with a reasoner or reasoning on temporary OntModel (Ontology API) is enough in your favorite IDE.

About reasoners that are easilly implentable in Jena: Openllet is a good one (https://github.com/Galigator/openllet).

Kind regards,

Hasna, hi.

The behaviour you are observing is because (guessing from the variable names in your code fragment) you are accessing the ontology through a reasoner. This means that you are getting inferred statements in addition to the explicit statements you see when you edit the ontology file. In your particular example, note these axioms in the People Ontology: Class: people:cat_liker EquivalentTo: people:person and (people:likes some people:cat) ObjectProperty: people:has_pet SubPropertyOf: people:likes Class: people:cat_owner EquivalentTo: people:person and (people:has_pet some people:cat) which force any instance of cat_ower to be by necessity also an instance of cat_liker. In other words, the reasoner can prove that cat_ower is a subclass of cat_liker, so the OWL API also returns this result. Similarly: Class: people:pet_owner EquivalentTo: people:person and (people:has_pet some people:animal) Class: people:cat SubClassOf: people:animal forces any instance of cat_ower to be by necessity also an instance of pet_owner, so pet_owner is also added to the superclasses of cat_owner. If you want to get explicit subClassOf statements only, use the subClassAxiomsForSubClass() property of the OWLOntology object, not a reasoner object. Hope this helps, Stasinos

Hi,

There is another issue here: the code that you are using is retrieving only the explicitly asserted subclassOf relations (that's why when you use Protegé to assert them, you can retrieve them). If you want to retrieve the inferred taxonomy, you should use a reasoner, and work with the OWLReasoner instead (or along with) of the OWLOntology. The DL reasoner infers the actual hierarchy that the ontology is modeling, and allows you to navigate through it . 

If you want to generate an ontology from a Database and have the ability to store semantics on your data stored in the Database, then ONTOP is your tool. I recommend it.

Best regards.

You can start with this video tutorial titled "Simple Protege Introduction". https://www.youtube.com/playlist?list=PLea0WJq13cnAfCC0azrCyquCN_tPelJN1

You can get more detailed information from Protege support page, http://protege.stanford.edu/support.php. There are several documents, and you can start with Ontology Development 101, then WebProtégé User's Guide and also Protégé OWL Tutorial.

Thanks for the explanation of the situation. It is a shame, because your studies are still actual. On other side, thank you for pooling of various studies about owls ecology on one place. Best wishes.

Have you considered owl:unionOf to define a class extension that contains all individuals of the class descriptions in the list? For example:

Note that owl:unionOf is not part of OWL Lite.

Basically, the selection  depends on what you expect of a fuzzy ontological model and fuzzy reasoning. There are tools (I think referenced in https://www.researchgate.net/publication/260514203_Application_of_Fuzzy_Ontological_Reasoning_in_an_Implementation_of_Medical_Guidelines) that incorporate membership functions into the model and support a number of fuzzy operators.

However, another approach (presented in the mentioned paper) is possible. It consists in using plain OWL and adding datatype property (weight) supporting membership level. However, such approach has a number of consequences:

The paper shows that it is possible to encode Mamdani rules with SWRL and combine Jena and Pellet to implement a FIS. See also attached sildes: https://www.researchgate.net/publication/263083436_SLIDES_-_Application_of_Fuzzy_Ontological_Reasoning_in_an_Implementation_of_Medical_Guidelines

Best regards

A good question, but I'm not sure how many experts are around in ResearchGate. Maybe there is a mailing list around the OWL eCl@ss effort where more experts are listening.

what is the depth and complexity of your ontology. is it a high level ontology or just few say 5 to 4 classes in it? 

In the near past I've used Jena to integrate a set of SWRL rules (pre-authored in Protege 3.4.4) for artificial intelligent and automated reasoning mechanisms. The programming language was -once more- Java and the only prerequisite was to include the Pellet reasoner. Both Apahe Framework and Pellet (now on GitHub) have extensive tutorials and examples, so give it a try instead of using PHP which has limited, or not at all, support in Semantic Web area...

Hello with owl-api jar and PelletReasoner

first you import : org.semanticweb.owlapi.model.OWLDataProperty;

and uses this code

OWLOntologyManager manager = OWLManager.createOWLOntologyManager();

OWLOntology ontology = manager.loadOntologyFromOntologyDocument (new File (file));

// DataProperty

OWLDataProperty name = manager.getOWLDataFactory().getOWLDataProperty(IRI.create("URI_of your DataProperty "));

// Ind contains information about the individual (and all other individuals that were inferred to be the same)

OWLNamedIndividual ind = sameInd.getRepresentativeElement();

// get the info about this specific individual: dataProperty

Set<OWLLiteral> names = reasoner.getDataPropertyValues( ind, name );

  //  we can get the value directly

String nameInd = names.iterator().next().getLiteral();

I hope that is usful

I presume you are using protege, rather than jena library/OWL API directly. Have you tried with the export (all inferred axioms) option? or u just saved the file after running reasoner?

For me it worked setting 1GB in run.bat

jre\bin\java.exe -Xmx1G -Dlog4j.configuration=file:log4j.xml -DentityExpansionLimit=100000000 -Dfile.encoding=utf-8 -Dorg.protege.plugin.dir=plugins -classpath bin/felix.jar;bin/ProtegeLauncher.jar org.protege.osgi.framework.Launcher

then it loaded successfully the ontology.

However in Win32 systems the JVM can not use more than 1.4GB as documented in this note by Oracle

What do you mean by reasoning? sparql can be used for some kind of reasoning purpose.

Pellet has implemented a spatial reasoner but there is no so many spatial reasoner available

The OGC Geo Spaql standard is not only about querying is also the definition of property and class that can be used to described spatial information.

 you should follow the work of a  team  of

Manolis Koubarakis,

Kostis Kyzirakos

about stSPARQLand stRDF data.

Hello Simon,

Although ontologies are in essence OWA, they are described as a set of restrictions. IMO the concrete language ( OWL ) may perfectly describe CWA. The question is an interpretation. Obviously reasoners are based on OWA and because this is the only correct way to work with ontologies, getting CWA is a hard task.

In my OWL2XS tool I had to make a lot of logical querying based on negation to get CWA. The simplest example is: Monkeys have a tail and they are mammals. Do humans have a tail? In the OWA they "might". Any OWA reasoner will return an existential quantification hasTail for both mammals and humans unless you specifically negate it. To check CWA one should explicitly try to negate it for the class and this is very computationally intensive.

Probably more interesting would be to create a CWA reasoner - it should be very close to an OWL parser!

So my answer yes you can. Nothing prevents to see your ontology as a closed world.

The question is in which scenario would we need it? In my case I was interested in Web services generation (XML).

Kind regards,

Dmitry

Median,

First of all, Protege does not show by default all the inferences that you may be interested in seeing, but you can easily activate different inference types through the Reasoner->Configure... menu (in your case you want to check the "Domains" and "Ranges" checkboxes under the "Displayed Object Property Inferences" section).

Second, although I am not a logics expert I think, that the answer to your first and second question is in fact "No", that is why I believe Protege does not show them, even if you activate the domain and range inferences in the configuration. Here is my reasoning, in case of your first question:

Although you correctly infer that 

whatever x is, if hasCar(x, y) => driver (x) => human(x),

x will still belong to the subset of those members of the human class that are also members of the driver class (i.e. they will never be member of the complement of the driver class, such as the non-driver humans - which BTW, I think is a inappropriate modeling in your example, since we know that non-driver persons can own a car in reality), and as such the the domain of the hasCar property will remain the driver class and cannot be extended to the entire human class. If you would say, for the sake of the argument, that there is no human that cannot drive (i.e. the human class is equivalent  with the driver class), than protege would show that the domain of the hasCar property is not just driver but also human.

Same reasoning goes for the range in your second question.

The answer to your third question is "True", but possibly not for the reasons that you would think of. The key statement that produce that inference are the range/domain statements, not the subclass relationship between audiCar and car. 

You may wonder why this inferable statement is not shown in Protege, even if you check all the possible reasoner configuration options. Simply, because there are infinite number of statements that can be entailed from an ontology, and Protege shows only a certain subset of those, which are commonly of interest to people who are building or using an ontology.  And this particular type of inference did not fall in that category.

However, if you write this statement into the DL Query plugin, and you check the "Equivalent classes" checkbox, you will see that driver class is returned as an equivalent class to the "driver hasAudiCar min 1 car" expression, and you can even get a nice explanation of why this is the case, if you click on the question mark on the right of the driver class in the query results.

I hope this helps.

The connections refers to instantiations of some concepts related to other ontologies (ex: FOAF) in your ontology.

You can filter the classes defined in SUMO by just analysing the URIs prefixes. 

I hope that I was clear and helpful.

Sumo is available in KIF here:

Hi Mona,

Linked Open Vocabularies (LOV) is great initiative when you are looking for existing ontologies that describe certain concept. You could simply search for a certain class or property and get links to the matched ontologies as a result .

The links usually contain descriptions of the classes and properties of an ontology as well as file in OWL, RDF or other Semantic Web/LOD standard format of the ontology that you could easily convert to OWL (if necessary) using online converters for instance.

Hope you'll find this useful,

Bojan

Dear Paul, thank you for sharing the manual. What is problem with your attachment but I could not get it. By any why, I used this file name to search in google and found the manual. It seems some different the gel casting there and should be used a bag to close well the bottom side.

You can think of  OWL 2 DL as a *syntactically* restricted version of OWL 2 Full. Yes there are certain language constructs that will allow you to tell what OWL a certain ontology falls under.

Take a look at the following:

Hi, look at this other Q/A:

Piotr Szwed · 14.08 · 4.36 · AGH University of Science and Technology in Kraków

RDFS offers taxonomic relations, object relations and datatype properties.

OWL has richer vocabulary and is more expressive:

with OWL it is possible to specify cardinalities of object relations and datatype properties (attributes)

it is possible to use logical opeartors in definitions (e.g. use union of classes as a range of relation)

For details you should compare specifications, e.g.:

  Enayat Rajabi · 6.98 · 3.89 · University of Alcalá 

Briefly, ontology gives you more facilities to define objects and their semantic relationships, while RDFS schema is about defining the Data structure. By RDFS, you can create your data hierarchy and their properties. Instead, in ontology you can say e.g., if A is a subclass of B, what are the other relationships of A to B? and to other classes? A good example could be, defining a sameAs relationship between objects which specified two objects that are semantically related.

Any case, this link may help: http://www.cambridgesemantics.com/semantic-university/rdfs-vs.-owl

There is a rather large body of work which looks at quality of ontologies, particularly in the biomedical domain but not exclusively. 

For a tool you can just use there is the OntoOops online system: slides and link to online tool in slides: http://www.eudat.eu/system/files/MariaPovedaVillalon.pdf  It looks for common issues with ontologies and flags them giving you an idea of quality.

Jeremy Rogers' early work on medical ontology quality: http://www.ncbi.nlm.nih.gov/pubmed/16685334

on concepulization quality: 

and on activity levels as a metric:

and many more...

Enterprise Integration Patterns is a good start: http://www.enterpriseintegrationpatterns.com/toc.html

Typically you are looking at Remote invocation, Distributed Tracking, Discovery protocols and Message etc. 

Entries in my database on Identification and Long-eared Owl:

Baker, K. (1983): Guide to ageing and sexing non-passeriformes (part. 7). Ringer's Bulletin 6: 45.

Baker, K. (1993): Identification guide to European non-passerines. British Trust for Ornithology, Norfolk.

Gálvez, R. A., L. Gavashelishvili & Z. Javakhishvili (2005): Raptors and owls of Georgia. Georgian Centre for the Conservation of Wildlife and Buneba Print Publishing, Tbilisi.

Martínez Climent, J. A., Í. Zuberogoitia Arroyo & R. A. Moreno (2002): Rapaces Nocturnas. Guía para la determinación de la edad y el sexo en las Estrigiformes ibéricas. Monticola, Madrid.

Mikkola, H. & J. Lamminmäki (2014): Moult, Aging and Sexing of Finnish Owls.

This paper may be of interest:

Causes of admissions to a raptor rehabilitation centre in KwaZulu-Natal, South Africa

LJ Thompson, B Hoffman, M Brown - African Zoology, 2013

SPARQL 1.1 supports querying over inferred data (e.g., with RDFS/OWL) using an extension called entailment regimes. Further information can be accessed at http://www.w3.org/TR/2013/REC-sparql11-entailment-20130321

Dear Luis, Thanks for your recommendation !

Best Regards

The Oracle Database Comes With Triple Stores And SPARQL Querying And Inferencing Support Starting From Version 11a Onwards... Thats Your Best Place To Start...

I just uploaded the datasets we used for the attached paper. You should be able to access them via that publication link.

Is the TBox complexity relevant for your experiment? If it has to be a specific TBox, it might be necessary to write your own instance generator that populates the ontology exactly the way you want it. (Often not all classes / properties need to be populated explicitly.)

The ontology can be saved on the disk or memory.  Then, you have to use what we call a triplestore.  The later is a database management system for RDF triples.  After that, you can query the database which is composed of Ontology + instances.  A triplestore contains also a set of reasoning systems.   The list of available triplestore can be found in :

RDFS offers taxonomic relations, object relations and datatype properties.

OWL has richer vocabulary and is more expressive:

For details you should compare specifications, e.g.:

 

Thank you all for your helpful suggestions. I found ARC 2 - An Easy RDF and SPARQL for LAMP systems to expose the endpoints.

(https://github.com/semsol/arc2/wiki )

As the rest of our system was build using LAMP, PHP and MqSQL getting ARC2 working with the rest of the system was very easy. You can try our end point at

This is an agriculture knowledgebase for farmers.

Our Agriculture Ontology was developed using protege. We find it takes a very long time to populate it with NamedIndividual.

Does anyone know a better method to add large number of NamedIndividuals to an ontology developed with protege ?

I've been using OWLAPI for a long time and I cannot understand what is your concern. For example, I've been working with Snomed ontology (~290.000 concepts), and I've haven't had any memory issues with OWLAPI ...

Note that ontologies are more oriented to capture and model the intensional dimension of the data (the schema), instead of the actual data. I recommend you to read the works on the OWL-DL Lite segment, which allows to handle the T-BOX in memory, while storing and handling the A-BOX in an external database, providing you the scalability you might be looking for. You might find the works by Diego Calvanese and Mariano Rodríguez Muro on Query rewriting useful .

Another approach you could use would be to handle the ontology with the OWLAPI and have the instances stored in a RDF repository, such as Virtuoso.