Michele Rizzi Web PageMichele Rizzi Web Page » Robotics and automation (4)

Neural Network Video

Michele Rizzi — Sat, 20 Aug 2016 19:13:07 +0000

Below is a video about neural network explained by me earlier

Jena: Semantic Web

Michele Rizzi — Sat, 26 Jul 2014 15:20:34 +0000

Nowadays everyone has internet, there are a lot of web pages and it is quite difficult to perform an accurate research among these pages to get the correct information that you need.

The problem is that the information online is not structured like a database:

Web page is complex document with pictures, videos, images and meta information of mark up to specify the interaction with human and graphic effects.

A way to index a text is to use a system of information retrieval like lucene but it is not enough because Lucene works only parsing text on your web page.

Lucene makes a structure called index composed by a pointer of the document and many keywords that this document contains. When you are looking for some information Lucene searches them in these keyword and assigns a special outcome called ranking.

The disadvantage of Lucene is that it performs the simple research in string that is composed by keywords of the document. Lucene doesn’t know the semantic of the text but knows only the keyword contained in this document.

The best way to perform a research on written text document is to add them a specific meta-information by introducing another tags to the html document.

These tags are not visible to the human but are necessary to improve the index of this page for a external information retrieval system.

This is called Semantic WEB

Semantic web works using a special XML file with all rules of the domain, all the constraints of it and the objects written here must respect these rules.

This XML file is called ontology and it is the knowledge base (KB) of the system.

In this way it’s possible to convert the static not structured text into a xml structured document with a lot of constraints and rules (like database) and it’s possible to make queries to this system. The language that executes these queries is OWL (Ontology Web Language)

There are a lot of XML schemas and a lot of rules to make these semantic web a lot of ontology web languages but the most widespread used is RDF

RDF

RDF is the acronym of Resource Description framework and it is the standard model for data interchange on the Web

This is an example of RDF written by me using Apache Jena:





Michele Rizzi


Rizzi
Michele

In the precedent example I written that the address www.rizzimichele.it is related at vcard descripted below that has Family Rizzi and Name: Michele.

This is a simple RDF example but I can make a complex XML like a WSDL and XSD that contains the identity card of web service.

Here is linked a complex RDF example

For example, the following are tags to define the domain.



Note that hasTopping is inverse functional because isToppingOf is functional

The property of #hasTopping is subproperty of #hasIngredient: each ingredient is Topping

hasTopping has the inverse of isTopping for passive voice.

hasTopping has a specified domains: pizza names.

This is an object that respects all rules and constraints on the system


CoberturaQuatroQueijos
Quattro Formaggi

This pizza is the subclass of cheeseTopping with mid spiciness

Apache JENA

Jena is a java library to write or read RDF language and other owl languages such as TTL, it can also to perform a query to do a reasoning about the xml rdf tree to search the information that you need

this is an example of jena query

select ?pizza where {?pizza a owl:Class ; rdfs:subClassOf ?restriction. ?restriction owl:onProperty pizza:hasSpiciness ; owl:someValuesFrom pizza:Mild }

In the previous query I am looking for a pizza with Spiciness Mild

My project

I tested four examples of applications with Apache Jena and I made one my application to write a simple RDF file.

When I tried to read a customized RDF file to execute a customized queries I get the following error:

Exception in thread "main" com.hp.hpl.jena.shared.PropertyNotFoundException: http://www.w3.org/2001/vcard-rdf/3.0#N at com.hp.hpl.jena.rdf.model.impl.ModelCom.getRequiredProperty(ModelCom.java:1243) at com.hp.hpl.jena.rdf.model.impl.ResourceImpl.getRequiredProperty(ResourceImpl.java:170)
at org.apache.jena.example.helloworld.Tutorial6.main(Tutorial6.java:52)

I am not an expert of Lucene or Apache jena these are not widespread technologies and there are few forums and manuals to learn about them, when it will be necessary to work with this framework I will spend much time to try and I will perform a lot of tests to fix these problems and to study this framework but in my opinion it is enough for now

Lucene:information retrieval

Michele Rizzi — Sat, 19 Jul 2014 15:39:12 +0000

How is internet search engine made of?

How I can search a lot of information in many documents or web pages?

I could search these information using a information retrieval system.

Information retrieval

The information retrival system executes queries to text unstructured document but this file is not ready to search information inside it because the user searches only few keyword that are written in sparse positions in the document and also the document can have a synonym of this keyword etc for this reason it is necessary to do a preprocessing operation.

The most important preprocessing operations are the following:

Stemming: Replacing words with their stems. For instance the English stem “bikes” is replaced with “bike”; now query “bike” can find both documents containing “bike” and those containing “bikes”.
Stop Words Filtering: Common words like “the”, “and” and “a” rarely add any value to a search. Removing them shrinks the index size and increases performance. It may also reduce some “noise” and actually improve search quality.
Text Normalization: Stripping accents and other character markings can make for better searching.
Synonym Expansion: Adding in synonyms at the same token position as the current word can mean better matching when users search with words in the synonym set.
Get most frequency terms

The information retrieval system executes the precedent operation and saves the resulted document and the pointer of the original document in a index file.

When the user searches the keyword, this keyword is find into the index file and the result is shown to the users grouped by ranking (level of relevance) when the user clicks on the link, he can open the document.

Apache Lucene

Lucene is the framework composed by many libraries to execute queries on text documents like an information retrieval system.

The principal libs are the following:

