Topic Assignment 2

In our semantic web class we were supplied with a PDF file and an owl file for a Robotics Ontology done by students in a previous class. We were supposed to study this ontology and understand it, and then comment on how it could possibly be improved.

I had a difficult time with this task, since I have no expertise in Robotics or Android programming, which is what this project entailed. To make matters worse, the owl file could not be opened in Protege to allow us to manipulate the ontology. So I had to open it in Firefox and read it as best I could.

Going through the PDF file it was clear to me that these students were well versed in the Robotics technology area as well as Android Programming (something I cannot say for myself). To try to explain in laymen terms what their project entailed, I would give this explanation:  for people who are interested in finding relevent and precise information related to robotics , there should exist an easy way of sorting through the information using the ideas of semantic web, and then making this more intelligent way of searching and gathering data easily accessible through an Android Device App.

I decided that the best way of understanding the Ontology was to recreate it as best I could in Protege, since the file we were provided could not be accessed. By reading their PDF file and observing their ontology, I came up with the following recreated ontology in Protege:

This Ontology was not difficult to recreate, and I guess the only advice I have for how to improve it would be to add more classes and to expand on the existing classes, which have not yet been explored due to the team stating they were not knowledgeable enough to do so. I think they did a good job creating the ontology, it is concise and clean, and it appeared to me to be based on a good foundation of knowledge on the subject.

I guess now it is up to someone else in the semantic web community who is more vastly familiar with the field of robotics to expand this ontology and continue the work.

Advertisements

Topic Assignment 1

In order to understand what is encompassed in the Intelligent Web, we were given an assignment in class to study section 1.3 of our “Algorithms of the Intelligent Web” textbook, and identify the three ingredients of intelligent web in each of the 6 domains discussed. The three ingredients of intelligent web are aggregated content, reference structures, and algorithms. Aggregated content refers to large amount of dynamic data that may be geographically dispersed. Reference structures provide structural and semantic interpretations of the content. Algorithms refer to the layers of modules that allow the application to harness the information for purposes of generalizing. predicting and overall improving user interaction.

1. Social Networking Sites.

These sites are described in the book to be content aggregators by construction, since they allow users to share files, and comments, and to join and create their own network. Reference structures are involved in the way content is categorized, for instance using labels to clearly classify things such as books, movies, etc. Algorithms are utilized in order to recommend things of suspected interest to the user, based on collected data.

2. Mashups

Mashups are based on aggregated content, but the mashups do not own the content they display. In intelligent (there are non-intelligent mashups as well) there is a need to be able to identify differences and similarities in the content, and then reference structures for interpreting meaning from the content. Algorithms are needed to identify which reference structure elements are contained where, and for categorizing the content retrieved from different sites.

3. Portals

Once again by definition this domain is a gateway to content, which is dispersed but accessible though internet. This content is grouped under different topics, some even user defined, utilizing reference structures. This happens automatically or semi-automatically by use algorithms, as in the case of the example given for this domain (Google News).

4. Wikis

Clearly these are aggregate content sites, they are repositories of knowledge. Wikis sometimes have an internal way of annotating content(their own reference structure distribution), basically they classify the information. They can also, through algorithms, link other pertinent references on the subject, this can even be done automatically.

5. Media-Sharing Sites

Although the size of the information this domain deals with is very large and so poses a threat to the gathering of intelligence, the pattern in this domain is the same as in the others.  There is still aggregated content that need to be categorized through reference structures, and the desired value needs to be extracted by algorithms from that content.

6. Online Gaming

Online games have much aggregated content and reference structures which reflect the rules of the games, and they have algorithms make the games sophisticated and interesting. They incorporate human input to make the game more entertaining.

As is obvious, all intelligent web applications need to have all three ingredients incorporated. These work together to achieve the goals of intelligent web design.

Tool Assignment 4

