Master Thesis Topics IT4BI 2015-2016 @ ULB CoDE/WIT

Introduction

The primary area of research in the Web and Information Technologies (WIT) laboratory of the the Department of Computer & Decision Engineering (CoDE) at ULB concerns information systems (both traditional and on the web). Broadly speaking, we can identify the following major themes in the laboratory's research.

The master thesis subjects presented below offered by Web and Information Technologies (WIT) laboratory of the the Department of Computer & Decision Engineering (CoDE) at ULB the cover the themes following themes.

  • Business Intelligence and Data Warehouses
  • The Semantic Web and Web Data Management
  • Spatio-temporal databases
  • Data Mining
  • Information extraction


Please note that this list of subjects is not exhaustive. Interested students are invited to propose original subjects.

Master Thesis in Collaboration with Euranova

Our laboratory performs collaborative research with Euranova R&D (http://euranova.eu/). The list of subjects proposed for this year by Euranova can be found here

These subject include topics on distributed graph processing, processing big data using Map/Reduce, cloud computing, and social networks.

Master thesis in Collaboration with Technion (Israel)

Our laboratory performs collaborative research with Technion (Israel Institute of Technology). The list of subjects proposed for this year by Technion can be found here.

These subject include topics on graph mining, text analytics, management of inconsistent database.

Topic 1: Graph Mining

Matching background: 2 options:

1) Algorithms, complexity, graph theory 2) C/C++ programming

Abstract:

The need to discover and generate frequent graph patterns arises in applications that span a wide spectrum, such as mining molecular data and classification of chemical com- pounds, behavior and link analysis in social networks, workflow analysis, and text classification. Several algorithms for generating (maximal) frequent subgraphs have been proposed and evaluated experimentally, but until recently not much has been known about the computational complexity of the fundamental related enumeration and decision problems. In a recent work, we conducted on a comprehensive investigation of the computational complexity of mining maximal frequent subgraphs, taking into account various key variables of the problem, such as possible restrictions on the classes of graphs and patterns, bounding the threshold, and bounding the number of desired answers. Within that investigation, we devised a novel algorithmic framework based on our previous work on hereditary graph properties. This framework is inherently different from previous algorithms for mining maximal frequent subgraphs, as it is incremental in nature (i.e., commits to answers as it runs), and it provides efficiency guarantees (polynomial delay) in certain natural cases. The project aims to advance our understanding and the practical usability of mining maximal frequent subgraphs. We are especially interested in usability in the context of feature generation in machine learning; there, frequent patterns capture recurring patterns in structure, and in turn can be used as features.

Relevant Publications:

  • Benny Kimelfeld, Phokion G. Kolaitis: The Complexity of Mining Maximal Frequent Subgraphs. ACM Trans. Database Syst. 39(4): 32 (2014)
  • Benny Kimelfeld, Phokion G. Kolaitis: The complexity of mining maximal frequent subgraphs. (Extended abstract.) PODS 2013: 13-24
  • Sara Cohen, Benny Kimelfeld, Yehoshua Sagiv: Generating all maximal induced subgraphs for hereditary and connected-hereditary graph properties. J. Comput. Syst. Sci. 74(7): 1147-1159 (2008)

Topic 2: Managing Inconsistent Databases with Tuple Preferences

Matching background: Logic,databases, complexity theory

Abstract:

Managing data inconsistency has been one of the major challenges in the research and practice of database management. Sources of inconsistency include imprecise processes of data generation such as mistakes in manual form filling and noisy sensing equipment, as well as data integration where different source databases may contain conflicting information. This problem becomes even more important and central to data management in the “Big Data” era, where data repositories are increasingly based on imprecise processes (e.g., crowd sourcing and information extraction from natural language) and integration of repositories with varying levels of reliability. The framework of database repairs provides a principled approach to managing inconsistencies in databases. Informally, a repair of an inconsistence database is a consistent database that differs from the inconsistent one in a “minimal way.” Here, all repairs are taken into account, and they are treated on a par with each other. There are situations, however, in which it is natural and desired to prefer one repair over another; for example, one data source is regarded to be more reliable than another, or timestamp information implies that a more recent fact should be preferred over an earlier one. Motivated by these considerations, Staworko, Chomicki and Marcinkowski introduced the framework of preferred repairs. The main characteristic of this framework is that it uses a priority relation between conflicting facts of an inconsistent database to define notions of preferred repairs. In this project, the goal is to establish the complexity of fundamental tasks such as finding the consistent answers to a query (i.e., the answers that are obtained in every repair), identifying that a given repair is optimal according to the preference, and determining whether the preferences defined a unique optimal repair.

