Guess the graph exploration system
Sponsored Links
This presentation is the property of its rightful owner.
1 / 55

GUESS The Graph Exploration System PowerPoint PPT Presentation


  • 103 Views
  • Uploaded on
  • Presentation posted in: General

GUESS The Graph Exploration System. Eytan Adar November 23, 2005. Existing tools, toolkits. Really good options exist Prefuse (Heer et al) JUNG (Fischer et al) GVF (Marshall) But… Need to know how to program Not easy to use for prototyping Program -> compile -> run cycle Too general…

Download Presentation

GUESS The Graph Exploration System

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript


GUESSThe Graph Exploration System

Eytan Adar

November 23, 2005


Existing tools, toolkits

  • Really good options exist

    • Prefuse (Heer et al)

    • JUNG (Fischer et al)

    • GVF (Marshall)

  • But…

    • Need to know how to program

    • Not easy to use for prototyping

      • Program -> compile -> run cycle

  • Too general…

    • Don’t take into account the nature of graphs


Existing tools, full programs

  • Biology focus

    • Cytoscope

  • Social network focus

    • UCINET/Krackplot

    • Pajek

  • Problems

    • Too specific

    • Overwhelming

      • Pajek interface


Design requirements

  • Deal with different kinds of networks

    • But not by abstracting everything to a matrix

      • Nodes and edges have properties!

  • Exploratory tool

    • Tolerate mistakes made in exploration

  • Ability to easily do standard analysis

  • Ability to add new analysis routines

  • Scriptable

  • Compile into application/applet

  • Flexible front/back ends


GUESS

  • Originally “Zoomgraph”

    • Limited scripting (big if-else loop)

    • Problem: actually got users

      • Users want things

  • GUESS was designed to handle new demands

    • Has a real programming language for scripting

    • Pluggable visualizations


Screenshot


GUESS

  • “Gython”

    • Python + graph data structures + operators + query language

  • Better (expandable/separable) architecture

    • Back-end storage abstracted

    • Front-end visualization abstracted

      • Prefuse

      • Touchgraph

      • Still have one main “zoomable” front end

        • The most complete


Demo


A Domain Specific (Embedded) Language

  • Took existing jython core and modified it

    • New operators ( ->, <-, <->, rcontains, etc.)

      • node1->node2

      • (node1,node2)->(node3,node5)

    • Better integration with Java

    • Automatic set mapping

      • (node1,node2,node3).color = red

    • If you know python or jython you should be comfortable in this space, but can also write Java code if you prefer


Query language built in

  • Nodes and Edges have properties

    • The usual types (text, numbers, Booleans)

  • Can use these to manipulate the display

    • (dept == ‘Human Resources’).color = blue

    • (freq > 10).width = 4

    • (cell_location == ‘wall’) & (expression_levels > 100)

    • (name like ‘Bob%’)


Users don’t care…

  • Top level namespace contains all the objects you may want to play with directly

    • g = the working graph

    • Each node uniquely named

    • Each edge set uniquely accessed

      • a->b

    • Property objects also automatically created

      • (freq > 100) and also...

      • freq.max

  • Immutable

    • EDA  shouldn’t have to start from scratch

    • Distinction between invisible and deleted

      • “deleted” objects actually sit around in special (queryable) state.


Users don’t care…

  • Objects have methods

    • g.gemLayout()

  • But, users don’t remember…

  • Automatic script finds all methods and loads them as built in functions

  • In Gython:

    • g.gemLayout()  gemLayout()  gemLayout()

    • Calls appropriate Java code

    • someFunction(x,y) vs. someFunction(x)


Getting data in

  • GUESS lets you define your own properties

nodedef> name, country VARCHAR

N1,”US”

N2,”France”

edgedef> node1,node2, delay INT default 5

N1,N2,20


Visual properties built in…

  • GUESS knows about visual properties

    • Nodes

      • location, color, size, shape, label, etc.

    • Edges

      • width, color, etc.

  • (Non-visual) properties generated dynamically

    • e.g. indegree, pagerank, betweeenness

  • Everything accessed same way

    • v3.color v3.dept v3.indegree