We recently used the Jena Framework (through Eclipse) to run an example from our textbook,  and blogged about it previously(in my first blog titled Installation, there you can see the results of the querying within the Eclipse/Jena environment). The process was rather painless and straightforward in Jena. Our goal was to see if we could replicate this with the tools at our disposal with the Protege software. Now, the example dealt with combining ontologies, aligning and reasoning with them and querying them.

In theory everything that can be done for this topic in Jena, can be done in Protege as well, but I have found it far more complicated to work with Protege than with Eclipse and the Jena framework. Although Protege is said to be easier to deal with since it has a user-friendly graphical interface, I find it is more demanding in the way files are treated and the way to query the ontologies. I happen to think that Eclipse and Jena are quite easier to work with, especially if the person using it has been exposed to Java code before. If that is the case, than once the ontology files are added to the project the code to access the ontologies is easy to decipher.

Nevertheless, my goal was to replicate the example in Protege, so I began by opening the ontology files provided for the example in chapter 2 of the book and merging them. I started this by actually importing each of the files into Protege 4.1 and merging them together to get the properties to show (in the same way as was done in my last blog titled Model Practice).

Once I got  all the files opened, I aligned them as to have the data matching in the categories.

I made person and individual be equivalent classes, and made knows(in the foaf ontology) a superproperty for hasFriend, and I declared hasName and foaf:name as equivalent properties. And lastly I declared that  “me” in FOAFFriends is identical to “individual_5”  in additionalFriends. Below are some screen shots of those operations.

Once that worked, I opened the ontology in Protege 3.4.7 in order to attempt to query it, since as stated in my previous blog, SPARQL is not supported in 4.1 .  Querying in Protege seems more difficult and less efficient than using Eclipse and Jena. It has more limitations due to the SPARQL syntax. It is possible to get the results we expect, but it is much more of a hassle. Here are some queries I ran:

Obviously, it is possible to do in Protege what can be done in Jena. The question now is, should it. I happen to think that Protege is too stringent in th way it handles such operations as we were performing for this example, and it is a lot less time-consuming to use Jena. This particular example was more straightforward when done with Jena.

Tool Assignment 3

In my Semantic Web class we were assigned the task of creating and querying a model in Protege. We were to create a FOAF file from the FOAF-a-matic site and then open it in Protege and query it. This proved to be quite difficult. It was very daunting getting the file open in Protege. When saving the file, the format would be altered and so was not properly opened, instead it was missing a lot of the information necessary for an ontology and for our querying purposes.

I tried numerous things to get the file to open correctly, but nothing worked. The main issue encountered was that the FOAF schema file, which is supposed to be accessed automatically by the address in the rdf heading of the FOAF file we created, was not actually accessed and so there was no schema attached to the file. I tried to import it quite a few times, but it would not work as expected.

Then, one of my fellow students found a way around this by downloading and using Altova Semantic Works software which allows you to create and edit RDF files, and save them in the proper format. This software made the entire assignment come together. Now  we were able to open and save the FOAF and the FOAF schema files in their correct rdf format and extension, and then open them inside of Protege version 4.1.

Once we opened the FOAF file in Protege, we were able to correctly import the schema file. Then, we merged them into one ontology and the relationships were finally visible for the ontology we created. Once this was done, it was finally possible to save the ontology in the RDF/XML format with an owl extension, so that we could open it in the older version of Protege (3.4.7). We need to do this in order to do the queries, since SPARQL query engine is not supported in the newer versions of Protege. After getting some information on SPARQL querying through tutorials suggested by our professor, it was time to put our knowledge to the test and try a few queries.

Below are some screen shots and explanations of the process:

This is a screen shot of the creation of my FOAF file.

Here is the FOAF file I created and pasted into Altova SemanticWorks in order to save it in rdf format correctly.

Here is the FOAF schema file downloaded and opened in Altova SemanticWorks in order to save it in rdf format correctly.
Once I opened the FOAF file and imported the schema file, they need to be merged into a common ontology.
Finally my ontology is operational, everything is visible.
After saving the ontology through Protege 4.1 as an owl file, I open it in Protege 3.4.7 in order to run some SPARQL queries.
Initiating the SPARQL to query the ontology.
 Here are some queries I made:
 

