bordeaux20142015:bordeaux_edition

**This is an old revision of the document!**

Instructors: Guy Melançon (email: `Guy dot Melancon at labri dot fr`

), Bruno Pinaud (email: `Bruno dot Pinaud at labri dot fr`

)

- You need to form teams (2 persons).
- Please email us to let us know who you work with.
- You need to select domain questions (one will certainly not be enough …) you will answer by foraging data.
- Your answer must be backed up by evidence relying on data supported by relevant visualization.
- You need to document your conclusions, provide a written report covering all methodology used.
- Tell us who's wiki pages we can find the report. Do not upload a flat and dull pdf file, create wiki pages. Use images to illustrate your report.

- You need to upload any specific algorithms and/or scripts you have used.

- You will be evaluated on
- the astute aspect of your work;
- the difficulty of the task;
- the technicality and innovativeness of the solution/s;
- the quality of your oral and written report;

- If the question is to simple to answer, think of refinements that make it more challenging;
- 15 minutes oral presentations will take place as a face-to-face interviews in January (date to be confirmed) – no powerpoint or anything, bring a laptop to show short demos and live data/scripts.

Access this page to know more about the available datasets and potential questions.

Remember that Tulip in installed in the CREMI in `/net/ens/tulip4`

. It should always be the latest svn version compiled by hand. It can be launched with `/net/ens/tulip4/bin/tulip`

or to directly launch the graph manipulation perspective `/net/ens/tulip4/bin/tulip_perspective -p Tulip`

. If you find a bug, do not hesitate to show it to us!!

This first portion of the course is meant to introduce the topic of the course, motivate this still new research field although examples are there to indicate ideas go back to ancient times.

Have a look at the slides showed in the class.

It does include a comprehensive course on Tulip so students are able to work by themselves using the framework.

- InfoVis by examples
- Florence Nightingale, an example showing how visualization may be misleading …
- White house budget directly from the White House website
- Obama's 2012 Budget from the New-York Times website
- Visualization in action (using Tulip / directory import (tree layout, 2 1/2 D); poker players)

Because we want to actually 'do' things, we need to devote time learning how to use the Tulip framework (developed here at LaBRI). We worked on several examples showing many tulip functionalities:

- Visual analytics (scatterplot view, parallel coordinates view) with the poker players dataset,
- Data import from a csv file with the 2004 cars dataset. The data comes from the Interactive Data Visualization Book which is a recommended lecture.
`python`

API (see Tulip's website)`python`

view

The Python part of the course or lesson will consists in:

- getting a graph (File/Import)
- we will start by making our own graph (a grid graph)
- you may also want to try the Grid, or Grid Approximation Tulip plugin

- computing a spanning tree out of it (python script)
- use a simple data structure like a stack or queue to drive the computation of a spanning tree, it's a few lines algorithm (python has a handy
`Queue`

library)

- applying a layout algorithm to the tree subgraph
- your spanning tree algorithm could well use a boolean property to select what edges (and all nodes) are selected to form the tree. Once you have that, use the
`addSubGraph`

method to build a subgraph - apply a tree layout algorithm to the tree. Use the
`applyLayoutAlgorithm`

method. It requires that you hand it a layout property. Use the`getLayoutProperty`

to grasp the`viewLayout`

property so the new positions for nodes will automatically be transferred to the whole graph (this is automagically done by Tulip. See the beginning of`main`

Python function in the Python script view.

- playing with node/edge properties to make this as readable as possible
- grasp the color property
`viewColor`

. Create and instance a light gray color`tlp.Color(192, 192, 192)`

or`tlp.Color.Gray`

for instance. iterate over edges and turn the non selected edges to gray (`viewColor.setEdgeValue(edge, tlp.Color.Gray)`

)

Here is a solution (will be available after the course). Have fun.

**Network metrics** This lecture was partly based on the chapter concerning network metrics. Half of the course was devoted to defining a few metrics on graphs: node degree (obvious while easily interpretable and extremely useful); clustering coefficient (also quite informative although more tedious to compute on some graphs); node betweenness centrality. We then looked into random walk version of node degree and (second order) centrality to scale the se metrics to large graphs.

Graph Drawing: Walker algorithm, sugiyama heuristics and introduction to graph drawing based on physical analogy. Slides showed during the lecture

See **Di-Battista, G.; Eades, P.; Tamassia, R. & Tollis, I.-G. Graph drawing – Algorithms for the visualization of graphs Prentice-Hall, 1999** for a nice introduction to graph drawing.

Hierarchical graph drawing (also called Layered drawing)

See this paper for a complete overview.

- You are asked to implement either
- Sindre's nested boxes (onion trees) algorithm for trees,
the H-tree layout by Eades*or*

- Your algorithm should start from an existing tree (use Tulip general tree random generator to test) and
from the previous layout to the next. The idea here is to force you to play with layout animation.*animate the change* - You need to submit your work on
*October 20 (Monday), before 9am, at the latest*.

Plotting (non graph) high-dimensional data (links with the MDS part of the course).

Graph clustering. Multi-dimensional graph clustering (K-Means, CURE, …), hierarchical clustering

Multilevel graph navigation

Divide and conquer - drawing and manipulating graph hierarchies with Tulip We will use the following file to play with graph hierarchies infovis_clean.tlpx. The work to do is described in this document hierarchies.pdf.

Let's continue to work on Multilevel graph navigation

Graph clustering.

- Parallel to hierarchical agglomerative clustering for high-dimensional data. Need to define what a “good” clustering is for a graph – no Huygens criteria this time.
- Newman modularity is such a criteria.
- Implementation of a hierarchical agglomerative clustering using Newman's criteria, computing incremental improvements of cluster merge.

Text mining & Document visualization

Project coaching

Project coaching

Project evaluation

/net/html/perso/melancon/Visual_Analytics_Course/data/attic/bordeaux20142015/bordeaux_edition.1417080863.txt.gz · Last modified: 2014/11/27 10:34 by melancon