The definition of Semantic Web according to Tim Berners-Lee, the inventor of World Wide Web
is: “The extension of the current web in which information is given well-defined meaning, better
enabling computers and humans to work in cooperation.”
Semantic Web is the abstract representation of data on the World Wide Web, based on the RDF (Resource Description
Framework) standards and other standards to be defined. This is being developed by the W3C (World Wide Web Consortium),
with participations from academic researchers and industrial partners. Data can be defined and linked in such a way so
that there is more effective discovery, automation, integration, and reuse across different applications.
The majority of today’s World Wide Web’s content is designed for humans to read and understand, not for machines and computer
programs to manipulate meaningfully. Computers can adeptly parse Web pages for layout and routine processing but, in general,
machines have no reliable way to process the semantics. The Semantic Web will bring structure to the meaningful content
of Web pages, where software agents roaming from page to page or from site to site can readily carry out automated sophisticated
tasks for users.
The Semantic Web is an extension of the World Wide Web, in which information is given well-defined meaning, better enabling
computers and people to work in cooperation. The first steps in incorporating the Semantic Web into the structure of the
existing Web are already under way. In the near future, these developments will roll out significant new functionality as
machines become much better able to process and understand the data that the Web merely displays at present. To date, the Web
has developed most rapidly as a medium for documents for humans rather than for data and information that can be processed
automatically. If you want something from the Web, then you have to do it manually. I take the context of “manual” to mean
that if you want to look for specific information or a product to buy from the internet, for example buying a book, then you
must sit at your computer searching most popular online bookstores through categories of titles that match what you want.
The Semantic Web aims to make up for this manual dependency (users should rely on software to do the task autonomously), and it
will be decentralized as much as possible, just like the Internet.
The key to the development of Semantic Web is Machine Intelligence. Other terms that are frequently used interchangeably
with Machine Intelligence are, Machine Learning, Computational Intelligence, Soft-Computing and Artificial Intelligence.
Although the five terms are used interchangeably by industries and academics, they are different branches to the researchers
who are involved in these fields. Artificial Intelligence involves symbolic computation while Soft-Computing involves
intensive numeric computation.
The following sub-branches of Machine Intelligence (mainly symbolic Artificial Intelligence) that are being addressed for Semantic Web:
- Knowledge Acquisitions and Representations
- Agent Systems ( or MAS – Multi Agent Systems)
Although symbolic Artificial Intelligence is currently built and developed into Semantic Web data representation, there
is no doubt that software tool vendors in the future and also software developers will incorporate the Soft-Computing paradigm
into it. The benefits and advantages that Soft-Computing adds to symbolic Artificial Intelligence is that it makes software
applications (systems) adaptive. This means that Soft-Computing program (software) will deal and adapt to would be unforeseen
input that it was (were) not built into it. This is in contrast to the non-adaptive nature of the pure symbolic
Artificial Intelligence which it cannot deal or adapt to unforeseen input (stimuli).
There are a number of related Machine Intelligence JSRs (Java Specification Request) in the JCP (Java Community Process) with two are
currently in public review. These JSRs are listed below:
- Java Rule Engine API : JSR-94 (Public Review : 11th September , 2002)
- Java Agent Services API : JSR-87 (Public Review : 19th May , 2002)
- Java Data Mining API : JSR-73 (Community Draft Ballot : 24th June , 2002)
As can be seen from the above list, it is only a small domain in the area of Machine Intelligence that is being extended as JSRs
in the JCP. The list is expected to grow in the future as new related Machine Intelligence JSRs will be proposed to the JCP.
Different disciplines of Machine Intelligence which have existed for over fifty years were successfully applied in different areas of
software applications, and it is only now that they are being applied to the internet in such extension as the Semantic Web. New
branches of Machine Intelligence are being constantly developed .
Knowledge Acquisitions and Representations
Knowledge Acquisition is defined as the extraction of knowledge from different sources of information. Examples
are: the extraction of knowledge from a human expert on a specific domain (such as a doctor, lawyer, or financial advisor),
extracting trading rules from a stock exchange database or extracting linguistic rules from a linguistic database and so on.
Knowledge Representation is defined as the expression of knowledge in computer-tractable form, so that it can be used
to help software-agents perform well. Software Agents (also called Softbot as opposed to Robot which is a mechanical device)
are a software (programs) that perceive its environment through sensors and acts upon that environment through
effectors. A Knowledge Representation language is defined by two aspects:
- Language Syntax: This describes the possible configurations that can constitute sentences.
- Semantics: This determines the facts in the world to which the sentences refer. Without semantics, a sentence
is just an arrangement of words, or sequence of marks on a print page, that has no meaning. For example, the sentence
“David is going to town” has a meaning, semantic or a fact. Without semantic, the sentence can equivalently be
stated as “town to going is David” or “going to David is town” which has no meaning at all in English. Therefore,
with semantics, each sentence makes a claim about the world.
For the Semantic web to function computers must have access to structured collections of information and sets of
inference rules that they can use to conduct automated reasoning. Traditional knowledge-representation systems typically
have been centralized, requiring everyone to share exactly the same definition of common concepts such as “fruit” or “vehicle.”
But central control is stifling, and increasing the size and scope of such a system rapidly becomes unmanageable. These systems
usually carefully limit the questions that can be asked so that the computer can answer (reasonably) reliably- or answer at
all. In avoiding such problems, traditional knowledge-representation systems generally each had their own narrow and
idiosyncratic set of rules for making inferences about their data. For example, a genealogy system, acting on a database
of family trees, might include the rule “a wife of an uncle is an aunt.” Even if the data could be transferred from one
system to another, the rules, existing in a completely different form, usually could not.
Semantic Web provides a language that expresses both data and rules for reasoning about the data and that allows
rules from any existing knowledge-representation system to be exported onto the Web. eXtensible Markup Language (XML)
and the Resource Description Framework (RDF) are important technologies for developing the Semantic Web. XML lets
everyone create their own tags-hidden labels such as Web pages or sections of text on a page. Scripts and programs
can make use of these tags in sophisticated ways, but the script writer has to know what the page writer uses each
tag for. XML allows users to add arbitrary structure to their documents but says nothing about what the structures
mean. The meaning is expressed by RDF, which encodes it in sets of triples, each one being rather like the subject,
verb and object of an elementary sentence. These triples can be written using XML tags. In RDF, a document makes
assertions that particular things (fruit, Web pages, movies and so on ) have properties such
as “is a type of” – Orange is a type of fruit or “is a kind of” – Die Hard is a kind of action movie,
with certain values (Orange, Action). This sort of structure turns out to be a natural way to describe
the vast majority of the data processed by machines. Subject and object are each identified by a Universal
Resource Identifier (URI), just as used in a link on a Web page. (URLs, Uniform Resource Locators, are
the most common type of URI.) The verbs are also identified by URIs, which enables anyone to define a
new concept, a new verb, just by defining a URI for it somewhere on the Web. The triples of RDF form webs
of information about related things. Because RDF uses URIs to encode this information in a document, the
URIs ensure that concepts are not just words in a document but are tied to a unique definition that everyone
can find on the Web.
Knowledge Engineering is defined as the: “Selecting of a Logic for building Knowledge-Base Systems, with the
implementation of the Proof Theory and also the Inference of new Facts”. Thus Knowledge Engineering specifies
what is true, and the inference procedure figures out how to turn the facts into a solution. Since a fact is true
regardless of what task one is trying to solve, knowledge bases can in principle, be reused for a variety of different
tasks without modification, and this is in sharp contrasts to procedural programming where a slight modification
requires a recompilation of the program. Thus Knowledge Engineering has a declarative approach.
Agent-based software engineering makes all sorts of systems and resources interoperable by providing an interface
based on first-order logic. An important step in the development of a knowledge-base is to decide on a vocabulary
of predicates, functions and constants, example, should Size be a function or a predicate? Would Bigness be a better
name than Size? Should Small be a constant or a predicate? Once the choices have been made, the result is a vocabulary
known as Ontology. Thus an Ontology is a document or file of vocabularies that formally define the relations among
terms. The most typical kind of ontology for the Web has a taxonomy and a set of inference rules.
The taxonomic hierarchy defines classes of objects and relations among them. Taxonomies have been used explicitly for
centuries in technical fields. For example, systematic biology aims to provide a taxonomy of all living and extinct
species; library science has developed a taxonomy of all fields of knowledge, encoded as Dewey Decimal systems; tax
authorities and other government departments have developed extensive taxonomies of occupations and commercial products.
First-order logic (FOL) is defined as a general-purpose representation language that is based on an ontological
commitment to the existence of objects and relations in the world. FOL makes it easy to state facts about categories,
either by relating objects to the categories or by quantifying over their members, for example:
- An object is a member of a category : Tomato2 is an element of category of Tomatoes.
- A category is a subclass of another category : Tomatoes is a subset of Category Fruit.
- All members of a category have some properties: For all X , where X is an element
of categories Tomatoes , there implies that there are Red Tomatoes and also Round Tomatoes.
- A category as a whole has some properties: Tomatoes is an element of DomesticatedSpecies.
Since Tomatoes is a category, and is a member of DomesticatedSpecies, then DomesticatedSpecies must be a category
of categories. One can have categories of categories of categories, but they are not much use. Although subclass and
instance relations are the most important ones for categories, there is a need to be able to state relations between
categories that are not subclasses of each other. Example, if you say that Males and Females are subclasses of Animals,
then you have not said that a male cannot be a female. If two or more categories have no members in common, they are
The ontologies on the Web range from large taxonomies categorizing Web sites (such as on Yahoo!) to categorizations
of products for sale and their features (such as on Amazon.com). For example, an address(category) may be defined as
a type of location(category), and city codes(property) may be defined to apply only to locations, and so on. Classes,
subclasses and relations among entities are a very powerful tool for Web use. A large number of relations can be
expressed among entities by assigning properties to classes and allowing subclasses to inherit such properties.
Application of Inference rules in Ontologies provide powerful logical deductions. With ontology pages on the Web,
solutions to terminology problems begin to emerge. The definitions of terms and vocabularies or XML codes used on a Web
page can be defined by pointers from the page to an ontology. Different Ontologies need to provide equivalence
relations (defining same meaning for all vocabularies), or otherwise there would be a conflict and confusion.
Ontologies have the ability to enhance the functioning of the Web in different ways. They can be used in a simple
fashion to improve the accuracy of Web searches-the search program can look for only those pages that refer to a precise
vocabularies and concepts instead of all the ones using ambiguous keywords. More advanced applications will use ontologies
to relate the information on a page to the associated taxonomy hierarchies, knowledge structures and inference rules.
As defined previously, Software-Agents perceive the environment through sensors and act upon that environment
through effectors. Autonomous Agents are defined as Software Agents who’s behaviour is determined by both its own
experience and its built-in knowledge. Here is an example of a non-autonomy agent (physical agent): If a clock manufacturer knew that
the clock owner would be going to Australia on some particular date, then a mechanism could be built in to adjust
the hands automatically by six hours at just the right time. This certainly would be a successful behaviour, but
the intelligence seems to belong to the clock’s designer rather than the clock itself. The same applies to software agents,
where the software seems to exhibit intelligence but actually, it is the programmers effort rather than the software itself. Autonomy
gives true intelligence where the software agent can use its past experience plus its built-in knowledge to deduce new goals.
Intelligent web agents such as a travel software agents – would be doing everything for the user, the agents find possible
ways to meet user needs, and offer the user choices for their achievement. Much as a travel agent might give you a list of
several flights you could take, or a choice of flying versus taking a train, a web agent should offer a range of possible ways
to get you what you need on the web. You delegate the agents the task of finding the best flight route, minimum costs of the
trip from London to Washington via Paris stopping over for two nights at a hotel with reasonable prices, also this hotel must
be near a beach in a city where the temperature is below room temperature. As you can see, this is a complex query that needs
a human to search the WWW to find flights, prices, hotels, weather and so forth to conclude a best deal. You can specify what
you want to the agents and leave the agents to complete the task, you(the user) can take a break, make yourself a cup of coffee
and then come back to your computer, perhaps the agent has returned (lapse time depends on the complexity of the query). It will
come back to you to propose a best flight route, minimum costs for two nights in Paris, propose a hotel that is near a beach and
so forth. All these are done by a machine, you have been freed from the burden of having to sit and browse on the internet for
perhaps hours, trying to achieve your goal. With Semantic Web the software agents can rely on its own experience and learn to
adapt and gain new knowledge during its exchange of dialogue with the hotel web ontologies, weather agency ontologies or the
airline ontologies and so on.
Many automated Web-based services already exist without semantics, but other programs such as agents have no way to locate
one that will perform a specific function. This process, called service discovery, can happen only when there is a common
language to describe a service in a way that lets other agents “understand” both the function offered and how to take advantage
of it. Services and agents can advertise their function by, for example, depositing such descriptions in directories similar
to the Yellow Pages.
There are some low-level service-discovery schemes which are currently available, such as Microsoft’s Universal Plug and
Play, which focuses on connecting different types of devices, and Sun Microsystems’s Jini, which aims to connect services. These
initiatives, however, attack the problem at a structural or syntactic level and rely heavily on standardization of a predetermined
set of functionality descriptions. The Semantic Web is more flexible by comparison. The consumer and producer agents can reach
a shared understanding by exchanging ontologies, which provide the vocabulary needed for discussion. Agents can even bootstrap
new reasoning capabilities when they discover new ontologies. Semantics also makes it easier to take advantage of a service
that only partially matches a request.
Available Java Tools
There are a number of tools (commercial and free-source) which are written in Java for development of Ontology and
Knowledge Base (refer resources). The following tools will help you build ontologies , logical reasoning systems, develop
agents systems and knowledge base in Java. Here are some of the popular ones (refer resources for download links):
- Protigi-2000: This tool is free-source (Mozilla Public License – MPL) available from Stanford University. Since
Protigi is MPL license, you can use it for your commercial product royalty-free. It is an extensible, platform-independent
environment for creating and editing ontologies , customizing knowledge-acquisition forms and knowledge bases. Use JDBC for
database backend. Protigi integrates with JESS (Java Expert System Shell). It also integrates with JADE (Java Agent Development
Framework). Protigi-2000 doesn’t provide direct support for web access, but it can easily be done. A number of Protigi users
have communicated with Protigi-2000 knowledge bases from the Web via servlets. There is a support for DAML+OIL back-end in
Protigi-2000. DAML stands for DARPA Markup Language and OIL means Ontology Interface Layer , both are ontology languages.
- JTP (Java Theorem Prover): This is also a free source Object-Oriented Modular Reasoning System available from
Stanford University. JTP is based on a very simple and general reasoning architecture. The modular character of the
architecture makes it easy to extend the system by adding new reasoning modules (reasoners), or by customizing or rearranging
existing ones. JTP consists of modules called reasoners. According to their functionality, reasoners can be classified
into two types, backward-chaining and forward chaining. Backward-chaining reasoners process queries and return proofs
for the answers they provide. Forward-chaining reasoners process assertions substantiated by proofs, and draw conclusions.
Example of Backward-chaining reasoning: Suppose , that I leave my pot of potatoes to boil in the kitchen, while I go to the lounge
to watch a favourite TV show. I estimated to time it for approximately half an hour(potatoes would be cooked by then), before I can come
back to the kitchen and turn off the oven. The TV show was exciting, so I forgot I had a pot of potatoes cooking, therefore the pot kept boiling
and finally all the water evaporated and ended up burning. The fire alarm in the kitchen went off, and when I heard it I turned my head to the direction
of the kitchen noticing smoke coming out. With no evidence at all (I am still in the lounge, I have not seen what is going on in the kitchen) that this was
caused by the pot of potatoes (my own negligence for failure to go back and turn off the oven after half an hour), I have already drawn that conclusion by
using Backward-chaining reasoning. Here is the chaining process of reasoning: (burnt_pot_of_potatoes <= smoke <= trigger_fire_alarm): As mentioned above, that I am still in the lounge when I heard the alarm and have not seen my pot yet, I hypothesize immediately that my pot of potatoe is burnt given
the facts: “fire_alarm_went_off” and “smoke_coming_out_of_the_kitchen”.
Forward Chaining: Suppose I have just walked out through my front door to go to work one morning, and looked up to the sky, and noticed it is cloudy. I immediately turned back
and went into the house to get an umbrella. Given a fact that it is a cloudy morning, I must need an umbrella because it is going to rain. It has not rain yet, but I reason
in a forward manner, that the knowledge base in by brain cells has a rule that says: “If it is a cloudy morning day then take an umbrella when going to work (expected it will be raining)”. The syntax
expression of rules in JTP and also JESS use a LISP-like expression (everything is a list).
- JADE (Java Agent Development Framework) : JADE aids the development of Multi-Agent Systems (MAS) while ensuring standard
compliance through a comprehensive set of system services and agents in compliance with the FIPA specifications : naming service
and yellow-page service, message transport and parsing service, and a library of FIPA interaction protocols ready to be used.
This tool is free-source GPL. FIPA stands for Foundation Intelligent of Physical Agents, this is a non-profit organization
formed by different companies aimed at producing standards for the interoperation of heterogeneous software agents. Surprisingly
Microsoft is not a member of FIPA. The .NET platform relies heavily on XML, but Semantic Web is an addition to Web Services
that will make it have autonomy. Current Web services protocols is not autonomous. JADE integrates with Protigi to build robust
ontology knowledge base with autonomous agent capability. JADE also integrates with JESS.
- JESS (Java Expert System Shell): This tool is a commercial one but the binary file can be downloaded for free. This is a
popular tool for building Expert Systems and Knowledge Base in Java. JESS has its own rule-language and it uses Backward-chaining reasoning. Note that the Java Rule
Engine API from JSR-94 has a wrapper for JESS. Java Rule Engine has no rule-language of its own therefore it can rely on JESS
for rule-language. JESS is a very important tool that can tie or link with other tools. You can extend it and incorporate other
machine learning tools into it with less effort. There is no one solution for machine intelligence that solves all and it is
a common practice to combine (hybridise) one or more methodologies, the more the better. Example, Protigi + JADE + JESS has been
integrated well in Protigi. Fuzzy Logic can be incorporated into JESS through FuzzyJESS. It is also possible to
integrate ANN (Artificial Neural Network), BBN (Bayesian Belief Network) , CBR (Case-Based-Reasoning) and GA (Genetic Algorithm) into FuzzyJESS. The
resulting hybrids of different machine learning methodologies would make a killer application (Java Rule Engine + JESS +
Protigi + JADE + FuzzyJESS + ANN + BBN + GA + CBR).
- OAA (Open Agent Architecture): Another free-source Tool for building Multi-Agent-System (MAS).
- AGLET: IBM tool, which is free to download (source+binary+docs).
The tools which have been described above are only some of the vast number of Java tools and APIs in machine intelligence
which would be instrumental in Semantic Web application development. The number of Java tools available for machine
intelligence (free-source and commercial) are growing week by week. New machine intelligence tools and APIs written in Java are announced
at Source Forge regularly.
Outlook for Java in Semantic Web
The role of Java language for future of Semantic Web will be influential as all the current FIPA compliant Software Agent
tools (commercial and free-source) are written in Java. Why? The advantage of Java for distributed computing and also
the WORA (Write Once Run All) principle. Software agents can move as mobile code from host-to-host carrying its state
with it. Note that the .NET platform relies on XML and applications built on these can only move data (mobile data) around
between different applications, while Java can dispatch software agents as mobile code (plus mobile data) wherever JVM is
available. The ability of software agents to act autonomously is through true mobility of the code, because the code does the execution of
computational task not the data. An agent can freeze its computation task at host A , saves its state then moves(with its
current state) to host B to continue on the computational where it left off from host A. There is a huge role for Java
in Semantic Web in which JSR such as Java Agent Services API (JSR-87) is already FIPA compliant.
Downloads and Links
- http://www.w3.org/2001/sw/ Semantic Web homepage
- http://www.w3.org/RDF/ RDF homepage
- http://www.jcp.org/jsr/detail/94.jsp Java Rule Engine (JSR-94)
- http://www.jcp.org/jsr/detail/87.jsp Java Agent Services (JSR-87)
- http://www.jcp.org/jsr/detail/73.jsp Java Datamining API (JSR-73)
- http://herzberg.ca.sandia.gov/jess/ Java Expert System Shell (JESS)
- http://protege.stanford.edu/index.html Protigi-2000 (Java Tool for building Knowledge Base and Ontology)
- http://sharon.cselt.it/projects/jade/ Java Agent DEvelopment Framework (JADE)
- http://leap.crm-paris.com/ Lightweight Extensible Agent Platform (LEAP)
- http://www.fipa.org/ Foundation of Intelligent Physical Agents (FIPA) homepage
- http://www.ai.sri.com/~oaa/ Open Agent Architecture
- http://ksl.stanford.edu/software/jtp/ Java Theorem Prover (JTP)
- http://research.compaq.com/SRC/esc/Simplify.html Automatic Theorem-Prover called Simplify
- http://sourceforge.net/projects/aglets/ AGLET (Tool for development of mobile Multi Agents Systems)
- http://www-2.cs.cmu.edu/~javabayes/Home/ JavaBayes (Bayesian Belief Network for Java)
- http://sourceforge.net/projects/joone JOONE (Java Object Oriented Neural Engine)
- http://ai.iit.nrc.ca/IR_public/fuzzy/fuzzyJToolkit.html FuzzyJ (Fuzzy Logic Toolkit for Java)
- http://www.daml.org/ DAML (DARPA Agent Markup Language) homepage
- http://www.markwatson.com/ (Mark Watson) Lots of Java Sample Codes for Machine Intelligence in this author’s homepage (refer book item 2 on the book lists)
- http://sourceforge.net/projects/selectionengine/ Selection Engine is a Java Case-Based-Reasoning (CBR) Tool
- Programming and Deploying Java Mobile Agents with Aglets by Danny B. Lange, Mitsuru Oshima, pub: Addison-Wesley Pub Co.
- Intelligent Java Applications for the Internet and Intranets, by Mark Watson, pub: Morgan Kaufman
- Constructing Intelligent Agents Using Java: Professional Developer’s Guide, 2nd Edition by Joseph P. Bigus, Jennifer Bigus, Joe Bigus, pub: John Wiley & Sons
- Ontologies: A Silver Bullet for Knowledge Management and Electronic Commerce by Dieter Fensel, pub: Springer Verlag
- Multiagent Systems : A Modern Approach to Distributed Artificial Intelligence by Gerhard Weiss , pub: MIT Press
- Applying Case-Based-Reasoning: Techniques for Enterprise Systems by Ian.D. Watson, pub: Morgan Kaufmann
- Artificial Intelligence a Modern Approach by Stuart Russel and Peter Norvig, pub: Prentice Hall
- Machine Learning by Tom. M. Mitchell, pub: Mc Graw Hill
- Expert Systems , Principles and Programming (3rd Edition) by Giarratano and Riley, pub: PWS Publishing Company
- Artificial Intelligence by Patrick Henry Winston, pub: Addison-Wesley
- Learning and Soft Computing : Support Vector Machines, Neural Networks, and Fuzzy Logic Models by Vojislav Kecman, pub: MIT Press
- Neuro-Fuzzy and Soft-Computing : A Computational Approach to Learning and Machine Intelligence by J.S.R Jang, C.T Sun and E. Mizutani, pub: Prentice Hall
- Fuzzy Logic and Soft Computing (Advances in Fuzzy Systems: Applications and Theory, Vol 4) by Bernadette Bouchon-Meunier (Editor), Ronald R. Yager (Editor), Lotfi Zadeh, pub: World Scientific Pub Co.
- Developing Intelligent Agents for Distributed Systems: Exploring Architectures, Techniques, and Applications by Michael Knapik, Jay B. Johnson, pub: McGraw-Hill
- Bayesian Data Analysis by Andrew Gelman, John B. Carlin, Hal S. Stern, Donald B. Rubin , pub: CRC Press
- Bayes and Empirical Bayes Methods for Data Analysis, Second Edition by Bradley P. Carlin, Thomas A. Louis , pub: CRC Press
- “Semantic Web” Journal
- Machine Learning
- Neural Computation
- IEEE Transaction on Pattern Analysis and Machine Intelligence
- Lecture Notes in Artificial Intelligence (LNAI)
- International Conference on Genetic Algorithm
- International Conference on Knowledge Discovery and Data Mining
About the author
Sione Palu has developed software for Publishing Systems, Imaging,
Web Applications, Symbolic and Computer Algebra Systems for secondary education. Palu graduated from the University of Auckland,
New Zealand, with a science degree (B.Sc) in mathematics and computing. His interests involve the application of Java and
Mathematics in the fields of mathematical modelling and simulations, symbolic AI and soft-computing, numerical analysis,
image processing, wavelets, digital signal processing, control systems and computational finance.