At the beginning of the last chapter we discovered that features induce equivalence relations and that equivalence relations create blocks of indiscernible objects, that is, “small groups of similar, equal, or equivalent things”. Any two objects in an equivalence class cannot be distinguished from each other, but two objects from different classes can be well discriminated. For our information systems that usually provide a large number of features, we also have many equivalence relations. Furthermore, any intersection of any subset of such equivalence relations also forms a new equivalence relation. And because equivalence relations are relations, and because relations are sets, it appears to be an interesting idea to consider the intersection of equivalence relations as a much finer and more detailed partitioning of our base set.

One of the cornerstones of (traditional) artificial intelligence is the assumption that

These processes include the acquisition of new knowledge, which we call machine learning or knowledge discovery. However, when talking about knowledge-based systems we first need to explain what we mean by knowledge. If we try to define learning by intelligence, we need to explain intelligence, and if we want to explain intelligence, we need to explain knowledge. Bertrand Russell (1992, 1995) has given a very precise and in our case very helpful (and actually entirely sufficient) definition of knowledge:

As a consequence, learning means acquiring the ability to recognise and differentiate between different things. Thus, the process of knowledge acquisition is a process that is initiated and (autonomously) run by a system whose purpose is to learn by itself. L. G. Valiant (1984) said that

If we try to put all the important information about machine learning in just a small box, it would look like this:

This rather rough picture is described in detail in the following sections.

First we need to specify what we will be talking about and the terms we will be using.

Representation

Machine learning and knowledge discovery are concerned with:

• grouping objects (like entities, processes, atoms, complex structures, etc.)

• from a domain (i.e., a set of such objects)

• into target concepts

• with respect to their properties and/or the classes they belong to.

First we need to ask ourselves how to represent our knowledge of the world. The part of the world that we live in and that we shall reason about is called the domain. To be able to talk about objects of the domain we need to have representations thereof.

Information is something that may change knowledge, and knowledge is the ability to relate things by putting a structure on them. Knowledge is not made from the things we put into order, and information does not change the things themselves. It is, rather, that knowledge is a set of relations describing things and information helps us to describe a relation's utility for classifying things. But, then, why do we assume information to be describable by a set of entities each of which can take a certain number of different states – if they do not know whether there are entities they have never seen before nor how many states the entities can possibly take? Why do we explain causality by means of probabilistic dependence?

There are many definitions of what knowledge could be, and there are many approaches to knowledge representation formalisms. They all agree that there is knowledge of different qualities: factual knowledge, weak knowledge, procedural knowledge, hard knowledge, motor knowledge, world knowledge, and behavioural knowledge are just a few. A sloppy and weak definition of knowledge might well be what we want to acquire by learning.

In the previous chapter we saw how similarity measures can be used to group objects into (hopefully) meaningful clusters. Given an information system ℑ, we now want to describe a feature's utility with respect to a given object's classification. Relationally speaking, we need to recursively apply those features fi ϵ F that generate a partition on U that is similar to U/Rt to learn a compressing classifier this way. It appears to be a good idea to start with a feature that appears to be the most “similar” to t. A feature being quite similar to the target function can be assumed to carry relevant information with respect to t. And this leads us to the information-theoretic notion of entropy.

People often try to explain Shannon and Weaver's (1949) information-theoretic measure of entropy by the laws of entropy in thermodynamics.

During the last decades, machine learning evolved from theories of reasoning in artificial intelligence to an essential component of software systems. Statistical methods outperform logic-based approaches in most application domains – and with increasing computational power it has become possible to generate and test classifiers. As a more sophisticated approach, ensemble learning implements divide-and-conquer strategies on the learning problem. With the further increase of data collections (e.g., data warehouses), the problem we are facing is not concerned with how we can induce a classifier that supports our model assumptions on the data but rather to understand what kind of information there actually is. In machine learning, this approach is known as knowledge discovery.