Visual shortcuts

  • Lots of syntactic sugar to do certain things

    • Color each department differently

      • colorize(dept)

    • Color each edge by frequency from red to blue

      • colorize(freq,red,blue)

  • Can group and sort by properties

    • depts = groupBy(dept)

    • freqs = sortBy(freq)

    • whatever = groupAndSortBy(…)


Built in functions

  • Layouts

  • Clustering algorithms

  • Shortest path/Flow algorithms

  • Centrality measures

  • Graph statistics

  • Plots and charts

  • Can even connect to R for more


Demo


Connect interpreter to display

  • Unique feature of GUESS

  • Mouse motion over text results in highlighting of graph/visualization structures

  • [[v4,v5],[v6,v7,v8]]

  • Contextual menus

    • Same menus pop up in display and in text window

    • Menus contextualized to type

  • “Copy as variable”


Demo


States and Time

  • As if graphs weren’t complicated enough…

    • Time is a critical dimension

    • Graphs and properties change

    • We want to visualize them

  • And users in an exploratory mode want undo

  • Kill two birds with one stone…


States and Time

  • Basics through simple commands

    • ss(‘state name’)

    • ls(‘state name’)

  • Queries work between states

    • v44[‘q105’].dept

    • freq[2005] > freq[2003]

  • Morphing

    • morph(‘state name’,time)

    • output as movie

    • Camera tracking (in Zoomgraph and soon in GUESS)

  • Also… “range” fields

    • “1,5-100,102-105”

    • Node rcontains (5,10)

    • Node rexact (102-105)


Extending GUESS

  • Write your own routines/programs

  • Change mouseover/click behavior

    • E.g. pop up a web page

  • Control remotely or through Java

  • Add “dockable” widgets

  • Replace front end

  • Compile into applet


Simple Example: Skitter


Skitter

def skitter(_field):

_maxangle = 2 * Math.PI

_ordering = sortBy(_field)

_increment = _maxangle / len(_ordering)

_curangle = 0

g.nodes[0].outdegree

_maxdeg = outdegree.max + 1.0

for _n in _ordering:

_radius = 1 - Math.log((_n.outdegree + 1.0) / _maxdeg)

_radius = _radius * 500.0

_x = 500.0 + _radius * Math.cos(_curangle)

_y = 500.0 + _radius * Math.sin(_curangle)

_n.setX(_x)

_n.setY(_y)

_curangle += _increment


Skitter


Modify the interface

import …

class dockexample1(com.hp.hpl.guess.ui.DockableAdapter):

def __init__(self):

testButton = JButton("center")

action = lambda event: center()

testButton.actionPerformed = action

self.add(testButton)

def getTitle(self):

return("dockexample1")


Modify the interface

def sc(self,evt):

val = self.testSlider.getValue()

g.nodes.visible = 1

(freq < val).visible = 0

(freq >= val).visible = 1

self.hideDisconnectedNodes()

self.label.setText("Frequency threshold ("+str(val)+")")


Modify the interface

import …

class dockexample2(com.hp.hpl.guess.ui.DockableAdapter):

testSlider = JSlider()

label = JLabel("Frequency threshold (0) ")

def __init__(self):

self.testSlider.setMinimum(freq.min)

self.testSlider.setValue(freq.min) # default value

self.testSlider.mouseReleased = self.sc

self.add(self.label)

self.add(self.testSlider)

ui.dock(self)


Modify the interface

def hideDisconnectedNodes(self):

toHide = []

for nod in g.nodes: # for all nodes

vis = 0 # default to invisble

for ed in nod.getOutEdges():

if (ed.visible == 1):

vis = 1

break

if (vis == 0): # should we hide the node?

toHide += [nod]

# hide all the nodes we put in our list

toHide.visible = 0


Compiling and distributing…

  • Users build applets/applications

    • Network simulation

    • Political blogs

  • I’ve heard of:

    • Neuroscience and sewer/water lines


Front end flexibility

  • Can replace the visualization

    • I like Piccolo

    • But…

      • Prefuse

      • Touchgraph

      • JUNG

      • and soon Wilma (3D)

    • Are also available


Scaling…

  • Not bad…

    • Graphics will slow you down

    • Algorithms are pretty fast

  • You can…

    • Load up a big dataset

    • Do a faster layout (gemLayout())

    • Go to lunch

    • Play with graph