Relevant Publications:

  • Ronald Fagin, Benny Kimelfeld, Frederick Reiss, Stijn Vansummeren: Cleaning inconsistencies in information extraction via prioritized repairs. PODS 2014: 164-175
  • Ronald Fagin, Benny Kimelfeld, Phokion Kolaitis: Dichotomies in the Complexity of Preferred Repairs. To appear in PODS, 2015.

Topic 3: Extending Database Technology with Fundamentals of Text Analytics

Matching background: 2 options:

1) Databases, Logic, Formal Languages. 2) Java/C++ programming

Abstract: Modern technological and social trends, such as mobile computing and social networking, result in an enormous amount of publicly available data with a high potential value within. Contemporary business models, such as cloud computing, open-source software and crowd sourcing, provide the means for analysis without the resources of grand enterprises. But that data have characteristics that challenge traditional database systems. Due to the uncontrolled nature by which data is produced, much of it is free text, often in informal natural language, leading to computing environments with high levels of uncertainty and error. Traditional database systems are based on models that fundamentally lack the ability to deeply process text and reason about uncertainty thereof; hence, existing solutions are often software bundles that combine databases, scripts fortext extraction, NLP algorithms, and statistical libraries. The goal of this project is to establish foundations and implementations of data management systems that capture the nature of modern text analysis, to facilitate, expedite, and simplify application development.

Relevant publications:

  • Benny Kimelfeld: Database principles in information extraction. PODS 2014: 156-163
  • Ronald Fagin, Benny Kimelfeld, Frederick Reiss, Stijn Vansummeren: Cleaning inconsistencies in information extraction via prioritized repairs. PODS 2014: 164-175
  • Ronald Fagin, Benny Kimelfeld, Frederick Reiss, Stijn Vansummeren: Spanners: a formal framework for information extraction. PODS 2013: 37-48

Topic 4: Query Suggestion in Complex Schemas

Matching background: Databases, Java/C++ programming

Abstract: This research aims to facilitate database querying in settings that involve large and complicated schemas (e.g., SAP schemas with thousands of relations). In this project we design and implement a system for automatic suggestion of database queries from keywords, natural text, and visual input from an interactive system. Such a system entails three main challenges. First, a nontrivial interactive interface is needed in order to allow users to express complicated schema relationships and understand system proposals. Second, the translation of vague phrases into valid queries (e.g., “Technion employee” into a join between Person, WorksFor, and Organization) requires nontrivial modeling that involves graphs, lexical databases and knowledge bases, and possibly machine learning and probabilistic modeling. Finally, all involved algorithms need to run in interactive response time.

Relevant Publications:

  • Benny Kimelfeld, Yehoshua Sagiv: Extracting minimum-weight tree patterns from a schema with neighborhood constraints. ICDT 2013: 249-260
  • Benny Kimelfeld, Yehoshua Sagiv: Finding a minimal tree pattern under neighborhood constraints. PODS 2011: 235-246
  • Ronald Fagin, Benny Kimelfeld, Yunyao Li, Sriram Raghavan, Shivakumar Vaithyanathan: Understanding queries in a search database system. PODS 2010: 273-284
  • Ronald Fagin, Benny Kimelfeld, Yunyao Li, Sriram Raghavan, Shivakumar Vaithyanathan: Rewrite rules for search database systems. PODS 2011: 271-282
  • Konstantin Golenberg, Benny Kimelfeld, Yehoshua Sagiv: Keyword proximity search in complex data graphs. SIGMOD Conference 2008: 927-940