Knowledge representation

Because we are used to describing knowledge in the language of terminologic logic, we quite often identify knowledge representation with logic models. In Chapter 3 we saw that knowledge can be represented in many, many different ways.

In the previous chapters, we saw that relations can be used to represent knowledge about sets of things. We also discovered that learning means to find a suitable set of relations with which we can describe or define concepts (see Definition 2.37). Now we describe a first approach to efficiently discover relational concept descriptions. Our starting point is an information system with a feature-based representation of the objects in our domain.

Concepts as sets of objects

Our working hypothesis is that knowledge is the ability to discriminate things and learning is knowledge acquisition. Therefore,

There are, in general, two different methods to group similar objects together and distinguish them from other groups of entities:

• Building sets or classes of objects that we assume to share certain properties by grouping them into the same cluster

• Inducing a concept that serves as a description of a representation class in terms of properties of objects.

What it is about

This book is about knowledge discovery. There are many excellent books on machine learning and data mining. And there are many excellent books covering many particular aspects of these areas. Even though all the knowledge we are concerned with in computer science is relational, relational or logic machine learning or knowledge discovery is not that common. Accordingly, there are fewer textbooks on this issue.

This book strongly emphasises knowledge: what it is, how it can be represented, and, finally, how new knowledge can be discovered from what is already known plus a few new observations. Our interpretation of knowledge is based on the notion of “discernability”; all the methods discussed in this book are presented within the same paradigm: we take “learning” to mean acquiring the ability to discriminate between different things. Because things are different if they are not equal, we use a “natural” equivalence to group similar things together and distinguish them from differing things. Equivalence means to have something in common. According to the portion of commonness between things there are certain degrees of equality: things can be exactly the same, they can be the same in most cases or aspects, they can be roughly the same, not really the same, and they can be entirely different. Sometimes, they are even incomparable.

This chapter proposes exercises and projects based on CouchDB, a recent database system which relies on many of the concepts presented so far in this book. In brief:

1. CouchDB adopts a semistructured data model, based on the JSON (JavaScript Object Notation) format; JSON offers a lightweight alternative to XML;

2. A database in CouchDB is schema-less: the structure of the JSON documents may vary at will depending on their specific features;

3. In order to cope with the absence of constraint that constitutes the counterpart of this flexibility, CouchDB proposes an original approach, based on structured materialized views that can be produced from document collections;

4. Views are defined with the MapReduce paradigm, allowing both a parallel computation and incremental maintenance of their content;

5. Finally, the system aspects of CouchDB illustrate most of the distributed data management techniques covered in the last part of the present book: distribution based on consistent hashing, support for data replication and reconciliation, horizontal scalability, parallel computing, and so forth.

CouchDB is representative of the emergence of so-called key-value store systems that give up many features of the relational model, including schema, structured querying, and consistency guarantees, in favor of flexible data representation, simplicity and scalability. It illustrates the “No[tOnly]SQL” trend with an original and consistent approach to large-scale management of “documents” viewed as autonomous, rich pieces of information that can be managed independently, in contrast with relational databases, which take the form of a rich graph of interrelated flat tuples.

INTRODUCTION

This chapter introduces XPath and XQuery, two related languages that respectively serve to navigate and query XML documents. XPath is actually a subset of XQuery. Both languages, specified by theW3C, are tightly associated and share in particular the same conceptual modeling of XML documents. Note that the XPath fragment of XQuery has a well-identified purpose (expressing “paths” in an XML tree) and as such can be used independently in other XML processing contexts, such as inside the XSLT transformation language. XQuery uses XPath as a core language for path expressions and navigation.

XQuery is a declarative language and intends to play for XML data the role of SQL in the relational realm. At a syntactical level, it is somewhat inspired from SQL. More importantly, it is expected to benefit from a mixture of physical storage, indexing, and optimization techniques in order to retrieve its result by accessing only a small fraction of its input. XQuery constitutes therefore an appropriate choice when large XML documents or large collections of documents must be manipulated.

