pyemma.plots.plot_network

pyemma.plots.plot_network(weights, pos=None, xpos=None, ypos=None, state_sizes=None, state_scale=1.0, state_colors='#ff5500', state_labels='auto', arrow_scale=1.0, arrow_curvature=1.0, arrow_labels='weights', arrow_label_format='%2.e', max_width=12, max_height=12, figpadding=0.2, attribute_to_plot='net_flux', show_frame=False, xticks=False, yticks=False, ax=None, **textkwargs)

Network representation of given matrix

This visualization is not optimized for large networks. It is meant to be used for the visualization of small models with up to 10-20 states. If used with large network, the automatic node positioning will be very slow and may still look ugly.

Parameters:
  • weights (ndarray(n, n)) – weight matrix
  • pos (ndarray(n,2), optional, default=None) – User-defined positions to draw the states on.
  • xpos (ndarray(n,), optional, default=None) – Fixes the x positions while the y positions are optimized
  • ypos (ndarray(n,), optional, default=None) – Fixes the y positions while the x positions are optimized
  • state_sizes (ndarray(n), optional, default=None) – User-defined areas of the discs drawn for each state. If not given, the stationary probability of P will be used
  • state_colors (string, ndarray(n), or list, optional, default='#ff5500' (orange)) –
    string :
    a Hex code for a single color used for all states
    array :
    n values in [0,1] which will result in a grayscale plot
    list :
    of len = nstates, with a color for each state. The list can mix strings, RGB values and hex codes, e.g. state_colors = [‘g’, ‘red’, [.23, .34, .35], ‘#ff5500’] is possible.
  • state_labels (list of strings, optional, default is 'auto') – A list with a label for each state, to be displayed at the center of each node/state. If left to ‘auto’, the labels are automatically set to the state indices.
  • arrow_scale (float, optional, default=1.0) – Relative arrow scale. Set to a value different from 1 to increase or decrease the arrow width.
  • arrow_curvature (float, optional, default=1.0) – Relative arrow curvature. Set to a value different from 1 to make arrows more or less curved.
  • arrow_labels ('weights', None or a ndarray(n,n) with label strings. Optional, default='weights') – Strings to be placed upon arrows. If None, no labels will be used. If ‘weights’, the elements of P will be used. If a matrix of strings is given by the user these will be used.
  • arrow_label_format (str, optional, default='%10.2f') – The numeric format to print the arrow labels
  • max_width (int (default = 12)) – The maximum figure width
  • max_height (int (default = 12)) – The maximum figure height
  • figpadding (float (default = 0.2)) – The relative figure size used for the padding
  • show_frame (boolean (default=False)) – Draw a frame around the network.
  • xticks (boolean (default=False)) – Show x ticks
  • yticks (boolean (default=False)) – Show y ticks
  • ax (matplotlib Axes object, optional, default=None) – The axes to plot to. When set to None a new Axes (and Figure) object will be used.
  • textkwargs (optional argument for the text of the state and arrow labels.) – See http://matplotlib.org/api/text_api.html#matplotlib.text.Text for more info. The parameter ‘size’ refers to the size of the state and arrow labels and overwrites the matplotlib default. The parameter ‘arrow_label_size’ is only used for the arrow labels; please note that ‘arrow_label_size’ is not part of matplotlib.text.Text’s set of parameters and will raise an exception when passed to matplotlib.text.Text directly.
Returns:

(fig, pos) – Axes instances containing the plot. Use pyplot.show() to display it. The positions of states. Can be used later to plot a different network representation (e.g. the flux).
Return type:

matpotlib.Figure instance, ndarray

Examples

We define first define a reactive flux by taking the following transition matrix and computing TPT from state 2 to 3

>>> import numpy as np
>>> P = np.array([[0.8,  0.15, 0.05,  0.0,  0.0],
...               [0.1,  0.75, 0.05, 0.05, 0.05],
...               [0.05,  0.1,  0.8,  0.0,  0.05],
...               [0.0,  0.2, 0.0,  0.8,  0.0],
...               [0.0,  0.02, 0.02, 0.0,  0.96]])

Scale the flux by 100 is basically a change of units to get numbers close to 1 (avoid printing many zeros). Now we visualize the flux:

>>> plot_network(P) 
(<matplotlib.figure.Figure..., array...)