org.apache.lucene.document.Document: allows to store into the index principal information (for example title or contain or creation date) called field of the document. When executing the query it’s necessary to specify what property of the document is searched
org.apache.lucene.analysis.standard.StandardAnalyzer: the analyser that processes the documents to extract the information to save into the index, for example removes stopword, executes stemming and all the four preprocessing operation written above
org.apache.lucene.search.Query: executes the query
org.apache.lucene.search.ScoreDoc: executes the ranking of the results
org.apache.poi.extractor.ExtractorFactory: is very useful for indexing office document like word or excel and to execute queries inside these documents

My Project

I tested all the precedent libraries of Lucene for searching information into word and excel documents and they run well: Lucene creates index files, executes the query and shows the results ordered by ranking.

There are a lot of analysers:

org.apache.lucene.analysis.standard.StandardAnalyzer
org.apache.lucene.analysis.en.EnglishAnalyzer
org.apache.lucene.analysis.it.ItalianAnalyzer

each analyser makes different preprocessing because English stopwords are different from the Italian stopwords, the same for synonyms and stemming.

The pre processing step is not executed automatically but it is necessary to use the method analyzer.tokenStream

when I execute the following code


for (File f : queue) {

FileReader  fr = new FileReader(f);
TokenStream ts=analyzer.tokenStream("contents", ExtractorFactory.createExtractor(f).getText());
doc.add(new TextField("contents",ts));
ts.reset();
ts.close();
writer.addDocument(doc); }

the console shows the following error:

java.lang.IllegalStateException: TokenStream contract violation: reset()/close() call missing, reset() called multiple times, or subclass does not call super.reset(). Please see Javadocs of TokenStream class for more information about the correct consuming workflow.
at org.apache.lucene.analysis.Tokenizer$1.read(Tokenizer.java:111)

This is not the correct way to add the token that contains the text preprocessed at the indexed document.

when I add the field of the document to the indexed document there are no exceptions and the query is executed correctly but when I use a token the previous exception occurs

In my opinion the another way to make the fourth precedents preprocessing is manually, by making many simple dictionaries:

Stop word dictionary a simple xml file with all words that it will be removed while are processed documents for making the index and it will be removed from the user queries
stem synonym dictionary: simple database table with two column: key:base term, another column:term to replace.
- For example BASE TERM:eat; TERM TO REPLACE:ate,eating,eats, have a meal
- I use a table that loads in a class file when the aplication starts by executing the following query “select * from stem_synonym_dictionary”
- when I process a document or a query and I found eating or have a meal, I replace it with eat (simple search into string)

How to make a robot?

Michele Rizzi — Sat, 10 May 2014 19:45:21 +0000

A robot is a special system that takes input from sensor and produces output to actuator.

The control system with more inputs and more outputs is called MIMO (multiple input, multiple output) system.

The control system with one input and one output is called SISO (Single input single output) system.
The simple schema of a robot is the following:

in this schema:

r is the input

y is the output that comes to the actuator

c is the first block that you will make to automatize the system

P is the plant, the system that you cannot control

F is the second block useful to automatize the system.

For example for making the temperature of a home constant, there are the below actors:

r is the desired temperature
Y is the temperature after running the air conditioning system
P is the house, it’s under observation and unmodifiable
C and F are internal devices in the air conditioning system: C works with the error (desired temperature-current temperature), F works using the current temperature

The differences between the desired temperature of the system (r) and the temperature of your block (F) is called E (error) and goes into the block C that produces the input to the plant.

Block C and F are made of a mathematical model that is a complex function written by using Laplace transformation and this function should respect the following requirements:

high disturbance rejection
guaranteed performance
unstable processes can be stabilized (to discover their stability you can use root locus, nyquist or bode diagrams)
reduced sensitivity to parameter variations
improved reference tracking performance

Transfer function allows to know how many components (for example transistors) are necessary for making a robot, how this components are interconnect one to each other.

In the most of the cases the control is the type of PID (proportional integral derive to the difference between input and output).

Another type of robot can make deductions by reasoning, this robot has a lot of information stored an a knowledge base (KB or ontology it is a xml file).

There are a lot of studies to make this robot and there are also a particular part of mathematics called logic that studies how to transform a normal problem in a subset of rules that the computer can process.

for example:

Knowledge base:
(a) the member of the population of Italy are intelligent
(b) the member of the population of Italy are men and woman who live in Italy
(c) Michele lives in Italy
(d) Michele is men

question:
is Michele intelligent?
response:

Michele through the rule d he is men and through the rule c he lives in Italy through the rule b Michele is member of population of Italy and through the a Michele is intelligent.
There are special languages like OWL (ontology web language) and special programming languages such as Prolog that does this reasoning. Apache Jena is the Java framework which works with the ontologies.

That’s used by the semantic web and by RDF (Resource Description Framework) which uses URIs to name the relationship between web objects (images, charts, maps and so on)

Another type of robot can understand from its experience and the environment, this is machine learning and there are three ways for making it

supervised learning: teaching robot how to make a task using a couple input-output, this is on the basis of neural network, in this way it is possible to teach your camera to recognize the faces of the people: giving to the software many pictures (input) and a desired output (which of them are the faces) makes the software understanding the mathematic function to recognize the human faces.
unsupervised learning: is made of many attempts to find hidden structure in unlabelled data. The method to discover this structure is for example clustering.
reinforcement learning: it is inspired by behaviourist psychology have the objective to punish wrong behaviour and reward the right behaviour, it is made of gain function that it will increases if the choice allows the robot to approach the solution, decreases otherwise. This learning is on the basis of the game theory (min max algorithm)

The robot must take a decision according to many alternative, this decision is taken by the experience (machine learning), by logic or is stored statically in the electronic circuit by the transfer function.