In this chapter, we use as running example a movies XML database. Each XML document represents one movie and is similar in structure to the sample document shown in Figure 2.1.

We begin the chapter with a bird's-eye view of XQuery principles, introducing the XML data model that supports the interpretation of path expressions and queries, and showing the main features of the two languages. We then consider in more detail XPath and XQuery in a rather informal way.

Lucene is an open-source tunable indexing platform often used for full-text indexing of Web sites. It implements an inverted index, creating posting lists for each term of the vocabulary. This chapter proposes some exercises to discover the Lucene platform and test its functionalities through its Java API.

PRELIMINARY: A LUCENE SANDBOX

We provide a simple graphical interface that lets you capture a collection of Web documents (from a given Web site), index it, and search for documents matching a keyword query. The tool is implemented with Lucene (surprise!) and helps to assess the impact of the search parameters, including ranking factors.

You can download the program from our Web site. It consists of a Java archive that can be executed right away (provided you have a decent Java installation on your computer). Figure 17.1 shows a screenshot of the main page. It allows you to

1. Download a set of documents collected from a given URL (including local addresses),

2. Index and query those documents,

3. Consult the information used by Lucene to present ranked results.

Use this tool as a preliminary contact with full text search and information retrieval. The projects proposed at the end of the chapter give some suggestions to realize a similar application.

INDEXING PLAIN TEXT WITH LUCENE – A FULL EXAMPLE

We embark now in a practical experimentation with Lucene. First, download the Java packages from the Web site http://lucene.apache.org/java/docs/.

INTRODUCTION

The vision of the Semantic Web is that of a world-wide distributed architecture where data and services easily interoperate. This vision is not yet a reality in the Web of today, in which given a particular need, it is difficult to find a resource that is appropriate to it. Also, given a relevant resource, it is not easy to understand what it provides and how to use it. To solve such limitations, facilitate interoperability, and thereby enable the Semantic Web vision, the key idea is to also publish semantics descriptions of Web resources. These descriptions rely on semantic annotations, typically on logical assertions that relate resources to some terms in predefined ontologies. This is the topic of the chapter.

An ontology is a formal description providing human users a shared understanding of a given domain. The ontologies we consider here can also be interpreted and processed by machines thanks to a logical semantics that enables reasoning. Ontologies provide the basis for sharing knowledge, and, as such, they are very useful for a number of reasons:

Organizing data. It is very easy to get lost in large collections of documents. An ontology is a natural means of “organizing” (structuring) it and thereby facilitates browsing through it to find interesting information. It provides an organization that is flexible, and that naturally structures the information in multidimensional ways. For instance, an ontology may allow browsing through the courses offered by a university by topic or department, by quarter or time, by level, and so forth.

INTRODUCTION

The goal of data integration is to provide a uniform access to a set of autonomous and possibly heterogeneous data sources in a particular application domain. This is typically what we need when, for instance, querying the deep web that is composed of a plethora of databases accessible through Web forms. We would like to be able with a single query to find relevant data no matter which database provides it.

A first issue for data integration (that will be ignored here) is social: The owners of some data set may be unwilling to fully share it and be reluctant to participate in a data integration system. Also, from a technical viewpoint, the difficulty comes from the lack of interoperability between the data sources, that may use a variety of formats, specific query-processing capabilities, different protocols. However, the real bottleneck for data integration is logical. It comes from the so-called semantic heterogeneity between the data sources. They typically organize data using different schemas even in the same application domain. For instance, each university or educational institution may choose to model students and teaching programs in its own way. A French university may use the social security number to identify students and the attributes nom, prenom, whereas the Erasmus database about European students may use a European student number and the attributes firstname, lastname, and home university.

In this chapter, we study data integration in the mediator approach. In this approach, data remain exclusively in data sources and are obtained when the system is queried.