Helpful sites and info:

SPARQL tutorials:

http://www.xml.com/lpt/a/1628

http://protege.stanford.edu/doc/sparql/

Altova Semantic Works download page:

http://www.altova.com/semanticworks.html

FOAF file creater page:

http://www.ldodds.com/foaf/foaf-a-matic

FOAF schema file address:

http://xmlns.com/foaf/spec/index.rdf

Tool Assignment 2

  • I went on Geonames.org and located my neighborhood, in Coral Springs (between Atlantic blvd and Royal Palm rd near University Drive).  I got familiar with how the site works, and what spots are currently named in my area. Then I created an account so I could add some names to familiar buildings and spots. I was able to follow the map to locate the mall (Coral Square Mall) which is only a block from my house and was already named. I used that as a starting point and from there I was able to locate my favorite local restaurants. I named the Coral Springs Olive Garden and Carrabbas restaurants. I then located and named the Sam’s Club, and corrected the location of Maplewood Elementary school which is directly behind the store, but was mistakenly tagged at an erroneous location a few blocks away. I noticed that although the mall was already named, the local movie theater in the neighboring plaza was not, so I tagged the Coral Square Stadium 8 movie theater. Then I also tagged a Walgreens pharmacy, and the First Presbyterian Church of Coral Springs/Margate. I also named a popular location for restaurants and stores, The Walk of Coral Springs. Although I found this site to be easy to work with and fun to use, I did notice that it was missing something. The terms used to tag with do not always include words every user expects. For example, I wanted to tag the Walgreens as a pharmacy, but that term was not available on their list, the closest term available was a dispensary, which to me seemed like an incorrect description, so I tagged it as a store instead, which is not an accurate description either. Chances are that the designated vocabulary will never be able to satisfy all users no matter how many terms are included, so sometimes things will be named in an inaccurate way as compared to how they would be described verbally.
  • Once I completed tagging things, I opened the Geonames rdf file in Protege and tried to understand the hierarchy. I am still adjusting to Protege and its uses, and I have to say I do not feel that comfortable with it. I am not sure that I understand what is shown when I open the RDF file. I can see the class hierarchy, it consists of four disjointed parts: concept, conceptschema, document, and spatialthing, each of which has its own subtopics. Under conceptschema, there is a class tab which allows you to see the main ontology codes, like “A” which when you click on it shows you it stands for a “country, state, region…” Within the code “A”, you can see the sub-tags, if you click on the concept class,  and then if you click on the sub-tag in question it tells you what specifically stands for,  such as “A.ADM1” which is defined as “first-order administrative division”. Under document, there are the subclasses map (which refers to an internet page displaying a map), RDF data, and ‘Wikipedia Article’. Under spatialthing, there is a feature subclass,which refers to “a geographical object uniquely defined by its geonames id.” That is how I perceived the hierarchy of the RDF file of the Geonames site.
  • I also went online and created my own FOAF file. Here are the contents of that file:

<rdf:RDF
xmlns:rdf=”http://www.w3.org/1999/02/22-rdf-syntax-ns#&#8221;
xmlns:rdfs=”http://www.w3.org/2000/01/rdf-schema#&#8221;
xmlns:foaf=”http://xmlns.com/foaf/0.1/&#8221;
xmlns:admin=”http://webns.net/mvcb/”&gt;

<foaf:PersonalProfileDocument rdf:about=””>

<foaf:maker
rdf:resource=”#me”/>
<foaf:primaryTopic rdf:resource=”#me”/>
generatorAgent
rdf:resource=”http://www.ldodds.com/foaf/foaf-a-matic”/&gt;
errorReportsTo
rdf:resource=”mailto:leigh@ldodds.com”/>

foaf:PersonalProfileDocument>

<foaf:Person rdf:ID=”me”>

<foaf:name>Iana Zankina

<foaf:title>Mrs

<foaf:givenname>Iana

