Role of Java in the Semantic Web
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.
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.
Page 2 of 2