Complex Event Processing for Security Analytics

As noted by Cugola and Magara, “an increasing number of distributed applications requires processing continuously flowing data (“events”) from geographically distributed sources at unpredictable rates to obtain timely responses to complex queries. Examples of such applications come from the most disparate fields: from fraud detection to network intrusion detection systems, from wireless sensor networks to financial tickers, from traffic management to click-stream inspection.”

These requirements have led to the development of a number of systems specifically designed to process information as a flow (or a set of flows) of continues data “events” according to a set of pre-deployed processing rules. Despite having a common goal, these systems differ in a wide range of aspects, including architecture, data models, rule and pattern languages, and processing mechanisms. In part, this is due to the fact that they were the result of the research efforts of different communities, each one bringing its own view of the problem and its background to the definition of a solution.

The master thesis is put forward in the context of the SPICES “Scalable Processing and mIning of Complex Events for Security-analytics” research project, funded by Innoviris. The objective of this master thesis is to survey the existing systems and compare the strengths and weaknesses when they are applied specifically to the context detecting security breaches (network intrusion, fraud detection, …), and help, as part of the research project, in the design & implementation of a new system that overcomes these weaknesses.

Interested? Contact : Stijn Vansummeren

Status: taken

Compiling SPARQL queries into machine code

Due to the increasing availability of larger and larger cheap RAM memories, the working set of modern database management systems becomes more and more main memory resident. This implies that, in contrast to traditional database management systems, slow disk accesses are rare, and that hence, the in-memory processing speed of databases becomes an important factor. As recently observed by a number of researchers, (e.g., Neumann and Leis), one very attractive approach for fast query processing in this context is the just-in-time compilation of incoming queries into machine code. This compilation avoids the overhead of the traditional interpretation of query plans, and can aid in minimzing memory traffic for boosting performance.