~2000


~6000 nodes


~12000 nodes


Politics and Blogs

Adamic & Glance, 2005


Viral marketing

Leskovec, Adamic, and Huberman, 2005


Social groups

Adamic, Adar, 2003


Email communications

Adamic, Adar, 2005


Information Flow

Adar, Zhang, Adamic, Lukose, 2004


Summary… (end Eytan’s slides)

  • Exploratory data analysis

  • Free (GPL)

    • http://www.graphexploration.org


Other visualization tools: Walrus

  • developed at CAIDA available under the GNU GPL.

  • “…best suited to visualizing moderately sized graphs that are nearly trees. A graph with a few hundred thousand nodes and only a slightly greater number of links is likely to be comfortable to work with.”

  • Java-based

  • Implemented Features

    • rendering at a guaranteed frame rate regardless of graph size

    • coloring nodes and links with a fixed color, or by RGB values stored in attributes

    • labeling nodes

    • picking nodes to examine attribute values

    • displaying a subset of nodes or links based on a user-supplied boolean attribute

    • interactive pruning of the graph to temporarily reduce clutter and occlusion

    • zooming in and out


Other visualization tools: GraphViz

  • Takes descriptions of graphs in simple text languages

  • Outputs images in useful formats

  • Options for shapes and colors

  • Standalone or use as a library

    • dot: hierarchical or layered drawings of directed graphs, by avoiding edge crossings and reducing edge length

    • neato (Kamada-Kawai) and fdp (Fruchterman-Reinhold with heuristics to handle larger graphs)

    • twopi – radial layout

    • circo – circular layout

http://www.graphviz.org/


Dot (GraphViz)


Neato (Graphviz)


YEd - JavaTM Graph Editorhttp://www.yworks.com/en/products_yed_about.htm(good primarily for layouts, maybe free)


Perfuse

  • (free) user interface toolkit for interactive information visualization

    • built in Java using Java2D graphics library

    • data structures and algorithms

    • pipeline architecture featuring reusable, composable modules

    • animation and rendering support

    • architectural techniques for scalability

  • requires knowledge of Java programming

  • website: http://prefuse.sourceforge.net/

    • CHI paper http://guir.berkeley.edu/pubs/chi2005/prefuse.pdf


Simple prefuse visualizations


Examples of prefuse applications: flow maps

A flow map of migration from California from 1995-2000, generated automatically by our system using edge routing but no layout adjustment.

  • http://graphics.stanford.edu/papers/flow_map_layout/


Examples of prefuse applications: viszter

  • http://jheer.org/vizster/


Network visualization + analysis: UCInet

  • UCInet – not free, but widely used for studying social networks

  • Can handle small to medium (10,000 node) networks

  • Social network analysis methods include

    • centrality measures

    • subgroup identification

    • role analysis

    • elementary graph theory

    • permutation-based statistical analysis.

  • Also includes:

    • strong matrix analysis routines

      • matrix algebra and multivariate statistics.

  • Integrated with UCINET is the NetDraw program for drawing diagrams of social networks

  • http://www.analytictech.com/ucinet.htm


JUNGJava Universal Network/Graph Framework

  • open source java library

    • homepage: http://jung.sourceforge.net/

    • requires knowledge of Java – but is infinitely extensible

  • supports

    • Graphs

      • directed and undirected

      • multi-modal

      • multigraphs

      • hypergraphs.

    • Metadata

    • Algorithms from graph theory, data mining, and social network analysis routines

      • clustering

      • decomposition

      • optimization

      • random graph generation

      • statistical analysis

      • network distances

      • flows

      • importance measures (centrality, PageRank, HITS, etc.).

  • visualization framework that makes it easy to construct tools for the interactive exploration of network data.

    • built-in layout algorithms provided

    • ability to create custom layouts


R routines for social network analysis

  • R is an open source statistical computing environment (using the S language, like S-Plus – a commercial version)

  • Both Pajek and GUESS can interface to R

  • R has a specialized social network analysis package

    • written by Carter Butts at UCI: http://erzuli.ss.uci.edu/R.stuff/

    • lots of different functions


  • Login