<foaf:family_name>Zankina

<foaf:mbox_sha1sum>4f6616265937c4bcc433aff6f0f3678cc6fc7b15

<foaf:phone
rdf:resource=”tel:954-255-1300″/>

<foaf:workplaceHomepage
rdf:resource=”http://fau.edu/”/&gt;

<foaf:workInfoHomepage
rdf:resource=”http://www.fau.edu/hr/Student_Employment/index.php”/&gt;

<foaf:schoolHomepage
rdf:resource=”http://fau.edu/”/&gt;

<foaf:knows>

<foaf:Person>

<foaf:name>Maria Minan

<foaf:mbox_sha1sum>4ff8e8e6ee6dd3d7cd3593edf71cc64bad759cb9

<foaf:knows>

<foaf:Person>

<foaf:name>Lan Reeder

<foaf:mbox_sha1sum>f3d35a4af2af1fbc87d4fa2029e7f175176d9e57

<foaf:knows>

<foaf:Person>

Calos Tauriz

b75baad1f3a354c7c82d62f10f38e45215da95a2

rdf:RDF>

  • Finally, I went to the google recipe site and tried to understand the ontology. When I opened the page, I noticed in the left hand corner they have a menus with different options about the kind of recipe you are looking for. Depending on what you click on in those menus, more options appear, and a selection of recipes appear that fit those options you clicked on. If you do not find anything you like or you want to limit the amount of results, you may just keep clicking on ingredients, calorie content, and cooking time to narrow down the kind of recipe you’re looking for. This produces smaller amount of hits on your search which are more accurate with your parameters for the search. The way it seems to work is that when you click on certain options for your ingredients or cooking preferences, the algorithm searches for a hit on those options. If it finds the words expected by your selection within the recipe, it returns that recipe as a result, and eliminates ones that do not contain those words/preferences in the recipe. Their ontology includes the terms like chicken, eggs, milk, beef, eggs, onions, potatoes, and many more. They also acknowledge specified options for cooking time and calorie content. This seems to me to be a brilliant idea, and I actually look forward to using this site. More than once I have looked in my fridge and found ingredients I did not know how to use together to make a meal. With this site you just enter what you have at your disposal and you can find a list of recipes to satisfy your taste and ease your cooking anxiety.

Tool Assignment 1 : installing Protege, Eclipse, Jena, ect.

The installation process was tedious but not very complicated. I began by making updates to my computer because it would otherwise complain when I tried to update the version of Java on my computer. Once I was able to update Java, I downloaded and installed Eclipse Helios, and ran it to make sure the installation worked, then I downloaded Jena. After that,  I concentrated on downloading Protege and then Pellet (which gave me a bit of trouble, and I had to try download it a few times before I was successful). Once I was sure all the downloads were successful, I ran the example from chapter two in the book (the FOAF friends example). It ran as expected and gave the following result:

The main comment I have, is that it would be a lot less trouble if there was a site you could go to which would have all the downloads you need for semantic web activities in one location. If someone groups these downloads and allows access to them from the same location, and makes sure that they run in the correct order and are compatible it would make it easier to begin working with them and to explore what services they offer for semantic web programming.

Tool Assignment 1

Many readers may be wondering exactly what semantic web refers to, and so from the data I have gathered, here is the best description of semantic web I could come up with. Semantic web is defined as meaning for the web in order to make better use of data available through the web. It refers to describing and linking data to build context, in accordance with a set rules and guidelines for the categorizing grammar used.

The basic idea is to enable machines to better be able to respond to human requests by being able to identify the individual differences between each person’s request, in order to come up with more precise results for each person. For this to be achieved there needs to be an ontology for the data available through the web, meaning that data are grouped according to their similarities and differences within a hierarchy. This ontology must be universally agreed upon, then its utilization would lead to more accurate deciphering of information when searching for requests by users, allowing for only the most likely results of their search to be produced as an outcome to the search, thereby limiting the amount of time the user spends sifting through information that does not match the data they  expected to find.