A number of recent research prototypes exist that compile SQL queries into machine code in this sense: HyPer A Hybrid OLTP&OLAP High Performance DBMS (http://hyper-db.de/) and Legobase (https://github.com/epfldata/NewLegoBase and http://data.epfl.ch/legobase).

The objective of this master thesis is to apply the same methodology to engineer a compiler that translates (fragments of) SPARQL (the standard query language for querying RDF data on the semantic web) into machine code. The overall methodology should follow the methodology used by HyPer and Legobase:

  • Use of a high-level language to construct the compiler (Scala, http://scala-lang.org/)
  • Use of Latent Modular Staging (LMS for short) for generating low-level portable assembly code at runtime (http://scala-lms.github.io/)
  • Use of LLVM (http://llvm.org/) as a portable assembly code and corresponding translator to machine code.

Getting aquaintend with these technologies is part of the master thesis objective.

Validation of the approach The thesis should propose a benchmark collection of SPARQL queries that can be used to test the obtained SPARQL-to-machine-code compiler and compare its perforance against a reference, interpreter-based SPARQL compiler.

Deliverables of the master thesis project:

  1. An overview of the state of the art in query-to-machine-code compilation.
  2. A description of latent modular staging and how it can be used to construct machine-code compilers.
  3. The SPARQL compiler (software artifact)
  4. A benchmark set of SPARQL queries and associated data sets for the experimental validation
  5. An experimental validation of the compiler, comparing efficiency of compiled queries against a reference compiler based on query plan interpretation.

Interested? Contact : Stijn Vansummeren

Status: available

An implementation of the SCULPT schema language for tabular data on the Web

Despite the availability of numerous standardized formats for semi-structured and semantic web data such as XML, RDF, and JSON, a very large percentage of data and open data published on the web, remains tabular in nature. (Jeni Tennison, one of the two co-chairs of the W3C CSV on the Web working group claims that ``over 90% of the data published on data.gov.uk is tabular data.) Tabular data is most commonly published in the form of comma separated values (CSV) files because such files are open and therefore processable by numerous tools, and tailored for all sizes of files ranging from a number of KBs to several TBs. Despite these advantages, working with CSV files is often cumbersome because they are typically not accompanied by a schema that describes the file's structure (i.e., ``the second column is of integer datatype, ``columns are delimited by tabs'', etc) and captures its intended meaning. Such a description is nevertheless vital for any user trying to interpret the file and execute queries or make changes to it.

In other data models, the presence of a schema is also important for query optimization (required for scalable query execution if the file is large), as well as other static analysis tasks. Finally, schemas are a prerequisite for unlocking huge amounts of tabular data to the Semantic Web.

In recognition of this problem, the CSV on the Web Working Group of the World Wide Web Consortium argues for the introduction of a schema language for tabular data to ensure higher interoperability when working with datasets using the CSV or similar formats.

The objective of this master thesis is to implement a recent proposal for such a schema language named SCULPT (http://arxiv.org/abs/1411.2351). Concretely, this entails:

  • proposing an elegant concrete syntax for SCULPT schemas
  • implement both the in-memory and streaming validation algorithms of SCULPT proposed in http://arxiv.org/abs/1411.2351
  • extend the SCULPT proposal, by investigating how SCULPT can be combined with complementary features recently proposed by the W3C CSV on the Web Working group (http://www.w3.org/2013/csvw/wiki/Main_Page)
  • and in particular, extend sculpt with features that allow tabular files to be converted into RDF
  • create associated tooling for SCULPT (i.e., parser and serializer generator, in the spirit of data description tools)


Deliverables of this master thesis project:

  1. detailed description of the SCULPT proposal (document)
  2. overview of the state of the art; in particular other proposals for schema languages for tabular data (document)
  3. concrete syntax for sculpt (design document + formal grammar)
  4. implementation of SCULPT validation algorithms (software artifact)
  5. extension of sculpt with features for converting into RDF (document + software)

Interested? Contact: Stijn Vansummeren

Status: available

Engineering a runtime system and compiler for AQL

Automatically extracting structured information from text is a task that has been pursued for decades.Since most analytics over text involves information extraction as a first step, IE is a very important part of data analysis in the enterprise today.

In 2005, researchers at the IBM Almaden Research Center developped a new system specifically geared for practical information extraction in the enterprise. This effort lead to SystemT, a rule-based IE system with an SQL-like declarative language named AQL (Annotation Query Language). The declarative nature of AQL enables new kinds of tools for extractor development, and draws upon known techniques form query processing in relational database management systems to offer a cost-based optimizer that ensures high-througput performance. Recent research into the foundations of AQL (http://researcher.watson.ibm.com/researcher/files/us-fagin/jacm15.pdf) has shown that, as an alternative, it is also possible to build a runtime system for AQL based on special kinds of finite state automata. A potential benefit of this alternate runtime system is that text files need only be processed once (instead of multiple times in the cost-based optimizer backend) and may hence provide greater throughput. On the other hand, the alternate system can sometimes have larger memory requirements than the cost-based optimizer backend.

The objective of this master thesis is to design and engineer a runtime system and compiler for (a fragment) of AQL based on finite state automata. Ideally, to obtain the best performance, these automata should be compiled into machine-code when executed. For this compilation, the following technologies should be used:

  • A a high-level language to construct the compiler (Scala, http://scala-lang.org/)
  • Use of Latent Modular Staging (LMS for short) for generating low-level portable assembly from the automata at runtime (http://scala-lms.github.io/)
  • Use of LLVM (http://llvm.org/) as a portable assembly code and corresponding translator to machine code.

Getting aquaintend with these technologies is part of the master thesis objective.

Validation of the approach The thesis should propose a benchmark collection of AQL queries and associated input text files that can be used to test the obtained automaton-based AQL compiler and compare its performance against the reference, cost-based optimizer of SystemT.

Deliverables of the master thesis project:

  1. An overview of AQL, SystemT, and its cost-based optimizer and evaluation engine. (document)
  2. A description of how AQL can be evaluated by means of so-called vset finite state automata. (document)
  3. A detailed desription of the state of the art in evaluating finite state automata. (document)
  4. Identification of the AQL syntaxt that is to be supported. (specification)
  5. The AQL compiler (software artifact)
  6. A benchmark set of AQL queries and associated data sets for the experimental validation
  7. An experimental validation of the compiler, comparing efficiency of compiled queries against the cost-based reference compiler.


References about SystemT:


References about finite state automata evaluation:


Interested? Contact : Stijn Vansummeren


Status: available

Structural compression of relational databases

Recent research in database management systems at ULB has shown how to theoretically construct succinct (compressed) representations for relational databases and semantic web databases. The advantage of these succinct representations is that they allow querying directly on the succinct representation, without needing to consult the underlying database.

The goal of this thesis is to study scalable algorithms for constructing the actual succinct representations. Some in-memory algorithms are already known, but given the large size of typical database, distributed and out-of-core alternatives need to be found.

Deliverables:

  • Overview of the state of the art in main-memory, and distributed (bi)simulation-based compression algorithms (document)
  • Description of the simulation-based compression algorithm to implement (document)
  • Selection of the distribution framework (Actors, Pregel, …) (document)
  • Simulation algorithm (software artifact)
  • Experimental analysis of distributed algorithm on a number of datasets. (document)

Interested? Contact : Stijn Vansummeren

Status: available

A Scala-based runtime and compiler for Distributed Datalog

Datalog is a fundamental query language in datamanagement based on logic programming. It essentially extends select-from-where SQL queries with recursion. There is a recent trend in data management research to use datalog to specify distributed applications, most notably on the web, as well as do inference on the semantic web. The goal of this thesis is to engineer a basic distributed datalog system, i.e., a system that is capable of compiling & running distributed datalog queries. The system should be implemented in the Scala programming language. Learning Scala is part of the master thesis project.

The system should incorporate recently proposed worst-case join algorithms (i.e., the leapfrog trie join) and employ known local datalog optimizations (such as magic sets and QSQ.)

Validation of the approach The thesis should propose a benchmark collection of datalog queries and associated data workloads that be used to test the obtained system, and measure key performance characteristics (elasticity of the system; memory frootprint; overall running time, …)

Deliverables:

  • Semantics of datalog; overview of known optimization strategies (document)
  • Description of the leapfrog trie join (document)
  • Datalog system (software artifact)
  • Experimental analysis of developped system on a number of use cases (document)


Interested? Contact : Stijn Vansummeren

Status: available

Semi-Supervised Entity Resolution

Toon Calders (WIT)

In the big data era large collections of data have become available for analysis. These data, however, often come from different data sources and may contain errors. Consider for instance a company that wants to combine data from marketing and sales in order to see to what extent the targeted marketing campaign has been successful in attracting new customers. A key operation in this analysis is the identification of which records from marketing and sales refer to the same person. In this way it can be determined which targeted potential customers were already clients, and of the contacted non-clients, which ones reacted to the marketing campaign. Furthermore, most likely the records of marketing are far less reliable and formatted differently than those of sales. For instance, the marketing records won't usually contain a client number. The process of linking these sources together and identifying which records refer to the same person is know as entity resolution. Most existing approaches for entity resolution use either a fixed set of pre-determined rules, which may be sub-optimal for the problem at hand, or are based on learning classifiers which requires large amounts of labelled data.

In this thesis you will study the possibility of entity-resolution in the absence of large collections of labelled data, by exploiting redundancies in the features with which records can be compared in combination with an active learning approach in which volunteers can be asked to label some examples on the fly.
Interested? Contact Toon Calders

Using Non-Redundant Sequential Pattern Mining for Process Discovery

Toon Calders (WIT)

Process mining is the act of deriving a process model, such as for instance a Petri-net or a BPMN model, based on an event log. An example of such a log could be all events that an insurance company undertakes for pricing a car insurance based on a request from a client. Events could be looking up if the client has been blacklisted, his or her history w.r.t. car accidents, estimating the risk based on car type, age and gender of the requester, making a proposal, soliciting the agreement of the client, in case of disagreement, contacting a manager to approve a special offer, etc. Based on several traces for different clients may allow the automatic reconstruction of a process model. There exist several approaches for process mining, including footprint based algorithms such as Alpha, Alpha+, heuristic algorithms including heuristics miner, genetic algorithms, region based methods, etc. The goal of this thesis is to explore the possibility of using current state-of-the-art data mining algorithms for sequence and episode mining as a basis of a new and improved version of the alpha-algorithm.

Van der Aalst, W. M. (2011). Process Mining: Discovery, Conformance and Enhancement of Business Processes. Springer.

Interested? Contact Toon Calders

Mining patterns for compression

Toon Calders (WIT)

Data mining is the research discipline that studies the extraction of information from large amounts of data. One of the typical data mining tasks is pattern mining where we try to find regularities that occur frequently in a dataset. The prototypical example is that of a supermarket storing for every customer visiting the supermarket, the transaction; that is, the set of items that were bought by that customer. The frequent itemset mining problem now is to detect which combinations of products were more often sold together than a given threshold. One of the major problems of pattern mining algorithms, however, is the enormous amount of redundant patterns they generate; for instance, very popular items, such as toilet paper, tend to appear in many frequent combinations purely due to chance. In order to deal with this problem, techniques based upon compression and minimum description length were proposed to reduce the number of patterns. The rationale behind the minimal description length principle is that a set of patterns that describes well what is happening in the dataset should allow for a good compression. For a collection of patterns, the quality is measured as the description length of the patterns plus the size of the data compressed with these patterns. For instance, if the pattern {bread, milk, butter} has a high frequency, we could opt to replace every occurrence of this pattern by a special code, effectively reducing the encoding length of the data. Surprisingly, however, the MDL principle was until now only used to rule out redundant patterns, and it has not been researched yet how well the discovered patterns actually do compress the data as compared to compression algorithms such as Lempel–Ziv–Welch. Hence, in this highly research oriented graduation project, two research questions are central: (1) How good do non-redundant pattern sets based on MDL allow compressing data, and (2) Can we extract useful patterns from existing compression algorithms?

Interested? Contact Toon Calders

Publishing and Using Spatio-temporal Data on the Semantic Web

RDF is the W3C proposed framework for representing information in the Web. Basically, information in RDF is represented as a set of triples of the form (subject,predicate,object). RDF syntax is based on directed labeled graphs, where URIs are used as node labels and edge labels. The Linked Open Data (LOD) initiative is aimed at extending the Web by means of publishing various open datasets as RDF, setting RDF links between data items from different data sources. Many companies and government agencies are moving towards publishing data following the LOD initiative. In order to do this, the original data must be transformed into Linked Open Data. Although most of these data are alphanumerical, most of the time they contained a spatial or spatio-temporal component, that must also be transformed. This can be exploited by application providers, that can build attractive and useful applications, in particular, for devices like mobile phones, tablets, etc.

The goals of this thesis are: (1) study the existing proposals for mapping spatio-temporal data into LOD; (2) apply this mapping to a real-world case study (as was the case for the Open Semantic Cloud for Brussels project; (3) Based on the produced mapping, and using existing applications like the Linked Geo Data project, build applications that make use of LOD for example, to find out which cultural events are taking place at a given time at a given location.

Extending SPARQL for Spatio-temporal Data Support

SPARQL is the W3C standard language to query RDF data over the semantic web. Although syntactically similar to SQL, SPARQL is based on graph matching. In addition, SPARQL is aimed, basically, to query alphanumerical data. Therefore, a proposal to extend SPARQL to support spatial data, called GeoSPARQL, has been presented to the Open Geospatial Consortium.

In this thesis we propose to (1) perform an analysis of the current proposal for GeoSPARQL; (2) a study of current implementations of SPARQL that support spatial data; (3) implement simple extensions for SPARQL to support spatial data, and use these language in real-world use cases.

 
teaching/mfe-it4bi.txt · Last modified: 2015/06/26 11:21 by svsummer