From 5e5db3f1ed8a2a4fa4a9048a925c2b3831e08e9c Mon Sep 17 00:00:00 2001 From: wingedRuslan Date: Mon, 12 Aug 2019 13:47:50 +0300 Subject: [PATCH 1/9] Add test of jupyter notebooks(including visualisations) in tutorials/ directory --- .travis.yml | 1 + requirements.txt | 1 + 2 files changed, 2 insertions(+) diff --git a/.travis.yml b/.travis.yml index 41fef08..2b855fc 100644 --- a/.travis.yml +++ b/.travis.yml @@ -14,6 +14,7 @@ install: script: - python3 -m pytest -v --ignore=tests/regression_test.py # temporarily ignore regression tests while we investigate why they are failing + - py.test --nbval-lax tutorials/ - cd docs - make html - touch .nojekyll diff --git a/requirements.txt b/requirements.txt index 68ab726..8b6d316 100644 --- a/requirements.txt +++ b/requirements.txt @@ -10,3 +10,4 @@ scikit-learn networkx>=2.2 forceatlas2 nilearn==0.5.0a0 +nbval From df2167379addb260c0640b4f7f8482126fa9112b Mon Sep 17 00:00:00 2001 From: wingedRuslan Date: Tue, 20 Aug 2019 16:49:57 +0300 Subject: [PATCH 2/9] Add documentation to the plotting section --- docs/source/plotting.rst | 33 +++++++++++++++++++++++++++++++-- 1 file changed, 31 insertions(+), 2 deletions(-) diff --git a/docs/source/plotting.rst b/docs/source/plotting.rst index 4360728..2774913 100644 --- a/docs/source/plotting.rst +++ b/docs/source/plotting.rst @@ -1,5 +1,34 @@ Plotting Brain Networks ======================= -With nilearn ------------- \ No newline at end of file +A good visualisation is worth millions of words. +That's why our community put an emphasis on ensuring that the produced figures are informative and communicate the results clearly. + +The :class:`scona` package has a great visualisation module, which enables you to produce publication-ready plots based on the results of the performed brain network analysis. +You are also able to export created figures (save as a file) to include in a research paper or in a publication. + +As it says the best explanation is through demonstration. That's why we have created `tutorials `_ which are jupyter notebooks that include visualisation examples of the data. +In a clear and easy way, these tutorials explain how different visualisation functions can be used to produce different plots and for better data understanding. + +1. Global Network Measures visualisation `tutorial `_ describes how to use the following functions: + - plot_degree_dist() - tool for plotting the degree distribution + - plot_network_measures() - tool for plotting network measures values + - plot_rich_club() - tool for plotting the rich club values per degree + +With the help of these functions, you can report measures relating to the whole network. + +2. Interactive visualisation `tutorial `_ provides examples on how to use functions like: + - view_nodes_3d() - view the nodes on a 3d plot + - view_connectome_3d() - view the edges - the connections - of the network on a 3d plot + +These tools rely on the excellent `nilearn.plotting library `_. + +3. Anatomical visualisation `tutorial `_ shows the usage of the following functions: + - plot_anatomical_network() - make plots of nodes and edges based on the given anatomical layout + - plot_connectome () - plot connectome on top of the brain glass schematics + +These are static visualisions that you could use to report your findings in a published paper. + + +With proper visualization, a researcher can reveal findings easier, understand complex data relationships and describe obtained insights from analyzed data. + From 08ab78c67debfc5069120153b3bb2df842855e54 Mon Sep 17 00:00:00 2001 From: wingedRuslan Date: Tue, 20 Aug 2019 16:54:18 +0300 Subject: [PATCH 3/9] Update the install command to be same as in the scona github page --- docs/source/introduction.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/source/introduction.rst b/docs/source/introduction.rst index 0343397..63fc811 100644 --- a/docs/source/introduction.rst +++ b/docs/source/introduction.rst @@ -16,7 +16,7 @@ Installing scona You can install scona directly from the GitHub repository:: - pip install git+https://github.com/WhitakerLab/scona.git + pip install -e git+https://github.com/WhitakerLab/scona.git#egg=scona If you want to edit scona it's recommended that you pass the ``-e`` flag to ``pip`` to install the package editably. From e089dfd61d85cc00a949cb5aad3c4cd7f90578b5 Mon Sep 17 00:00:00 2001 From: wingedRuslan Date: Tue, 20 Aug 2019 17:10:53 +0300 Subject: [PATCH 4/9] Make a note about subpackages in the scona --- docs/source/scona.rst | 2 ++ 1 file changed, 2 insertions(+) diff --git a/docs/source/scona.rst b/docs/source/scona.rst index 8178519..d102506 100644 --- a/docs/source/scona.rst +++ b/docs/source/scona.rst @@ -12,6 +12,8 @@ Subpackages scona.wrappers scona.datasets +**Note**: These subpackages (scona.wrappers, scona.scripts, scona.datasets) are represented as a set of features that will be incorporated into scona package. You **should not** open or/and use the code inside these packages, because the code inside **is not supported** and this part is in the alpha development phase. + Module contents --------------- From ca01cd637e7db68a324eb69adff496fc01571862 Mon Sep 17 00:00:00 2001 From: wingedRuslan Date: Fri, 23 Aug 2019 01:55:27 +0300 Subject: [PATCH 5/9] Implement get_anatomical_layouts() function in visualisation_helpers.py --- scona/visualisations_helpers.py | 46 +++++++++++++++++++++++++++++++++ 1 file changed, 46 insertions(+) diff --git a/scona/visualisations_helpers.py b/scona/visualisations_helpers.py index 53dbc4f..dabecdf 100644 --- a/scona/visualisations_helpers.py +++ b/scona/visualisations_helpers.py @@ -440,3 +440,49 @@ def anatomical_layout(x, y, z, orientation="sagittal"): raise ValueError( "{} is not recognised as an anatomical layout. orientation values " "should be one of 'sagittal', 'axial' or 'coronal'.".format(orientation)) # noqa + + +def get_anatomical_layouts(G): + """ + This function extracts the required coordinates of a node based on the given + anatomical layout. + + Parameters + ---------- + + G : :class:`networkx.Graph` + G should have nodal locations in MNI space indexed by nodal + attribute "centroids". + + Returns + ------- + axial_dict, sagittal_dict, coronal_dict dictionaries + Returns three dictionaries containing appropriate pairs of coordinates + for axial, sagittal and coronal slices. + """ + + # create empty dictionaries to store corresponding coordinates + axial_dict = {} + sagittal_dict = {} + coronal_dict = {} + + # check if graph has centroids + if G.graph["centroids"] == False: + raise ValueError("The given BrainNetwork Graph does not have centroids") + + for node in G.nodes: + # get x coordinate + x_coord = G.node[node]["x"] + + # get y coordinate + y_coord = G.node[node]["y"] + + # get z coordinate + z_coord = G.node[node]["z"] + + # store appropriate pairs of coordinates for sagittal, coronal and axial + axial_dict[node] = axial_layout(x_coord, y_coord, z_coord) + sagittal_dict[node] = sagittal_layout(x_coord, y_coord, z_coord) + coronal_dict[node] = coronal_layout(x_coord, y_coord, z_coord) + + return axial_dict, sagittal_dict, coronal_dict From 4736e22e94b4db9556eda07e7d96e3fd125af5b9 Mon Sep 17 00:00:00 2001 From: wingedRuslan Date: Sat, 24 Aug 2019 23:54:51 +0300 Subject: [PATCH 6/9] Remove deprecated file nilearn_plotting.py The code is re-implemented and placed in scona/visualisations.py --- scona/nilearn_plotting.py | 170 -------------------------------------- 1 file changed, 170 deletions(-) delete mode 100644 scona/nilearn_plotting.py diff --git a/scona/nilearn_plotting.py b/scona/nilearn_plotting.py deleted file mode 100644 index a9d2aa9..0000000 --- a/scona/nilearn_plotting.py +++ /dev/null @@ -1,170 +0,0 @@ -from nilearn import plotting -import networkx as nx -import numpy as np - - -def graph_to_nilearn_array( - G, - node_colour_att=None, - node_size_att=None, - edge_attribute="weight"): - """ - Derive from G the necessary inputs for the `nilearn` graph plotting - functions. - G : :class:`networkx.Graph` - G should have nodal locations in MNI space indexed by nodal - attribute "centroids" - node_colour_att : str, optional - index a nodal attribute to scale node colour by - node_size_att : str, optional - index a nodal attribute to scale node size by - edge_attribute : str, optional - index an edge attribute to scale edge colour by - """ - node_order = sorted(list(G.nodes())) - adjacency_matrix = nx.to_numpy_matrix( - G, - nodelist=node_order, - weight=edge_attribute) - node_coords = np.array([G._node[node]["centroids"] for node in node_order]) - if node_colour_att is not None: - node_colour_att = [G._node[node][node_colour_att] for node - in node_order] - if node_size_att is not None: - node_size_att = [G._node[node][node_size_att] for node in node_order] - return adjacency_matrix, node_coords, node_colour_att, node_size_att - - -def plot_connectome_with_nilearn( - G, - node_colour_att=None, - node_colour="auto", - node_size_att=None, - node_size=50, - edge_attribute="weight", - edge_cmap="Spectral_r", - edge_vmin=None, - edge_vmax=None, - output_file=None, - display_mode='ortho', - figure=None, - axes=None, - title=None, - annotate=True, - black_bg=False, - alpha=0.7, - edge_kwargs=None, - node_kwargs=None, - colorbar=False): - """ - Plot a BrainNetwork using :func:`nilearn.plotting.plot_connectome()` tool. - - Parameters - ---------- - G : :class:`networkx.Graph` - G should have nodal locations in MNI space indexed by nodal - attribute "centroids" - node_colour_att : str, optional - index a nodal attribute to scale node colour by - node_size_att : str, optional - index a nodal attribute to scale node size by - edge_attribute : str, optional - index an edge attribute to scale edge colour by - - other parameters are passed to :func:`nilearn.plotting.plot_connectome()` - """ - adjacency_matrix, node_coords, colour_list, size_list = graph_to_nilearn_array(G, node_colour=node_colour_att, node_size=node_size_att, edge_attribute=edge_attribute) - - if node_colour_att is not None: - node_colour = [node_colour(x) for x in colour_list] - if node_size_att is not None: - node_size = [x*node_size for x in size_list] - - plotting.plot_connectome( - adjacency_matrix, node_coords, node_color=node_colour, - node_size=node_size, edge_cmap="Spectral_r", edge_vmin=edge_vmin, - edge_vmax=edge_vmax, edge_threshold=0.01, output_file=output_file, - display_mode=display_mode, figure=figure, axes=axes, title=title, - annotate=annotate, black_bg=black_bg, alpha=alpha, - edge_kwargs=edge_kwargs, node_kwargs=node_kwargs, colorbar=colorbar) - - -def view_connectome_with_nilearn( - G, - edge_attribute="weight", - edge_cmap="Spectral_r", - symmetric_cmap=True, - edgewidth=6.0, - node_size=3.0, - node_colour_att=None, - node_colour='black'): - # node_colour_list=None): - """ - Plot a BrainNetwork using :func:`nilearn.plotting.view_connectome()` tool. - - Parameters - ---------- - G : :class:`networkx.Graph` - G should have nodal locations in MNI space indexed by nodal - attribute "centroids" - node_colour_att : str, optional - index a nodal attribute to scale node colour by - edge_attribute : str, optional - index an edge attribute to scale edge colour by - - other parameters are passed to :func:`nilearn.plotting.view_connectome()` - """ - adjacency_matrix, node_coords, colour_list, z = graph_to_nilearn_array( - G, - edge_attribute=edge_attribute, - node_colour=node_colour_att) - return plotting.view_connectome( - adjacency_matrix, - node_coords, - threshold=None, - cmap=edge_cmap, - symmetric_cmap=symmetric_cmap, - linewidth=edgewidth, - marker_size=node_size) -# if colour_list is None: -# colours = [node_colour for i in range(len(node_coords))] -# else: -# colours = np.array([node_colour(x) for x in colour_list]) -# -# connectome_info = plotting.html_connectome._get_markers(node_coords, -# colours) -# connectome_info.update(plotting.html_connectome._get_connectome( -# adjacency_matrix, node_coords, threshold=None, cmap=edge_cmap, -# symmetric_cmap=symmetric_cmap)) -# connectome_info["line_width"] = edgewidth -# connectome_info["marker_size"] = node_size -# return plotting.html_connectome._make_connectome_html(connectome_info) - - -def view_markers_with_nilearn( - G, - node_size=5., - node_colouring='black'): - """ - Plot nodes of a BrainNetwork using - :func:`nilearn.plotting.view_connectome()` tool. - - Parameters - ---------- - G : :class:`networkx.Graph` - G should have nodal locations in MNI space indexed by nodal - attribute "centroids" - node_colouring : str or list of str, default 'black' - node_colouring will determine the colour given to each node. - If a single string is given, this string will be interpreted as a - a colour, and all nodes will be rendered in this colour. - If a list of colours is given, - """ - a, node_coords, colour_list, z = graph_to_nilearn_array( - G,) - if isinstance(node_colouring, str): - colours = [node_colouring for i in range(len(node_coords))] - elif colour_list is not None: - colours = np.array([node_colouring(x) for x in colour_list]) - return plotting.view_markers( - node_coords, colors=colours, marker_size=node_size) From 98873026b0dde7ca0634d2bb54fe37b941129fbe Mon Sep 17 00:00:00 2001 From: wingedRuslan Date: Sun, 25 Aug 2019 00:22:59 +0300 Subject: [PATCH 7/9] Set the python3 kernel for the tutorial Make tests for global_measures_viz tutorial pass --- tutorials/global_measures_viz.ipynb | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/tutorials/global_measures_viz.ipynb b/tutorials/global_measures_viz.ipynb index e8fc62b..0c789e9 100644 --- a/tutorials/global_measures_viz.ipynb +++ b/tutorials/global_measures_viz.ipynb @@ -1484,9 +1484,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python [conda env:kwPython3]", + "display_name": "Python 3", "language": "python", - "name": "conda-env-kwPython3-py" + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -1498,7 +1498,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.4" + "version": "3.6.8" } }, "nbformat": 4, From 08369c00ad5e98562ebd19c04d9f35e98f7ed0bf Mon Sep 17 00:00:00 2001 From: wingedRuslan Date: Wed, 28 Aug 2019 18:24:23 +0300 Subject: [PATCH 8/9] Remove the old global_network tutorial The most recent relevant is global_measures_viz tutorial --- tutorials/global_network_viz.ipynb | 1511 ---------------------------- 1 file changed, 1511 deletions(-) delete mode 100644 tutorials/global_network_viz.ipynb diff --git a/tutorials/global_network_viz.ipynb b/tutorials/global_network_viz.ipynb deleted file mode 100644 index 9a9c626..0000000 --- a/tutorials/global_network_viz.ipynb +++ /dev/null @@ -1,1511 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Gloabl network visualisation tutorial\n", - "\n", - "In the [`introductory_tutorial`](introductory_tutorial.ipynb) we ran through building structural covariance network analyses using `scona`🍪.\n", - "\n", - "In this tutorial we'll cover some of the visualisation tools that communicate global network measures from your results.\n", - "\n", - "Click on any of the links below to jump to that section\n", - "* [Get set up](#Get-set-up) (make sure to run this section before jumping into any of the others!)\n", - "* [Visualise the degree distribution: `plot_degree`](#Visualise-the-degree-distribution%3A-%3Ccode%3Eplot_degree%3C%2Fcode%3E)\n", - "* [Report the global measures of the graph: `report_global_measures`](#Report-the-global-measures-of-the-graph%3A-%3Ccode%3Ereport_global_measures%3C%2Fcode%3E)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Get set up\n", - "\n", - "### Import the modules you need" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "import scona as scn\n", - "import scona.datasets as datasets\n", - "import numpy as np\n", - "import networkx as nx\n", - "import pandas as pd\n", - "from IPython.display import display\n", - "\n", - "import matplotlib.pyplot as plt\n", - "import seaborn as sns\n", - "%matplotlib inline\n", - "\n", - "%load_ext autoreload\n", - "%autoreload 2" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Read in the data, build a network and calculate the network metrics\n", - "\n", - "If you're not sure about this step, please check out the [`introductory_tutorial`](introductory_tutorial.ipynb) notebook for more explanation." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "collapsed": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " Creating 10 random graphs - may take a little while\n" - ] - } - ], - "source": [ - "# Read in sample data from the NSPN WhitakerVertes PNAS 2016 paper.\n", - "df, names, covars, centroids = datasets.NSPN_WhitakerVertes_PNAS2016.import_data()\n", - "\n", - "# calculate residuals of the matrix df for the columns of names\n", - "df_res = scn.create_residuals_df(df, names, covars)\n", - "\n", - "# create a correlation matrix over the columns of df_res\n", - "M = scn.create_corrmat(df_res, method='pearson')\n", - "\n", - "# Initialise a weighted graph G from the correlation matrix M\n", - "G = scn.BrainNetwork(network=M, parcellation=names, centroids=centroids)\n", - "\n", - "# Threshold G at cost 10 to create a binary graph with 10% as many edges as the complete graph G.\n", - "G10 = G.threshold(10)\n", - "\n", - "# Create a GraphBundle object that contains the G10 graph called \"real_graph\"\n", - "bundleGraphs = scn.GraphBundle([G10], [\"real_graph\"])\n", - "\n", - "# Add ten random graphs to this bundle\n", - "# (In real life you'd want more than 10 random graphs,\n", - "# but this step can take quite a long time to run so \n", - "# for the demo we just create 10)\n", - "bundleGraphs.create_random_graphs(\"real_graph\", 10)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Visualise the degree distribution: `plot_degree`\n", - "\n", - "The degree of each node is the number of edges adjacent to the node.\n", - "For example if a node is connected to four other nodes then its degree is 4.\n", - "If it is connected to 50 other nodes, its degree is 50.\n", - "\n", - "Brain networks are usually [\"scale-free\"](https://en.wikipedia.org/wiki/Scale-free_network) which means that their degree distribution follows a power law.\n", - "You can think of them as having a \"heavy tail\": there are a small number of nodes that have a large number of connections.\n", - "\n", - "This is in contrast to - for example - an Erdős–Rényi graph where each node is connected to the others with a set, random probability.\n", - "This graph is often called a [binomial graph](https://en.wikipedia.org/wiki/Erd%C5%91s%E2%80%93R%C3%A9nyi_model) because the probability of connections follows a binomial (Yes-No) distribution.\n", - "\n", - "One of the first things to check for the structural covariance network analysis with `scona` is that our degree distribution shows this pattern." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Look at the data\n", - "\n", - "The degree distribution is already saved in the `G10` graph object.\n", - "But we'll just spend a few moments showing how you can access that information.\n", - "\n", - "You can make a dictionary of the node ids (the dictionary key) and their degree (the dictionary value)." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Node: 0 has degree = 47\n", - "Node: 50 has degree = 16\n", - "Node: 100 has degree = 80\n", - "Node: 150 has degree = 9\n", - "Node: 200 has degree = 11\n", - "Node: 250 has degree = 37\n", - "Node: 300 has degree = 25\n" - ] - } - ], - "source": [ - "degrees = dict(G10.degree())\n", - "\n", - "# Print the degree of every 50th node to show what's inside this dictionary\n", - "for node_id, degree in list(degrees.items())[::50]:\n", - " print ('Node: {:3d} has degree = {:2d}'.format(node_id, degree))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "You can see the information for a specific node from the graph itself.\n", - "\n", - "Although note that the degree needs to be calculated.\n", - "It hasn't been added to the attributes yet." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'name': 'lh_insula_part3',\n", - " 'x': -37.400137000000001,\n", - " 'y': -8.5937070000000002,\n", - " 'z': 4.4363890000000001,\n", - " 'centroids': array([-37.400137, -8.593707, 4.436389])}" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Display the nodal attributes\n", - "G10.nodes[150]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "`scona` has a command for that.\n", - "Lets go ahead and add the degree to the nodal attributes....along with a few other measures." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'name': 'lh_insula_part3',\n", - " 'x': -37.400137000000001,\n", - " 'y': -8.5937070000000002,\n", - " 'z': 4.4363890000000001,\n", - " 'centroids': array([-37.400137, -8.593707, 4.436389]),\n", - " 'module': 1,\n", - " 'degree': 9,\n", - " 'closeness': 0.39308578745198464,\n", - " 'betweenness': 0.0011242664849842761,\n", - " 'shortest_path_length': 2.5357142857142856,\n", - " 'clustering': 0.5277777777777778,\n", - " 'participation_coefficient': 0.0}" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Calculate nodal measures for graph G10\n", - "G10.calculate_nodal_measures()\n", - "\n", - "# Display the nodal attributes\n", - "G10.nodes[150]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Look at all that information!\n", - "\n", - "We only want to visualise the degree distribution at the moment though." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Import the code you need: `plot_degree_dist`" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "# import the function to plot network measures\n", - "from scona.visualisations import plot_degree_dist" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Plot the degree distribution\n", - "\n", - "We only need the BrainNetwork graph to plot the degree distribution." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Default settings\n", - "\n", - "By default we add an Erdős–Rényi random graph that has the same number of nodes as our BrainNetwork Graph for comparison.\n", - "The default colours are blue for the degree distribution of the real graph and a grey line for the random graph." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_degree_dist(G10)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Without the random graph\n", - "\n", - "The random graph is a good sanity check that your degree distribution is not random...but it rather swamps the plot.\n", - "So this example allows you to plot only the degree distribution of the real graph, without the random graph." - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_degree_dist(G10, binomial_graph=False)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Save the plot\n", - "\n", - "You can save this figure in any location.\n", - "\n", - "You can do that by passing a file name and (optional) directory path to the `figure_name` option. \n", - "If you don't set a directory path the figure will be saved in the local directory.\n", - "\n", - "For this tutorial we'll save the output in a `figures` folder inside this `tutorials` directory." - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_degree_dist(G10, binomial_graph=False, figure_name=\"figures/DegreeDistribution.png\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "☝️ Did you see an error message?\n", - "\n", - "The code checks to see if the directory that you want to save your figure to actually exists.\n", - "If it doesn't then it creates the directory, but gives you a little warning first to check that it isn't coming as a surprised (for example if you have tried to save your figure in the wrong place!)\n", - "\n", - "We have the `tutorials/figures` directory specifically ignored in this project so we shouldn't ever see changes there.\n", - "\n", - "Note that if you don't pass a file ending the file will be saved as a `png` by default.\n", - "\n", - "If you add a file extension allowed by `matplotlib` (eg `.jpg`, `.svg`, `.pdf` etc) then the figure will be saved in that format." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Change the colours\n", - "\n", - "You can pass a pair of colours to the `plot_degree_dist` function.\n", - "\n", - "The first colour is that of the histogram for the real graph.\n", - "\n", - "The second colour is the line for the Erdős-Rényi graph.\n", - "\n", - "In the example below, we've chosen red and black 🎨" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_degree_dist(G10, color=[\"red\", \"black\"])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Report the global measures of the graph: `report_global_measures`\n", - "\n", - "One of the first things we want to know are how the global attributes of the network compare to those of random networks.\n", - "\n", - "Specifically we'll calculate:\n", - "\n", - "* `a`: assortativity \n", - "* `C`: clustering \n", - "* `E`: efficiency \n", - "* `L`: shortest path \n", - "* `M`: modularity\n", - "* `sigma`: small world\n", - "\n", - "and plot a bar chart that compares the real network to the random graphs." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Calculate the global measures" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
assortativityaverage_clusteringaverage_shortest_path_lengthefficiencymodularity
real_graph0.0907690.4498892.3762430.4798400.382855
real_graph_R0-0.0882340.2269462.0849020.5194060.121712
real_graph_R1-0.0926170.2474082.0797410.5202770.124544
real_graph_R2-0.0878160.2233232.0840560.5196510.130772
real_graph_R3-0.0968730.2304802.0850080.5193680.123251
real_graph_R4-0.0793770.2231412.0843100.5195230.123564
real_graph_R5-0.0880010.2331672.0788320.5203250.128539
real_graph_R6-0.0933290.2275062.0763990.5207280.125078
real_graph_R7-0.0619990.2270142.0970640.5174940.129245
real_graph_R8-0.0801100.2278832.0884340.5188720.120861
real_graph_R9-0.0734020.2344682.0886460.5188670.116025
\n", - "
" - ], - "text/plain": [ - " assortativity average_clustering \\\n", - "real_graph 0.090769 0.449889 \n", - "real_graph_R0 -0.088234 0.226946 \n", - "real_graph_R1 -0.092617 0.247408 \n", - "real_graph_R2 -0.087816 0.223323 \n", - "real_graph_R3 -0.096873 0.230480 \n", - "real_graph_R4 -0.079377 0.223141 \n", - "real_graph_R5 -0.088001 0.233167 \n", - "real_graph_R6 -0.093329 0.227506 \n", - "real_graph_R7 -0.061999 0.227014 \n", - "real_graph_R8 -0.080110 0.227883 \n", - "real_graph_R9 -0.073402 0.234468 \n", - "\n", - " average_shortest_path_length efficiency modularity \n", - "real_graph 2.376243 0.479840 0.382855 \n", - "real_graph_R0 2.084902 0.519406 0.121712 \n", - "real_graph_R1 2.079741 0.520277 0.124544 \n", - "real_graph_R2 2.084056 0.519651 0.130772 \n", - "real_graph_R3 2.085008 0.519368 0.123251 \n", - "real_graph_R4 2.084310 0.519523 0.123564 \n", - "real_graph_R5 2.078832 0.520325 0.128539 \n", - "real_graph_R6 2.076399 0.520728 0.125078 \n", - "real_graph_R7 2.097064 0.517494 0.129245 \n", - "real_graph_R8 2.088434 0.518872 0.120861 \n", - "real_graph_R9 2.088646 0.518867 0.116025 " - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Calculate the global measures\n", - "bundleGraphs_measures = bundleGraphs.report_global_measures()\n", - "\n", - "# Show the dataframe so we can see the measures\n", - "display(bundleGraphs_measures)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now you have everything to plot the **network measures** of the BrainNetwork Graph and compare these measures to random measures values obtained from 10 random graphs stored inside the graph bundle `bundleGraphs`. " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Import the code you need: `plot_network_measures`" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [], - "source": [ - "# import the function to plot network measures\n", - "from scona.visualisations import plot_network_measures" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Plot the measures\n", - "\n", - "There are 2 required parameters for the `plot_network_measures` function: \n", - "\n", - "1. a `GraphBundle` object (e.g. `bundleGraphs`)\n", - "2. the name of the *real graph* in your `GraphBundle` (e.g. `\"real_graph\"`)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Default settings\n", - "\n", - "The default colours are blue and grey, and by default the error bars show 95% confidence intervals." - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_network_measures(bundleGraphs, real_network=\"real_graph\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Save the figure\n", - "\n", - "You'll probably want to save the beautiful figure you've made! \n", - "\n", - "You can do that by passing a file name and (optional) directory path to the `figure_name` option. \n", - "If you don't set a directory path the figure will be saved in the local directory.\n", - "\n", - "For this tutorial we'll save the output in a `figures` folder inside this `tutorials` directory.\n", - "\n", - "For fun, we'll also adjust the colours to make the real network orange (#FF4400) and the random network turquoise (#00BBFF)." - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_network_measures(bundleGraphs, \"real_graph\",\n", - " figure_name=\"figures/NetworkMeasuresDemo\",\n", - " color=[\"#FF4400\", \"#00BBFF\"])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Hide the legend\n", - "\n", - "You might not want to show the legend.\n", - "That's fine!\n", - "\n", - "We'll also use this example to save an `svg` file." - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_network_measures(bundleGraphs, \"real_graph\",\n", - " figure_name=\"figures/NetworkMeasuresDemoNoLegend.svg\",\n", - " show_legend=False)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Only show the real graph\n", - "\n", - "You might not want to show the random graphs.\n", - "\n", - "In this case you have to create a new graph bundle that only contains the real graph, and pass that to the `plot_network_measures` function.\n", - "\n", - "For this example we've also changed the colour to green (to show off 😉)." - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Create a new graph bundle\n", - "realBundle = scn.GraphBundle([G10], [\"real_graph\"])\n", - "\n", - "plot_network_measures(realBundle, real_network = \"real_graph\",\n", - " color=[\"green\"])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Change the type of error bars\n", - "\n", - "The variance of measures obtained from random graphs is - by default - shown as the 95% confidence interval.\n", - "\n", - "They're calculated by bootstrapping the random graphs.\n", - "There's more information in the [seaborn documentation](https://seaborn.pydata.org/generated/seaborn.barplot.html) if you're curious.\n", - "\n", - "But you don't have to calculate them.\n", - "You can plot the standard deviations instead if you'd prefer.\n", - "(These are a bit larger than the 95% confidence intervals so they're a bit easier to see in the plot below.)" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_network_measures(bundleGraphs,\n", - " real_network=\"real_graph\",\n", - " ci=\"sd\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Alternatively you could show the 99% confidence interval." - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_network_measures(bundleGraphs, real_network=\"real_graph\",\n", - " ci=99)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Run with 100 random graphs\n", - "\n", - "You can't publish results with 10 random graphs.\n", - "These don't give meaningful variations.\n", - "So let's add 90 more random graphs.\n", - "\n", - "(This still isn't enough, but much better than 10!\n", - "We'd recommend that you run 1000 random graphs for publication quality results.)\n", - "\n", - "This takes some time (around 5 minutes) so the cell below is commented out by default.\n", - "Remove the `#` at the start of each of the lines below to run the commands yourself." - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [], - "source": [ - "#bundleGraphs.create_random_graphs(\"real_graph\", 90)\n", - "#print (len(bundleGraphs))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Congratulations! 🎉\n", - "\n", - "You created additional 90 random graphs, to give you a total of 100 random graphs and 1 real graph, and you managed to answer to some of your emails while waiting.\n", - "\n", - "Here's a beautiful plot of your network measures with 95% confidence intervals....which you can't see because the random networks are all so similar to each other 🤦" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [], - "source": [ - "#plot_network_measures(bundleGraphs, real_network=\"real_graph\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "------------------------------------------------------------------" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## *plot_rich_club*\n", - "- to plot the rich club values per degree along with the random rich club values created from Random Networks with a preserved degree distribution\n", - "\n", - "Function requries *GraphBundle* object - scona way to handle across-network comparisons. Basically, it is a dictionary, containing *BrainNetwork* objects as values and *strings* (corresponding names of BrainNetwork) as keys.\n", - "\n", - "It is also required to pass the name of the real Graph in GraphBundle (e.g. \"Real_Graph\") as a string.\n", - "\n", - "Let's create input for the function" - ] - }, - { - "cell_type": "code", - "execution_count": 74, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Woo\n" - ] - } - ], - "source": [ - "print ('Woo')" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "# instantiate the GraphBundle object with the BrainNetwork Graph and corresponding name for this Graph\n", - "\n", - "bundleGraphs = scn.GraphBundle([H], [\"Real_Graph\"])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "This creates a dictionary-like object with BrainNetwork H keyed by 'Real_Graph'. " - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'Real_Graph': }" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "bundleGraphs" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now add a series of random graphs created by edge swap randomisation of H (keyed by 'Real_Graph').\n", - "\n", - "The *create_random_graphs method* of the GraphBundle class takes in a real network (in our case Real_Graph) and creates a number (10 in the example below) of random graphs. The output is a dictionary of all these graphs." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " Creating 10 random graphs - may take a little while\n" - ] - } - ], - "source": [ - "# Note that 10 is not usually a sufficient number of random graphs to do meaningful analysis,\n", - "# it is used here for time considerations\n", - "bundleGraphs.create_random_graphs(\"Real_Graph\", 10)" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'Real_Graph': ,\n", - " 'Real_Graph_R0': ,\n", - " 'Real_Graph_R1': ,\n", - " 'Real_Graph_R2': ,\n", - " 'Real_Graph_R3': ,\n", - " 'Real_Graph_R4': ,\n", - " 'Real_Graph_R5': ,\n", - " 'Real_Graph_R6': ,\n", - " 'Real_Graph_R7': ,\n", - " 'Real_Graph_R8': ,\n", - " 'Real_Graph_R9': }" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "bundleGraphs" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Well-done! The required input - GraphBundle is created which contains real network keyed by \"Real_Graph\" and 10 random graphs. Now, let's plot the **rich club coefficient values** of our BrainNetwork Graph and compare real rich club values to random rich club values obtained from 10 random Graphs (stored inside the GraphBundle). " - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "# import the function to plot rich club values\n", - "from scona.visualisations import plot_rich_club" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAqoAAAGKCAYAAADEwWPBAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nKaiKiIiIiFdSUBURERERr/T/Adr2RLnQ4H7QAAAAAElFTkSuQmCC\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# plot the figure and display without saving to a file\n", - "plot_rich_club(bundleGraphs, real_network=\"Real_Graph\")" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
Real_GraphReal_Graph_R0Real_Graph_R1Real_Graph_R2Real_Graph_R3Real_Graph_R4Real_Graph_R5Real_Graph_R6Real_Graph_R7Real_Graph_R8Real_Graph_R9
550.5667830.5005810.4947740.4727060.5005810.4808360.4866430.4796750.4773520.4994190.501742
560.5743900.5097560.5012200.4731710.5012200.4829270.4853660.4817070.4804880.5024390.508537
570.5782050.5102560.5115380.4807690.5102560.4884620.4871790.4910260.4884620.5038460.515385
580.5990990.5225230.5135140.4834830.5330330.4909910.4969970.4969970.4909910.5135140.518018
590.6067230.5344540.5277310.4941180.5462180.5008400.5008400.5008400.5058820.5294120.526050
600.6067230.5344540.5277310.4941180.5462180.5008400.5008400.5008400.5058820.5294120.526050
610.6150540.5526880.5354840.5096770.5569890.5053760.5182800.5139780.5225810.5376340.556989
620.6252870.5609200.5471260.5126440.5609200.5034480.5218390.5287360.5195400.5425290.558621
630.6524220.5641030.5612540.5356130.5612540.5213680.5327640.5413110.5327640.5669520.572650
640.6533330.5800000.5700000.5366670.5600000.5433330.5400000.5466670.5400000.5733330.583333
650.6630430.5869570.5833330.5471010.5615940.5507250.5398550.5471010.5362320.5760870.594203
\n", - "
" - ], - "text/plain": [ - " Real_Graph Real_Graph_R0 Real_Graph_R1 Real_Graph_R2 Real_Graph_R3 \\\n", - "55 0.566783 0.500581 0.494774 0.472706 0.500581 \n", - "56 0.574390 0.509756 0.501220 0.473171 0.501220 \n", - "57 0.578205 0.510256 0.511538 0.480769 0.510256 \n", - "58 0.599099 0.522523 0.513514 0.483483 0.533033 \n", - "59 0.606723 0.534454 0.527731 0.494118 0.546218 \n", - "60 0.606723 0.534454 0.527731 0.494118 0.546218 \n", - "61 0.615054 0.552688 0.535484 0.509677 0.556989 \n", - "62 0.625287 0.560920 0.547126 0.512644 0.560920 \n", - "63 0.652422 0.564103 0.561254 0.535613 0.561254 \n", - "64 0.653333 0.580000 0.570000 0.536667 0.560000 \n", - "65 0.663043 0.586957 0.583333 0.547101 0.561594 \n", - "\n", - " Real_Graph_R4 Real_Graph_R5 Real_Graph_R6 Real_Graph_R7 Real_Graph_R8 \\\n", - "55 0.480836 0.486643 0.479675 0.477352 0.499419 \n", - "56 0.482927 0.485366 0.481707 0.480488 0.502439 \n", - "57 0.488462 0.487179 0.491026 0.488462 0.503846 \n", - "58 0.490991 0.496997 0.496997 0.490991 0.513514 \n", - "59 0.500840 0.500840 0.500840 0.505882 0.529412 \n", - "60 0.500840 0.500840 0.500840 0.505882 0.529412 \n", - "61 0.505376 0.518280 0.513978 0.522581 0.537634 \n", - "62 0.503448 0.521839 0.528736 0.519540 0.542529 \n", - "63 0.521368 0.532764 0.541311 0.532764 0.566952 \n", - "64 0.543333 0.540000 0.546667 0.540000 0.573333 \n", - "65 0.550725 0.539855 0.547101 0.536232 0.576087 \n", - "\n", - " Real_Graph_R9 \n", - "55 0.501742 \n", - "56 0.508537 \n", - "57 0.515385 \n", - "58 0.518018 \n", - "59 0.526050 \n", - "60 0.526050 \n", - "61 0.556989 \n", - "62 0.558621 \n", - "63 0.572650 \n", - "64 0.583333 \n", - "65 0.594203 " - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# show rich club values for degrees from 55 to 65\n", - "rich_club_df = bundleGraphs.report_rich_club()\n", - "rich_club_df.iloc[55:66, :]" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "rich_club_df." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "More examples of plotting rich club values:" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "- save the produced figure in the current directory (where this running python file (or notebook) is located) and set different colors (for real values - #FF4400 - red, for random - #00BBFF - blue)." - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAqoAAAGKCAYAAADEwWPBAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n2CUFVRERERGxSwqqIiIiImKX/h+SaNQHyeJ6MAAAAABJRU5ErkJggg==\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_rich_club(bundleGraphs, real_network=\"Real_Graph\",figure_name=\"Rich_club_values\", color=[\"#FF4400\", \"#00BBFF\"])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "- save the produced figure in the location = figure_name and without the legend.\n", - "\n", - "Please, give your own location (path-to_file) to *figure_name* in order to save a figure.\n", - "\n", - "*Note*: if location does not exist, we will notify you and try to automatically create necessary directories." - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAqoAAAGKCAYAAADEwWPBAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/pilot/anaconda3/lib/python3.6/site-packages/scona/helpers.py:25: UserWarning: The path - /home/pilot/GSoC/mynewdir1/Rich_Club_Values does not exist. But we will create this directory for you and store the figure there.\n", - " \"directory for you and store the figure there.\".format(path_name))\n" - ] - } - ], - "source": [ - "plot_rich_club(bundleGraphs, real_network=\"Real_Graph\", figure_name=\"/home/pilot/GSoC/mynewdir1/Rich_Club_Values\", \n", - " show_legend=False)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "* plot rich club values **only for the real network** (BrainNetwork Graph) and set the color to green.\n", - "\n", - "Simply, do not create random graphs in GraphBundle" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [ - "realGraph = scn.GraphBundle([H], [\"Real_Graph\"])" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'Real_Graph': }" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "realGraph" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAqoAAAGKCAYAAADEwWPBAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_rich_club(realGraph, real_network=\"Real_Graph\", color=[\"green\"])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "---------------------------------------------------------" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "----------------------" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python [default]", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.6.4" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} From 0fd5ebcfab78c9528e3426098e277b8a327facb8 Mon Sep 17 00:00:00 2001 From: wingedRuslan Date: Wed, 28 Aug 2019 19:13:54 +0300 Subject: [PATCH 9/9] Fix the failing viz tests on Travis --- .travis.yml | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/.travis.yml b/.travis.yml index 2b855fc..e1acf44 100644 --- a/.travis.yml +++ b/.travis.yml @@ -9,12 +9,13 @@ env: secure: QvKbq/nKWPcVk5RrOD5rLUUioaM0iZ9PblW/ucd3zjPWdeJTKSG4BqFf+fWkLN+3aE9k+EeFsQ0voyKriKrSOHHOoHGIbROOdjM8+Uc06N8h1noJ/LLW1BBDbICtCMma70//QWYG+eqIGSBozp3tZ5QGbDZB5Nt5fNDSbO6rYJzfBF26jWAWjurB6E/6v+Dp3nbFRZ2Eju2/RG059w9Y5IK87n/GKUmiS3kRgLJaeSwvji8f6/29xVYsKhorw2GlQA0Es/rnXFHBF5tMqX1CrCjWGN2XH/MIRtrI7FxUz691LBXkGivOl8E6zjyKN/aTvjKe+PZHdF+VPCzjWMUklT2L5p4W6qbjxR+Uw/7ecfBeiTMkubzFig4kqpkz9skhfOiYCeEld+4dzl5mGFhpxwSXKLTQtVvwh7PGuuc22LWK4O5LyESv3jHHPyxEhB48GDc5illzalMqYw7+m/H1A8i4RSPx5xloNSMHmS1naNXq851kZmdLspqd67ECBNnLRN/AMfQIqltTlheFTYZk2hbD9g+fntjr1aboYIxyB1f33WSAJuyTBFagM/la/tVDUGM57WiV7dvLRXF1gXr4U7DzD7mUpflXmn75wCiuyNB4rWDv7LxEpgBR0iXJultzP0ewVPgAU31k8/rMapzfWwTX4z+kXgVNYJqe9XhBudY= install: - pip install -q networkx==$NETWORKX_VERSION + - pip install . - pip install -q -r requirements.txt - pip install sphinx sphinx sphinxcontrib-napoleon sphinx_rtd_theme script: - python3 -m pytest -v --ignore=tests/regression_test.py # temporarily ignore regression tests while we investigate why they are failing - - py.test --nbval-lax tutorials/ + - python3 -m pytest --nbval-lax tutorials/ - cd docs - make html - touch .nojekyll