']].to_csv(output_dir + 'map_vosviewer.txt', sep='\\t', index=False);\n",
711 | "\n",
712 | "edge_df = pd.DataFrame([(G_terms.vs[e.source]['id'], G_terms.vs[e.target]['id'], e['weight']) for e in G_terms.es],\n",
713 | " columns=['source', 'target', 'weight']);\n",
714 | "edge_df = edge_df.sort_values(['source', 'target']);\n",
715 | "edge_df.to_csv(output_dir + 'network_vosviewer.txt', sep='\\t', index=False, header=False);"
716 | ]
717 | },
718 | {
719 | "cell_type": "markdown",
720 | "metadata": {},
721 | "source": [
722 | "The great benefit of doing the clustering in Python is that we now also have a clustering of the publications. This is something that is not possible in VOSviewer."
723 | ]
724 | },
725 | {
726 | "cell_type": "markdown",
727 | "metadata": {},
728 | "source": [
729 | "Let us first load the actual publication files which were used by VOSviewer (we have already done this in the previous notebook). As said, the `document id` refers to the line number of the WoS files that were read by VOSviewer, starting from `1`. We therefore also create a `document id` that is the same."
730 | ]
731 | },
732 | {
733 | "cell_type": "code",
734 | "execution_count": null,
735 | "metadata": {},
736 | "outputs": [],
737 | "source": [
738 | "import glob\n",
739 | "import csv\n",
740 | "files = sorted(glob.glob('data-files/wos/tab-delimited/*.txt'))\n",
741 | "publications_df = pd.concat(pd.read_csv(f, sep='\\t', quoting=csv.QUOTE_NONE, \n",
742 | " usecols=range(68), index_col='UT') for f in files)\n",
743 | "publications_df['document id'] = range(1,publications_df.shape[0]+1)"
744 | ]
745 | },
746 | {
747 | "cell_type": "markdown",
748 | "metadata": {},
749 | "source": [
750 | "Now let us create a dataframe from `G_doc_term` with all the information from the documents."
751 | ]
752 | },
753 | {
754 | "cell_type": "code",
755 | "execution_count": null,
756 | "metadata": {},
757 | "outputs": [],
758 | "source": [
759 | "nodes_df = pd.DataFrame.from_dict({attr: G_doc_term.vs[attr] for attr in G_doc_term.vs.attributes()});\n",
760 | "nodes_df = nodes_df[nodes_df['type'] == 'doc'];"
761 | ]
762 | },
763 | {
764 | "cell_type": "markdown",
765 | "metadata": {},
766 | "source": [
767 | "Now we need back the original integer `document id`, instead of the identifiers we created `doc-1`, `doc-2`, etc... We can then use those `document id` to merge back the results with the original information from the publications."
768 | ]
769 | },
770 | {
771 | "cell_type": "code",
772 | "execution_count": null,
773 | "metadata": {},
774 | "outputs": [],
775 | "source": [
776 | "nodes_df['document id'] = nodes_df['id'].str[:-4].astype(int);\n",
777 | "publications_df = pd.merge(nodes_df[['document id', 'cluster']], publications_df, \n",
778 | " left_on='document id', right_on='document id')"
779 | ]
780 | },
781 | {
782 | "cell_type": "markdown",
783 | "metadata": {},
784 | "source": [
785 | "Finally, for further inspection, we may want to export our results to a `.csv` file."
786 | ]
787 | },
788 | {
789 | "cell_type": "code",
790 | "execution_count": null,
791 | "metadata": {},
792 | "outputs": [],
793 | "source": [
794 | "publications_df[['AU', 'PY', 'TI', 'SO', 'cluster']].to_csv(output_dir + 'publications_clustering.csv', \n",
795 | " index=False)"
796 | ]
797 | },
798 | {
799 | "cell_type": "markdown",
800 | "metadata": {},
801 | "source": [
802 | "# Own analysis"
803 | ]
804 | },
805 | {
806 | "cell_type": "markdown",
807 | "metadata": {},
808 | "source": [
809 | "\n",
810 | "Load your own data in VOSviewer and create a co-citation network of journals.\n",
811 | "
"
812 | ]
813 | },
814 | {
815 | "cell_type": "code",
816 | "execution_count": null,
817 | "metadata": {},
818 | "outputs": [],
819 | "source": []
820 | },
821 | {
822 | "cell_type": "markdown",
823 | "metadata": {},
824 | "source": [
825 | "\n",
826 | "Detect comunities in the journal co-citation network. What do you think the different clusters mean?\n",
827 | "
"
828 | ]
829 | },
830 | {
831 | "cell_type": "code",
832 | "execution_count": null,
833 | "metadata": {},
834 | "outputs": [],
835 | "source": []
836 | },
837 | {
838 | "cell_type": "markdown",
839 | "metadata": {},
840 | "source": [
841 | "\n",
842 | " Load your own data in VOSviewer and create a term-map. Please take the following steps to create the term-map and extract the
terms.csv file and the
doc-terms.csv file.\n",
843 | " \n",
844 | "
\n",
845 | " - Open VOSviewer and press the button \"Create...\".
\n",
846 | " - Choose \"Create a map based on text data\" and press \"Next\".
\n",
847 | " - Choose \"Read data from bibliographic database files\" and press \"Next\".
\n",
848 | " - Choose the \"Web of Science\" tab and select the files you have downloaded yourself and press \"Next\".
\n",
849 | " - Choose \"Title and abstract fields\" (the default) and press \"Next\".
\n",
850 | " - Choose \"Binary counting\" (the default) and press \"Next\".
\n",
851 | " - Leave the default threshold of 10 and press \"Next\".
\n",
852 | " - Leave the default number of terms to be selected and press \"Next\".
\n",
853 | "
\n",
854 | "\n",
855 | "VOSviewer will now calculate the \"relevance\" scores. When it is done, you will be shown a list of terms together with the number of their occurrences and the relevance scores. Please follow the following remaining steps.\n",
856 | "\n",
857 | "
\n",
858 | " - On the list of terms, click-right, and choose \"Export selected terms...\". Choose an appropriate file name (
terms.txt) and make sure you choose an appropriate directory and then press \"Export\". \n",
859 | " - On the list of terms, click-right, and choose \"Export document-term relations...\". Choose an appropriate file name (
doc-terms.txt) and make sure you choose an appropriate directory and then press \"Export\". \n",
860 | "
\n",
861 | "
\n",
869 | " Load the terms.csv file and the doc-terms.csv files. Detect the clusters in this bipartite network, as explained above.\n",
870 | "
"
871 | ]
872 | },
873 | {
874 | "cell_type": "code",
875 | "execution_count": null,
876 | "metadata": {},
877 | "outputs": [],
878 | "source": []
879 | },
880 | {
881 | "cell_type": "markdown",
882 | "metadata": {},
883 | "source": [
884 | "\n",
885 | " Compare the results to the clusters you can detect immediately in VOSviewer itself. Are they similar or not?\n",
886 | "
"
887 | ]
888 | },
889 | {
890 | "cell_type": "code",
891 | "execution_count": null,
892 | "metadata": {},
893 | "outputs": [],
894 | "source": []
895 | },
896 | {
897 | "cell_type": "markdown",
898 | "metadata": {},
899 | "source": [
900 | "\n",
901 | " Try to identify the main topic for the largest few clusters on the basis of the terms in the term map. Does that match well with the publications in the same cluster? Do you see any discrepancies?\n",
902 | "
"
903 | ]
904 | },
905 | {
906 | "cell_type": "code",
907 | "execution_count": null,
908 | "metadata": {},
909 | "outputs": [],
910 | "source": []
911 | }
912 | ],
913 | "metadata": {
914 | "kernelspec": {
915 | "display_name": "Python 3",
916 | "language": "python",
917 | "name": "python3"
918 | },
919 | "language_info": {
920 | "codemirror_mode": {
921 | "name": "ipython",
922 | "version": 3
923 | },
924 | "file_extension": ".py",
925 | "mimetype": "text/x-python",
926 | "name": "python",
927 | "nbconvert_exporter": "python",
928 | "pygments_lexer": "ipython3",
929 | "version": "3.8.3"
930 | }
931 | },
932 | "nbformat": 4,
933 | "nbformat_minor": 2
934 | }
935 |
--------------------------------------------------------------------------------
/01-basics.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {},
6 | "source": [
7 | "# Introduction"
8 | ]
9 | },
10 | {
11 | "cell_type": "markdown",
12 | "metadata": {},
13 | "source": [
14 | "In this lab exercise, you will learn how to perform scientometric network analysis in Python. We will start with practicalities on some basic data handling and import. We then move on to creating a network and cover some basic analysis. In the next session, we will be using more advanced techniques."
15 | ]
16 | },
17 | {
18 | "cell_type": "markdown",
19 | "metadata": {},
20 | "source": [
21 | "\n",
22 | "This Python notebook is intended to be used as an exercise. We have prepared it for you to include many details, but at some parts we will ask you to fill in some of the blanks. Exercises where you are asked to do something, or to think about something, will be indicated like this. If you need to execute and write your own code, we provide empty space below to do so.\n",
23 | "
"
24 | ]
25 | },
26 | {
27 | "cell_type": "markdown",
28 | "metadata": {},
29 | "source": [
30 | "\n",
31 | "If you need any help with anything, please don't hesitate to ask your teachers. \n",
32 | "
"
33 | ]
34 | },
35 | {
36 | "cell_type": "markdown",
37 | "metadata": {},
38 | "source": [
39 | "# Data handling"
40 | ]
41 | },
42 | {
43 | "cell_type": "markdown",
44 | "metadata": {},
45 | "source": [
46 | "Python is a general purpose programming language and it can be used to handle data in general. In this notebook we will specifically deal with scientometric datasets, but you can also use it for other purposes.\n",
47 | "\n",
48 | "We will start by handling some data from a scientometric data source. There are many different possible data sources, and we discussed some of them earlier this week. In this notebook we will focus on data downloaded from Web of Science. We have already downloaded some data for you to demonstrate Python. At the end of the exercise you will be asked to load your own data. \n",
49 | "\n",
50 | "The data that we provided is a selection of publications from authors from Belgium from Tropical Medicine from 2000-2017."
51 | ]
52 | },
53 | {
54 | "cell_type": "markdown",
55 | "metadata": {},
56 | "source": [
57 | "\n",
58 | " Note: You cannot load your own data when you run this notebook online using Binder.\n",
59 | "
"
60 | ]
61 | },
62 | {
63 | "cell_type": "markdown",
64 | "metadata": {},
65 | "source": [
66 | "We start by loading the data. In order to read in the data, we first need to make sure that Python is able to read it. A very versatile *package* for handling data in Python is called `pandas`. For those of you familiar with `R`, it is similar to the `data.frame` in `R`."
67 | ]
68 | },
69 | {
70 | "cell_type": "markdown",
71 | "metadata": {},
72 | "source": [
73 | "We *import* this package as follows, and we call the `pandas` package `pd`, for easy reference. We also need the `csv` package to indicate some options to the `pandas` package."
74 | ]
75 | },
76 | {
77 | "cell_type": "markdown",
78 | "metadata": {},
79 | "source": [
80 | "\n",
81 | " In order to execute the code you have to press Ctrl-Enter while selecting the code cell below. Alternatively, you can press the \"Play\" button at the top of the screen. This also moves to the next cell at the same time. Using Shift-Enter instead of Ctrl-Enter will also execute the code and move to the next cell at the same time.\n",
82 | "
"
83 | ]
84 | },
85 | {
86 | "cell_type": "code",
87 | "execution_count": null,
88 | "metadata": {},
89 | "outputs": [],
90 | "source": [
91 | "import pandas as pd\n",
92 | "import csv"
93 | ]
94 | },
95 | {
96 | "cell_type": "markdown",
97 | "metadata": {},
98 | "source": [
99 | "\n",
100 | " If you have executed that code cell correctly, it should now be numbered 1. While the code in a cell is being executed it is marked by an asterisk *. Each cell of executed code will be numbered in the order in which you execute it. If you execute it again, it will be numbered 2, et cetera.\n",
101 | "
"
102 | ]
103 | },
104 | {
105 | "cell_type": "markdown",
106 | "metadata": {},
107 | "source": [
108 | "We are now ready to read in the data that you just downloaded. We have named the `pandas` package `pd`, which will save us some typing."
109 | ]
110 | },
111 | {
112 | "cell_type": "code",
113 | "execution_count": null,
114 | "metadata": {},
115 | "outputs": [],
116 | "source": [
117 | "publications_df = pd.read_csv('data-files/wos/tab-delimited/savedrecs_0001_0500.txt', \n",
118 | " sep='\\t', index_col='UT',\n",
119 | " quoting=csv.QUOTE_NONE, usecols=range(68))"
120 | ]
121 | },
122 | {
123 | "cell_type": "markdown",
124 | "metadata": {},
125 | "source": [
126 | "We called the *function* `read_csv` of the `pandas` package. We provide it with several *arguments*. \n",
127 | "\n",
128 | "1. The location of the file we want to read.\n",
129 | "\n",
130 | "2. The second argument is a *named argument*, we provide both the name of the argument (`sep`) and its value (`'\\t'`). This indicates the *sep*arator between different fields. In this case it is a tab-delimited file, so the fields are separated by tabs, which is indicated by `'\\t'`.\n",
131 | "\n",
132 | "3. The third argument is again a named argument. We indicate that the `UT` field should be the index. This is the unique identifier that WoS uses.\n",
133 | "\n",
134 | "The two subqeuent arguments are needed to correctly handle some peculiarities of WoS files."
135 | ]
136 | },
137 | {
138 | "cell_type": "markdown",
139 | "metadata": {},
140 | "source": [
141 | "\n",
142 | "We downloaded some example files for you, which are located in the folder data_files/wos. At the end of this notebook, you will be asked to download your own data. If you want to load that data instead, use the path to that data.\n",
143 | "
"
144 | ]
145 | },
146 | {
147 | "cell_type": "markdown",
148 | "metadata": {},
149 | "source": [
150 | "\n",
151 | " Note: Windows usually uses backslashes \\ to separate directories, in Python you can also use the forward slash /, which is usually more convenient for a number of reasons.\n",
152 | "
"
153 | ]
154 | },
155 | {
156 | "cell_type": "markdown",
157 | "metadata": {},
158 | "source": [
159 | "The `pandas` package took care of reading the file, and has now stored it in the variable called `publications_df`. You can take a closer look at `publications_df` to see the data that we just read."
160 | ]
161 | },
162 | {
163 | "cell_type": "code",
164 | "execution_count": null,
165 | "metadata": {},
166 | "outputs": [],
167 | "source": [
168 | "publications_df"
169 | ]
170 | },
171 | {
172 | "cell_type": "markdown",
173 | "metadata": {},
174 | "source": [
175 | "You will see that the data has quite cryptic column headers. Each line contains information about a single publication, and contains various details, such as the title (`TI`), abstract (`AB`), authors (`AU`), journal title (`SO`) and cited references (`CR`). Unfortunately, the documentation of Web of Science is relatively limited, but some explanation can be found here. You can retrieve this information in various ways from the pandas dataframe `publications_df`. For example, you can list the first five titles as follows:"
176 | ]
177 | },
178 | {
179 | "cell_type": "code",
180 | "execution_count": null,
181 | "metadata": {},
182 | "outputs": [],
183 | "source": [
184 | "publications_df.TI[:5]"
185 | ]
186 | },
187 | {
188 | "cell_type": "markdown",
189 | "metadata": {},
190 | "source": [
191 | "Here, `[:5]` indicates that you want the first elements (starting at 0) until (but excluding) 5, so item 0, 1, 2, 3 and 4. This is called a *slice* of the data. You can also look at authors for rows 5 until 10 as follows:"
192 | ]
193 | },
194 | {
195 | "cell_type": "code",
196 | "execution_count": null,
197 | "metadata": {},
198 | "outputs": [],
199 | "source": [
200 | "publications_df.AU[5:10]"
201 | ]
202 | },
203 | {
204 | "cell_type": "markdown",
205 | "metadata": {},
206 | "source": [
207 | "In order to get the last few elements, you can use negative indices. The last element is indicated by `-1`, the penultimate element is indicated by `-2`, and so on. You can get the journals for the last five sources as follows:"
208 | ]
209 | },
210 | {
211 | "cell_type": "code",
212 | "execution_count": null,
213 | "metadata": {},
214 | "outputs": [],
215 | "source": [
216 | "publications_df.SO[-5:]"
217 | ]
218 | },
219 | {
220 | "cell_type": "markdown",
221 | "metadata": {},
222 | "source": [
223 | "Alternatively, there are various ways to index the dataframe. For example, to get the title and abstract for the first five elements you can do the following."
224 | ]
225 | },
226 | {
227 | "cell_type": "code",
228 | "execution_count": null,
229 | "metadata": {},
230 | "outputs": [],
231 | "source": [
232 | "publications_df[0:5][['TI', 'AB']]"
233 | ]
234 | },
235 | {
236 | "cell_type": "markdown",
237 | "metadata": {},
238 | "source": [
239 | "The notation `['TI', 'AB']` creates a *list* of elements in Python. We now used it to get multiple columns from the dataframe. "
240 | ]
241 | },
242 | {
243 | "cell_type": "markdown",
244 | "metadata": {},
245 | "source": [
246 | "The following does exactly the same:"
247 | ]
248 | },
249 | {
250 | "cell_type": "code",
251 | "execution_count": null,
252 | "metadata": {},
253 | "outputs": [],
254 | "source": [
255 | "publications_df[['TI', 'AB']][0:5]"
256 | ]
257 | },
258 | {
259 | "cell_type": "markdown",
260 | "metadata": {},
261 | "source": [
262 | "The `pandas` package automatically determines whether you try to get columns or rows. Slices are always assumed to refer to rows."
263 | ]
264 | },
265 | {
266 | "cell_type": "markdown",
267 | "metadata": {},
268 | "source": [
269 | "\n",
270 | " Show the title (TI), abstract (AB), journal (SO) and publication year (PY) for rows 200-210.\n",
271 | "
"
272 | ]
273 | },
274 | {
275 | "cell_type": "markdown",
276 | "metadata": {},
277 | "source": [
278 | "\n",
279 | "To start typing in the cell below, select the cell using the mouse, or select it using the arrows on the keyboard and press Enter\n",
280 | "
"
281 | ]
282 | },
283 | {
284 | "cell_type": "code",
285 | "execution_count": null,
286 | "metadata": {},
287 | "outputs": [],
288 | "source": []
289 | },
290 | {
291 | "cell_type": "markdown",
292 | "metadata": {},
293 | "source": [
294 | "You can also access a particular `UT` directly by using the `.loc` indexer."
295 | ]
296 | },
297 | {
298 | "cell_type": "code",
299 | "execution_count": null,
300 | "metadata": {},
301 | "outputs": [],
302 | "source": [
303 | "publications_df.loc['WOS:000419235100004', ['TI', 'AU', 'SO', 'PY']]"
304 | ]
305 | },
306 | {
307 | "cell_type": "markdown",
308 | "metadata": {},
309 | "source": [
310 | "## Reading multiple files"
311 | ]
312 | },
313 | {
314 | "cell_type": "markdown",
315 | "metadata": {},
316 | "source": [
317 | "Until now we have only loaded one file. But we have of course downloaded more files, and we need to load all of them. We can list all files in a directory using the package `glob`. We first import the package."
318 | ]
319 | },
320 | {
321 | "cell_type": "code",
322 | "execution_count": null,
323 | "metadata": {},
324 | "outputs": [],
325 | "source": [
326 | "import glob"
327 | ]
328 | },
329 | {
330 | "cell_type": "markdown",
331 | "metadata": {},
332 | "source": [
333 | "Now, let us get a list of all files in the directory `data_files/wos/tab-delimited/`."
334 | ]
335 | },
336 | {
337 | "cell_type": "code",
338 | "execution_count": null,
339 | "metadata": {},
340 | "outputs": [],
341 | "source": [
342 | "files = sorted(glob.glob('data-files/wos/tab-delimited/*.txt'))\n",
343 | "files"
344 | ]
345 | },
346 | {
347 | "cell_type": "markdown",
348 | "metadata": {},
349 | "source": [
350 | "We asked `glob` for a list of files that end with `txt` (`*.txt`) in the directory `data-files/wos/tab-delimited`. We sorted the list to ensure that we read the files in the correct order. We can now simply pass this list of files to read multiple WoS files."
351 | ]
352 | },
353 | {
354 | "cell_type": "code",
355 | "execution_count": null,
356 | "metadata": {},
357 | "outputs": [],
358 | "source": [
359 | "publications_df = pd.concat(pd.read_csv(f, sep='\\t', quoting=csv.QUOTE_NONE, \n",
360 | " usecols=range(68), index_col='UT') for f in files)\n",
361 | "publications_df = publications_df.sort_index()"
362 | ]
363 | },
364 | {
365 | "cell_type": "markdown",
366 | "metadata": {},
367 | "source": [
368 | "\n",
369 | " Now checkout the new publications_df data frame, and see how many rows it has.\n",
370 | "
"
371 | ]
372 | },
373 | {
374 | "cell_type": "code",
375 | "execution_count": null,
376 | "metadata": {},
377 | "outputs": [],
378 | "source": []
379 | },
380 | {
381 | "cell_type": "markdown",
382 | "metadata": {},
383 | "source": [
384 | "## Data summarisation"
385 | ]
386 | },
387 | {
388 | "cell_type": "markdown",
389 | "metadata": {},
390 | "source": [
391 | "The `pandas` package provides various ways to summarise the data and get a useful overview of the data. For example, you can group by a certain column, and count or sum things. For example, we can count the number of articles in each journal that is included in this dataset:"
392 | ]
393 | },
394 | {
395 | "cell_type": "code",
396 | "execution_count": null,
397 | "metadata": {},
398 | "outputs": [],
399 | "source": [
400 | "grouped_by_journal = publications_df.groupby('SO')\n",
401 | "grouped_by_journal.size().sort_values(ascending=False)[:10]"
402 | ]
403 | },
404 | {
405 | "cell_type": "markdown",
406 | "metadata": {},
407 | "source": [
408 | "We could also ask the mean publication year of publications in those journals"
409 | ]
410 | },
411 | {
412 | "cell_type": "code",
413 | "execution_count": null,
414 | "metadata": {},
415 | "outputs": [],
416 | "source": [
417 | "grouped_by_journal['PY'].mean()"
418 | ]
419 | },
420 | {
421 | "cell_type": "markdown",
422 | "metadata": {},
423 | "source": [
424 | "\n",
425 | " Group by the year (PY) and count the number of paper from each year.\n",
426 | "
"
427 | ]
428 | },
429 | {
430 | "cell_type": "markdown",
431 | "metadata": {},
432 | "source": [
433 | "\n",
434 | "Now it is time to introduce you a little trick: you can get a list of all functions and argument of some variable by simply pressing Tab. For example, you can type publications_df., including the . and then press Tab (make sure the cursor is located after the .). If you then start typing the name of the function you are looking for and press Tab again, Python will automatically finish it as much as possible. This is something general: whenever you press Tab Python will try to autocomplete whatever you are typing.\n",
435 | "\n",
436 | "One other trick: if you have selected a function and press Shift-Tab you will get documentation of what this function does. You can press the + to find out more.\n",
437 | "
"
438 | ]
439 | },
440 | {
441 | "cell_type": "code",
442 | "execution_count": null,
443 | "metadata": {},
444 | "outputs": [],
445 | "source": []
446 | },
447 | {
448 | "cell_type": "markdown",
449 | "metadata": {},
450 | "source": [
451 | "## Network generation"
452 | ]
453 | },
454 | {
455 | "cell_type": "markdown",
456 | "metadata": {},
457 | "source": [
458 | "Ultimately, we would like to use this data to generation scientometric networks. This is not a trivial task, and we will now show how to construct a co-authorship network and a journal level bibliographic coupling network.\n",
459 | "\n",
460 | "We first load the network analysis package that we will use in the notebook, `igraph`."
461 | ]
462 | },
463 | {
464 | "cell_type": "markdown",
465 | "metadata": {},
466 | "source": [
467 | "\n",
468 | " Import the pacakge igraph and call it ig.\n",
469 | "
"
470 | ]
471 | },
472 | {
473 | "cell_type": "code",
474 | "execution_count": null,
475 | "metadata": {},
476 | "outputs": [],
477 | "source": []
478 | },
479 | {
480 | "cell_type": "markdown",
481 | "metadata": {},
482 | "source": [
483 | "### Co-authorship"
484 | ]
485 | },
486 | {
487 | "cell_type": "markdown",
488 | "metadata": {},
489 | "source": [
490 | "We first build a co-authorship network. We will do this one publication at the time. All combinations of authors that are involved in a publication are co-authors. Let us look at the authors for publication 0."
491 | ]
492 | },
493 | {
494 | "cell_type": "code",
495 | "execution_count": null,
496 | "metadata": {},
497 | "outputs": [],
498 | "source": [
499 | "publications_df['AU'][0]"
500 | ]
501 | },
502 | {
503 | "cell_type": "markdown",
504 | "metadata": {},
505 | "source": [
506 | "Note that the authors are all listed and separated with a semicolon (`;`). In computer terms, it is now a single *string*. We will split this string of all authors into a list of strings where each string then represents a single author."
507 | ]
508 | },
509 | {
510 | "cell_type": "code",
511 | "execution_count": null,
512 | "metadata": {},
513 | "outputs": [],
514 | "source": [
515 | "publications_df['AU_split'] = publications_df['AU'].fillna('').str.split('; ')"
516 | ]
517 | },
518 | {
519 | "cell_type": "code",
520 | "execution_count": null,
521 | "metadata": {},
522 | "outputs": [],
523 | "source": [
524 | "authors = publications_df['AU_split'][0]\n",
525 | "authors"
526 | ]
527 | },
528 | {
529 | "cell_type": "markdown",
530 | "metadata": {},
531 | "source": [
532 | "In order to create all possible combinations, we can use a convenient package, called `itertools`. The function `combinations` can generate all possible combinations of the elements of a list."
533 | ]
534 | },
535 | {
536 | "cell_type": "code",
537 | "execution_count": null,
538 | "metadata": {},
539 | "outputs": [],
540 | "source": [
541 | "import itertools as itr\n",
542 | "list(itr.combinations(authors, 2))"
543 | ]
544 | },
545 | {
546 | "cell_type": "markdown",
547 | "metadata": {},
548 | "source": [
549 | "Of course, we don't want to do this for a single publication only, but rather, for all publications in our dataset. We can do that using the function `apply`. We can supply it with a small function (called a `lambda` function) that simply takes some input and produces some output. In this case, the input are the `authors`, and the output is the result of `itr.combinations(...)`."
550 | ]
551 | },
552 | {
553 | "cell_type": "code",
554 | "execution_count": null,
555 | "metadata": {},
556 | "outputs": [],
557 | "source": [
558 | "coauthors_per_publication = publications_df['AU_split'].apply(\n",
559 | " lambda authors: list(itr.combinations(authors, 2)))"
560 | ]
561 | },
562 | {
563 | "cell_type": "markdown",
564 | "metadata": {},
565 | "source": [
566 | "The variable `coauthors_per_publication` is now a list of a list of co-authors per publication. That is, each element of `coauthors_per_publication` contains a list of all co-authors for that publication. So, `coauthors_per_publication[0]` contains the coauthors we examined previously."
567 | ]
568 | },
569 | {
570 | "cell_type": "code",
571 | "execution_count": null,
572 | "metadata": {},
573 | "outputs": [],
574 | "source": [
575 | "coauthors_per_publication[0]"
576 | ]
577 | },
578 | {
579 | "cell_type": "markdown",
580 | "metadata": {},
581 | "source": [
582 | "Let us turn each element of this list into a separate row. This is done by using `explode` in `pandas`. Publications with only one author have no co-authors, which results in an `NA` (Not Available) value. We will drop those using `dropna`."
583 | ]
584 | },
585 | {
586 | "cell_type": "code",
587 | "execution_count": null,
588 | "metadata": {},
589 | "outputs": [],
590 | "source": [
591 | "coauthors = coauthors_per_publication.explode().dropna()"
592 | ]
593 | },
594 | {
595 | "cell_type": "markdown",
596 | "metadata": {},
597 | "source": [
598 | "Finally, we can create the actual network as follows"
599 | ]
600 | },
601 | {
602 | "cell_type": "code",
603 | "execution_count": null,
604 | "metadata": {},
605 | "outputs": [],
606 | "source": [
607 | "G_coauthorship = ig.Graph.TupleList(\n",
608 | " edges=coauthors.to_list(),\n",
609 | " vertex_name_attr='author',\n",
610 | " directed=False\n",
611 | " )"
612 | ]
613 | },
614 | {
615 | "cell_type": "markdown",
616 | "metadata": {},
617 | "source": [
618 | "Note that this graph will still contain many duplicate edges, because there are multiple edges present. Let us therefore simplify this graph, and simply count the number of multiple edges. We first create a so-called edge attribute `n_joint_papers`. We can create it by using the edge sequence `es` of the graph. We can then simply sum this weight when we simplify the graph."
619 | ]
620 | },
621 | {
622 | "cell_type": "code",
623 | "execution_count": null,
624 | "metadata": {},
625 | "outputs": [],
626 | "source": [
627 | "G_coauthorship.es['n_joint_papers'] = 1\n",
628 | "G_coauthorship = G_coauthorship.simplify(combine_edges='sum')"
629 | ]
630 | },
631 | {
632 | "cell_type": "markdown",
633 | "metadata": {},
634 | "source": [
635 | "Let us see how many authors (i.e. nodes) there are in the network. This is called the `vcount` (vertex count) in `igraph`."
636 | ]
637 | },
638 | {
639 | "cell_type": "code",
640 | "execution_count": null,
641 | "metadata": {},
642 | "outputs": [],
643 | "source": [
644 | "G_coauthorship.vcount()"
645 | ]
646 | },
647 | {
648 | "cell_type": "markdown",
649 | "metadata": {},
650 | "source": [
651 | "Similarly, the number of edges is available as the `ecount` of the graph."
652 | ]
653 | },
654 | {
655 | "cell_type": "code",
656 | "execution_count": null,
657 | "metadata": {},
658 | "outputs": [],
659 | "source": [
660 | "G_coauthorship.ecount()"
661 | ]
662 | },
663 | {
664 | "cell_type": "markdown",
665 | "metadata": {},
666 | "source": [
667 | "We can do all sorts of analysis on this network. But first, we will create a bibliographic coupling network."
668 | ]
669 | },
670 | {
671 | "cell_type": "markdown",
672 | "metadata": {},
673 | "source": [
674 | "### Bibliographic coupling"
675 | ]
676 | },
677 | {
678 | "cell_type": "markdown",
679 | "metadata": {},
680 | "source": [
681 | "Bibliographic coupling and co-authorship is in a sense very similar. Previously, we computed for each publication a combination of all co-authors. For bibliographic coupling we can compute for each cited reference the combinations of all citing journals. We will first create a dataframe of all journal citations (`SO`) of a certain cited reference (`CR`). Similar to the authors, we need to first split the cited references."
682 | ]
683 | },
684 | {
685 | "cell_type": "code",
686 | "execution_count": null,
687 | "metadata": {},
688 | "outputs": [],
689 | "source": [
690 | "publication_with_cr_df = publications_df.loc[pd.notnull(publications_df['CR']), ['SO', 'CR']]\n",
691 | "publication_with_cr_df['CR'] = publication_with_cr_df['CR'].str.split('; ')"
692 | ]
693 | },
694 | {
695 | "cell_type": "markdown",
696 | "metadata": {},
697 | "source": [
698 | "We now simply list all citations from a certain journal (`SO`) to a certain cited reference (`CR`)."
699 | ]
700 | },
701 | {
702 | "cell_type": "code",
703 | "execution_count": null,
704 | "metadata": {},
705 | "outputs": [],
706 | "source": [
707 | "journal_cits_df = publication_with_cr_df[['SO', 'CR']].explode('CR')"
708 | ]
709 | },
710 | {
711 | "cell_type": "markdown",
712 | "metadata": {},
713 | "source": [
714 | "We then create all bibliographic couplings per cited reference as follows. We first group by the cited reference (`CR`) and then take all combinations of citing journals."
715 | ]
716 | },
717 | {
718 | "cell_type": "code",
719 | "execution_count": null,
720 | "metadata": {},
721 | "outputs": [],
722 | "source": [
723 | "bibcoupling_per_cr = journal_cits_df.groupby('CR').apply(lambda x: list(itr.combinations(x['SO'], 2)))"
724 | ]
725 | },
726 | {
727 | "cell_type": "markdown",
728 | "metadata": {},
729 | "source": [
730 | "We again `explode` all combinations of two sources citing the same reference."
731 | ]
732 | },
733 | {
734 | "cell_type": "code",
735 | "execution_count": null,
736 | "metadata": {},
737 | "outputs": [],
738 | "source": [
739 | "bibcouplings = bibcoupling_per_cr.explode().dropna()"
740 | ]
741 | },
742 | {
743 | "cell_type": "markdown",
744 | "metadata": {},
745 | "source": [
746 | "We can then create the network."
747 | ]
748 | },
749 | {
750 | "cell_type": "code",
751 | "execution_count": null,
752 | "metadata": {},
753 | "outputs": [],
754 | "source": [
755 | "G_coupling = ig.Graph.TupleList(\n",
756 | " edges=bibcouplings,\n",
757 | " vertex_name_attr='SO',\n",
758 | " directed=False\n",
759 | " )"
760 | ]
761 | },
762 | {
763 | "cell_type": "markdown",
764 | "metadata": {},
765 | "source": [
766 | "\n",
767 | " We again need to simplify this network. Create a new edge attribute called coupling set it to 1 and then sum this attribute when simplifying the network.\n",
768 | "
"
769 | ]
770 | },
771 | {
772 | "cell_type": "code",
773 | "execution_count": null,
774 | "metadata": {},
775 | "outputs": [],
776 | "source": []
777 | },
778 | {
779 | "cell_type": "markdown",
780 | "metadata": {},
781 | "source": [
782 | "This network should be reasonably sized, and you should be able to visualize this network by calling `ig.plot`."
783 | ]
784 | },
785 | {
786 | "cell_type": "code",
787 | "execution_count": null,
788 | "metadata": {},
789 | "outputs": [],
790 | "source": [
791 | "ig.plot(G_coupling, vertex_label=G_coupling.vs['SO'])"
792 | ]
793 | },
794 | {
795 | "cell_type": "markdown",
796 | "metadata": {},
797 | "source": [
798 | "# Network analysis"
799 | ]
800 | },
801 | {
802 | "cell_type": "markdown",
803 | "metadata": {},
804 | "source": [
805 | "Now that we have created some scientometric networks, let us look at some basic analyses of these networks."
806 | ]
807 | },
808 | {
809 | "cell_type": "markdown",
810 | "metadata": {},
811 | "source": [
812 | "## Connectivity"
813 | ]
814 | },
815 | {
816 | "cell_type": "markdown",
817 | "metadata": {},
818 | "source": [
819 | "Let us start with a very simple question. Is the co-authorship network connected?"
820 | ]
821 | },
822 | {
823 | "cell_type": "code",
824 | "execution_count": null,
825 | "metadata": {},
826 | "outputs": [],
827 | "source": [
828 | "G_coauthorship.is_connected()"
829 | ]
830 | },
831 | {
832 | "cell_type": "markdown",
833 | "metadata": {},
834 | "source": [
835 | "Apparently, not all authors in this dataset are connected via co-authored papers."
836 | ]
837 | },
838 | {
839 | "cell_type": "markdown",
840 | "metadata": {},
841 | "source": [
842 | "\n",
843 | "How many authors do you think will be connected to each other? 500? 5000? Almost everybody?\n",
844 | "
"
845 | ]
846 | },
847 | {
848 | "cell_type": "markdown",
849 | "metadata": {},
850 | "source": [
851 | "In order to take a closer look, we need to detect the *connected components*. This is easily done, but the function is confusingly called `clusters`."
852 | ]
853 | },
854 | {
855 | "cell_type": "code",
856 | "execution_count": null,
857 | "metadata": {},
858 | "outputs": [],
859 | "source": [
860 | "components = G_coauthorship.clusters()"
861 | ]
862 | },
863 | {
864 | "cell_type": "markdown",
865 | "metadata": {},
866 | "source": [
867 | "We only want the so-called giant component. "
868 | ]
869 | },
870 | {
871 | "cell_type": "markdown",
872 | "metadata": {},
873 | "source": [
874 | "\n",
875 | "What function do you think returns the giant component?\n",
876 | "
"
877 | ]
878 | },
879 | {
880 | "cell_type": "markdown",
881 | "metadata": {},
882 | "source": [
883 | "\n",
884 | " Remember, you can use Tab and Shift-Tab to find out more about possible functions.\n",
885 | "
"
886 | ]
887 | },
888 | {
889 | "cell_type": "code",
890 | "execution_count": null,
891 | "metadata": {},
892 | "outputs": [],
893 | "source": []
894 | },
895 | {
896 | "cell_type": "markdown",
897 | "metadata": {},
898 | "source": [
899 | "Let us only look at the giant component."
900 | ]
901 | },
902 | {
903 | "cell_type": "code",
904 | "execution_count": null,
905 | "metadata": {},
906 | "outputs": [],
907 | "source": [
908 | "H = components.giant()"
909 | ]
910 | },
911 | {
912 | "cell_type": "markdown",
913 | "metadata": {},
914 | "source": [
915 | "Let us check how many nodes are in the giant component. We can call the function `summary`."
916 | ]
917 | },
918 | {
919 | "cell_type": "code",
920 | "execution_count": null,
921 | "metadata": {},
922 | "outputs": [],
923 | "source": [
924 | "print(H.summary())"
925 | ]
926 | },
927 | {
928 | "cell_type": "markdown",
929 | "metadata": {},
930 | "source": [
931 | "The first line indicates that we have an undirected graph (`U`) with 7871 nodes and 69928 links. The next line shows vertex attributes (indicated by the `v` behind the name of the attribute), and edge attributes (indicated by the `e`)."
932 | ]
933 | },
934 | {
935 | "cell_type": "markdown",
936 | "metadata": {},
937 | "source": [
938 | "\n",
939 | "
\n",
940 | " - What is the percentage of nodes that are in the giant component? \n",
941 | "
- Double check whether the giant component is connected.\n",
942 | "
\n",
943 | "
\n",
992 | "How many nodes are in the path? What is the path length?\n",
993 | "
"
994 | ]
995 | },
996 | {
997 | "cell_type": "markdown",
998 | "metadata": {},
999 | "source": [
1000 | "These numbers probably do not mean that much to you. You can find out more about an individual node by looking at the `VertexSequence` of `igraph`, abbreviated as `vs`. This is a sort of list of all vertices, and is indexed by brackets `[ ]`, similar to lists, instead of parentheses `( )` as we do for functions."
1001 | ]
1002 | },
1003 | {
1004 | "cell_type": "code",
1005 | "execution_count": null,
1006 | "metadata": {},
1007 | "outputs": [],
1008 | "source": [
1009 | "G_coauthorship.vs[0]"
1010 | ]
1011 | },
1012 | {
1013 | "cell_type": "markdown",
1014 | "metadata": {},
1015 | "source": [
1016 | "The vertex itself is also a type of list (called a *dictionary*), and you can only return the author name as follows"
1017 | ]
1018 | },
1019 | {
1020 | "cell_type": "code",
1021 | "execution_count": null,
1022 | "metadata": {},
1023 | "outputs": [],
1024 | "source": [
1025 | "G_coauthorship.vs[0]['author']"
1026 | ]
1027 | },
1028 | {
1029 | "cell_type": "markdown",
1030 | "metadata": {},
1031 | "source": [
1032 | "You can also list multiple vertices at once."
1033 | ]
1034 | },
1035 | {
1036 | "cell_type": "code",
1037 | "execution_count": null,
1038 | "metadata": {},
1039 | "outputs": [],
1040 | "source": [
1041 | "G_coauthorship.vs[[0, 3, 223, 355]]['author']"
1042 | ]
1043 | },
1044 | {
1045 | "cell_type": "markdown",
1046 | "metadata": {},
1047 | "source": [
1048 | "You can of course also simply pass the variable `path` that we constructed earlier."
1049 | ]
1050 | },
1051 | {
1052 | "cell_type": "code",
1053 | "execution_count": null,
1054 | "metadata": {},
1055 | "outputs": [],
1056 | "source": [
1057 | "G_coauthorship.vs[path]['author']"
1058 | ]
1059 | },
1060 | {
1061 | "cell_type": "markdown",
1062 | "metadata": {},
1063 | "source": [
1064 | "This shows that Osaer collaborated with Geert, who collaborated with Van Mark, who in the end collaborated with Watkins."
1065 | ]
1066 | },
1067 | {
1068 | "cell_type": "markdown",
1069 | "metadata": {},
1070 | "source": [
1071 | "You can also get the vertex by searching for the author name. For example, if we want to find `'Van Marck, E'` we can use the following."
1072 | ]
1073 | },
1074 | {
1075 | "cell_type": "code",
1076 | "execution_count": null,
1077 | "metadata": {},
1078 | "outputs": [],
1079 | "source": [
1080 | "G_coauthorship.vs.find(author_eq = 'Van Marck, E')"
1081 | ]
1082 | },
1083 | {
1084 | "cell_type": "markdown",
1085 | "metadata": {},
1086 | "source": [
1087 | "Here `author_eq` refers to the condition that the vertex attribute `author` should **eq**ual `'Van Marck, E'`."
1088 | ]
1089 | },
1090 | {
1091 | "cell_type": "markdown",
1092 | "metadata": {},
1093 | "source": [
1094 | "\n",
1095 | " Find the shortest path from 'Van Marck, E' to 'Migchelsen, S'. Who is in between?\n",
1096 | "
"
1097 | ]
1098 | },
1099 | {
1100 | "cell_type": "code",
1101 | "execution_count": null,
1102 | "metadata": {},
1103 | "outputs": [],
1104 | "source": []
1105 | },
1106 | {
1107 | "cell_type": "markdown",
1108 | "metadata": {},
1109 | "source": [
1110 | "We can let `igraph` also calculate how far apart all nodes are."
1111 | ]
1112 | },
1113 | {
1114 | "cell_type": "markdown",
1115 | "metadata": {},
1116 | "source": [
1117 | "\n",
1118 | "The following may take some time to run\n",
1119 | "
"
1120 | ]
1121 | },
1122 | {
1123 | "cell_type": "code",
1124 | "execution_count": null,
1125 | "metadata": {},
1126 | "outputs": [],
1127 | "source": [
1128 | "path_lengths = G_coauthorship.path_length_hist()\n",
1129 | "print(path_lengths)"
1130 | ]
1131 | },
1132 | {
1133 | "cell_type": "markdown",
1134 | "metadata": {},
1135 | "source": [
1136 | "\n",
1137 | "How far apart are most authors? Do you think most authors are close by? Or do you think they are far apart?\n",
1138 | "
"
1139 | ]
1140 | },
1141 | {
1142 | "cell_type": "markdown",
1143 | "metadata": {},
1144 | "source": [
1145 | "Let us take a closer look at the path between node 0 and node 355 again. Instead of the nodes on the path, we now want to take a closer look at the edges on the path."
1146 | ]
1147 | },
1148 | {
1149 | "cell_type": "code",
1150 | "execution_count": null,
1151 | "metadata": {},
1152 | "outputs": [],
1153 | "source": [
1154 | "epath = G_coauthorship.get_shortest_paths(0, 355, output='epath')\n",
1155 | "epath"
1156 | ]
1157 | },
1158 | {
1159 | "cell_type": "markdown",
1160 | "metadata": {},
1161 | "source": [
1162 | "There are three edges on this path, but the numbers themselves are not very informative. They refer to the edges, and similar to the `VertexSequence` we encountered earlier, there is also an `EdgeSequence`, abbreviated as `es`. Let us take a closer look to the number of joint papers that the authors had co-authored."
1163 | ]
1164 | },
1165 | {
1166 | "cell_type": "code",
1167 | "execution_count": null,
1168 | "metadata": {},
1169 | "outputs": [],
1170 | "source": [
1171 | "G_coauthorship.es[epath[0]]['n_joint_papers']"
1172 | ]
1173 | },
1174 | {
1175 | "cell_type": "markdown",
1176 | "metadata": {},
1177 | "source": [
1178 | "Perhaps there are other paths that connect the two authors with more joint papers? Perhaps we could use the number of joint papers as weights?"
1179 | ]
1180 | },
1181 | {
1182 | "cell_type": "code",
1183 | "execution_count": null,
1184 | "metadata": {},
1185 | "outputs": [],
1186 | "source": [
1187 | "epath = G_coauthorship.get_shortest_paths(0, 355, weights='n_joint_papers', output='epath')\n",
1188 | "epath"
1189 | ]
1190 | },
1191 | {
1192 | "cell_type": "markdown",
1193 | "metadata": {},
1194 | "source": [
1195 | "We do get a different path, which it is actually longer. Let us take a look at the number of joint papers."
1196 | ]
1197 | },
1198 | {
1199 | "cell_type": "code",
1200 | "execution_count": null,
1201 | "metadata": {},
1202 | "outputs": [],
1203 | "source": [
1204 | "G_coauthorship.es[epath[0]]['n_joint_papers']"
1205 | ]
1206 | },
1207 | {
1208 | "cell_type": "markdown",
1209 | "metadata": {},
1210 | "source": [
1211 | "The total number of joint papers is lower! That is because *shortest path* means: the path with the lowest sum of the weights. This is clearly not what we want. You should always be aware of this whenever using the concept of the *shortest path*."
1212 | ]
1213 | },
1214 | {
1215 | "cell_type": "markdown",
1216 | "metadata": {},
1217 | "source": [
1218 | "\n",
1219 | "Attention! Weighted shortest paths have the lowest total weight.\n",
1220 | "
"
1221 | ]
1222 | },
1223 | {
1224 | "cell_type": "markdown",
1225 | "metadata": {},
1226 | "source": [
1227 | "## Clustering coefficient"
1228 | ]
1229 | },
1230 | {
1231 | "cell_type": "markdown",
1232 | "metadata": {},
1233 | "source": [
1234 | "Let us look whether co-authors of an author also tend to be co-authors among themselves."
1235 | ]
1236 | },
1237 | {
1238 | "cell_type": "markdown",
1239 | "metadata": {},
1240 | "source": [
1241 | "Let us take a look at the co-authors of of author number 0, which are called the *neighbors* in network terminology."
1242 | ]
1243 | },
1244 | {
1245 | "cell_type": "code",
1246 | "execution_count": null,
1247 | "metadata": {},
1248 | "outputs": [],
1249 | "source": [
1250 | "G_coauthorship.neighborhood(0)"
1251 | ]
1252 | },
1253 | {
1254 | "cell_type": "markdown",
1255 | "metadata": {},
1256 | "source": [
1257 | "What we actually want to know is whether many of those neighors are connected. That is, we want to take the subgraph of all authors that have co-authored with author number 0."
1258 | ]
1259 | },
1260 | {
1261 | "cell_type": "code",
1262 | "execution_count": null,
1263 | "metadata": {},
1264 | "outputs": [],
1265 | "source": [
1266 | "H = G_coauthorship.induced_subgraph(G_coauthorship.neighborhood(0))\n",
1267 | "print(H.summary())"
1268 | ]
1269 | },
1270 | {
1271 | "cell_type": "markdown",
1272 | "metadata": {},
1273 | "source": [
1274 | "This subgraph only has 4 nodes (including node 0, so it has 3 neighbours) and 6 edges. This is sufficiently small to be easily plotted for visual inspection."
1275 | ]
1276 | },
1277 | {
1278 | "cell_type": "code",
1279 | "execution_count": null,
1280 | "metadata": {},
1281 | "outputs": [],
1282 | "source": [
1283 | "H.vs['color'] = 'red'\n",
1284 | "H.vs[0]['color'] = 'grey'\n",
1285 | "ig.plot(H)"
1286 | ]
1287 | },
1288 | {
1289 | "cell_type": "markdown",
1290 | "metadata": {},
1291 | "source": [
1292 | "\n",
1293 | "Do many of the co-authors collaborate among themselves as well? Why do you think this happens?\n",
1294 | "
"
1295 | ]
1296 | },
1297 | {
1298 | "cell_type": "markdown",
1299 | "metadata": {},
1300 | "source": [
1301 | "We can also ask `igraph` to calculate the clustering coefficient (which is called *transitivity* in igraph, which is the same concept using different terms) of node 0."
1302 | ]
1303 | },
1304 | {
1305 | "cell_type": "code",
1306 | "execution_count": null,
1307 | "metadata": {},
1308 | "outputs": [],
1309 | "source": [
1310 | "G_coauthorship.transitivity_local_undirected(0)"
1311 | ]
1312 | },
1313 | {
1314 | "cell_type": "markdown",
1315 | "metadata": {},
1316 | "source": [
1317 | "\n",
1318 | "What percentage of the co-authors of node 0 have also written papers with each other?\n",
1319 | "
"
1320 | ]
1321 | },
1322 | {
1323 | "cell_type": "code",
1324 | "execution_count": null,
1325 | "metadata": {},
1326 | "outputs": [],
1327 | "source": []
1328 | },
1329 | {
1330 | "cell_type": "markdown",
1331 | "metadata": {},
1332 | "source": [
1333 | "You can calculate the average for all nodes using the function `transitivity_avglocal_undirected`."
1334 | ]
1335 | },
1336 | {
1337 | "cell_type": "markdown",
1338 | "metadata": {},
1339 | "source": [
1340 | "\n",
1341 | "What percentage of the co-authors have also written papers with each other on average? Do you think this is high or not?\n",
1342 | "
"
1343 | ]
1344 | },
1345 | {
1346 | "cell_type": "code",
1347 | "execution_count": null,
1348 | "metadata": {},
1349 | "outputs": [],
1350 | "source": []
1351 | },
1352 | {
1353 | "cell_type": "markdown",
1354 | "metadata": {},
1355 | "source": [
1356 | "## Centrality"
1357 | ]
1358 | },
1359 | {
1360 | "cell_type": "markdown",
1361 | "metadata": {},
1362 | "source": [
1363 | "Often, people want to identify wich nodes seem to be most important in some way in the network. This is often thought of as a type of *centrality* of a node."
1364 | ]
1365 | },
1366 | {
1367 | "cell_type": "markdown",
1368 | "metadata": {},
1369 | "source": [
1370 | "### Degree"
1371 | ]
1372 | },
1373 | {
1374 | "cell_type": "markdown",
1375 | "metadata": {},
1376 | "source": [
1377 | "The simplest type of centrality is the *degree* of a node, which is simply the number of its neighbors. Previously, we saw that node 0 had 3 neighbors, we therefore say its degree is 3."
1378 | ]
1379 | },
1380 | {
1381 | "cell_type": "code",
1382 | "execution_count": null,
1383 | "metadata": {},
1384 | "outputs": [],
1385 | "source": [
1386 | "G_coauthorship.degree(0)"
1387 | ]
1388 | },
1389 | {
1390 | "cell_type": "markdown",
1391 | "metadata": {},
1392 | "source": [
1393 | "We can also simply calculate the degree for everybody and store it in a new vertex attribute called `degree`."
1394 | ]
1395 | },
1396 | {
1397 | "cell_type": "code",
1398 | "execution_count": null,
1399 | "metadata": {},
1400 | "outputs": [],
1401 | "source": [
1402 | "G_coauthorship.vs['degree'] = G_coauthorship.degree()"
1403 | ]
1404 | },
1405 | {
1406 | "cell_type": "markdown",
1407 | "metadata": {},
1408 | "source": [
1409 | "\n",
1410 | " What is the degree of 'Van Marck, E'?\n",
1411 | "
"
1412 | ]
1413 | },
1414 | {
1415 | "cell_type": "code",
1416 | "execution_count": null,
1417 | "metadata": {},
1418 | "outputs": [],
1419 | "source": []
1420 | },
1421 | {
1422 | "cell_type": "markdown",
1423 | "metadata": {},
1424 | "source": [
1425 | "We can also take a look at the complete degree distribution. To plot it, we load the `matplotlib` package. We import the plotting functionality and name the package `plt`. We also include a statement telling Python to show the plots immediately in this notebook."
1426 | ]
1427 | },
1428 | {
1429 | "cell_type": "code",
1430 | "execution_count": null,
1431 | "metadata": {},
1432 | "outputs": [],
1433 | "source": [
1434 | "import matplotlib.pyplot as plt\n",
1435 | "%matplotlib inline"
1436 | ]
1437 | },
1438 | {
1439 | "cell_type": "markdown",
1440 | "metadata": {},
1441 | "source": [
1442 | "Now let us plot a histogram of the degree, using 50 bins."
1443 | ]
1444 | },
1445 | {
1446 | "cell_type": "code",
1447 | "execution_count": null,
1448 | "metadata": {},
1449 | "outputs": [],
1450 | "source": [
1451 | "plt.hist(G_coauthorship.vs['degree'], 50);\n",
1452 | "plt.yscale('log')"
1453 | ]
1454 | },
1455 | {
1456 | "cell_type": "markdown",
1457 | "metadata": {},
1458 | "source": [
1459 | "This clearly shows that the degree distribution is quite skewed. Most authors have only few collaborators, while a few authors have many collaborators. If the degree distribution is so skewed, it is sometimes referred to as a *scale-free* network, although the exact definition has been a topic of intense discussion recently."
1460 | ]
1461 | },
1462 | {
1463 | "cell_type": "markdown",
1464 | "metadata": {},
1465 | "source": [
1466 | "The code below sorts the nodes in descending order of the degree."
1467 | ]
1468 | },
1469 | {
1470 | "cell_type": "code",
1471 | "execution_count": null,
1472 | "metadata": {},
1473 | "outputs": [],
1474 | "source": [
1475 | "highest_degree = sorted(G_coauthorship.vs, key=lambda v: v['degree'], reverse=True)"
1476 | ]
1477 | },
1478 | {
1479 | "cell_type": "markdown",
1480 | "metadata": {},
1481 | "source": [
1482 | "The `sorted` function takes a list as input, `G_coauthorship.vs` in our case, and sorts it according to a sort key. We indicate the sort key by a small function, called a `lambda` function, that returns the degree. In other words, the `sorted` function will sort the nodes according to the degree. By indicating `reverse=True` we obtain a list that is sorted highest to lowest, instead of the other way around."
1483 | ]
1484 | },
1485 | {
1486 | "cell_type": "markdown",
1487 | "metadata": {},
1488 | "source": [
1489 | "You can look at the first five results in the following way."
1490 | ]
1491 | },
1492 | {
1493 | "cell_type": "code",
1494 | "execution_count": null,
1495 | "metadata": {},
1496 | "outputs": [],
1497 | "source": [
1498 | "highest_degree[:5]"
1499 | ]
1500 | },
1501 | {
1502 | "cell_type": "markdown",
1503 | "metadata": {},
1504 | "source": [
1505 | "So, apparently, U D'Allessandro has collaborated with 715 other authors! This of course only considers the number of co-authors, it does not take into account the number of papers written with somebody else.\n",
1506 | "When specifying such *edge weights* like the number of joint papers, the weighted degree is referred to as the *strength* of a node (which is sometimes a bit confusing term). \n",
1507 | "\n",
1508 | "Let us look at the strength of node 0."
1509 | ]
1510 | },
1511 | {
1512 | "cell_type": "code",
1513 | "execution_count": null,
1514 | "metadata": {},
1515 | "outputs": [],
1516 | "source": [
1517 | "G_coauthorship.strength(0, weights='n_joint_papers')"
1518 | ]
1519 | },
1520 | {
1521 | "cell_type": "markdown",
1522 | "metadata": {},
1523 | "source": [
1524 | "Apparently, author 0 collaborated with 3 different authors, and has a total strength of 3. But what does this 3 mean? We need to carefully think about this. Suppose that author 0 has co-authored a single publication with three other co-authors, then each of the three co-authors would have an edge weight of `n_joint_papers = 1`. So, the strenght would be 3. Hence, the strength denotes the total number of collaborations that an author had, which depends both on the number of publications and the number of collaborators per paper.\n",
1525 | "\n",
1526 | "Sometimes, we wish to take into account the number of co-authorships when creating a link weight. We can then fractionally count the weight of each collaboration between $n_a$ authors as\n",
1527 | "\n",
1528 | "$$\\frac{1}{n_a - 1}.$$\n",
1529 | "\n",
1530 | "We need to go back to the `publications_df` in order to construct such a *fractional* edge weight."
1531 | ]
1532 | },
1533 | {
1534 | "cell_type": "code",
1535 | "execution_count": null,
1536 | "metadata": {},
1537 | "outputs": [],
1538 | "source": [
1539 | "import itertools as itr\n",
1540 | "[(coauthor[0], coauthor[1], 1/(len(authors) - 1)) for coauthor in itr.combinations(authors, 2)]"
1541 | ]
1542 | },
1543 | {
1544 | "cell_type": "markdown",
1545 | "metadata": {},
1546 | "source": [
1547 | "We again do this for all publications."
1548 | ]
1549 | },
1550 | {
1551 | "cell_type": "code",
1552 | "execution_count": null,
1553 | "metadata": {},
1554 | "outputs": [],
1555 | "source": [
1556 | "coauthors_per_publication = publications_df['AU_split'].apply(\n",
1557 | " lambda authors: \n",
1558 | " [(coauthor[0], coauthor[1], 1, 1/(len(authors) - 1)) \n",
1559 | " for coauthor in itr.combinations(authors, 2)])"
1560 | ]
1561 | },
1562 | {
1563 | "cell_type": "markdown",
1564 | "metadata": {},
1565 | "source": [
1566 | "The variable `coauthors_per_publication` is now a list of a list of co-authors per publication, but including a full weight of `1` and a fractional weight of `1/(len(authors) - 1)`, where `len(authors)` is the number of authors of the publications. We again `explode` this list."
1567 | ]
1568 | },
1569 | {
1570 | "cell_type": "code",
1571 | "execution_count": null,
1572 | "metadata": {},
1573 | "outputs": [],
1574 | "source": [
1575 | "coauthors = coauthors_per_publication.explode().dropna()"
1576 | ]
1577 | },
1578 | {
1579 | "cell_type": "markdown",
1580 | "metadata": {},
1581 | "source": [
1582 | "We can again create the network, but now we can pass two edge attributes, `n_joint_papers` and `n_joint_papers_frac`. We of course also have to simplify the network again."
1583 | ]
1584 | },
1585 | {
1586 | "cell_type": "code",
1587 | "execution_count": null,
1588 | "metadata": {},
1589 | "outputs": [],
1590 | "source": [
1591 | "G_coauthorship = ig.Graph.TupleList(\n",
1592 | " edges=coauthors.to_list(),\n",
1593 | " vertex_name_attr='author',\n",
1594 | " directed=False,\n",
1595 | " edge_attrs=('n_joint_papers', 'n_joint_papers_frac')\n",
1596 | " )\n",
1597 | "G_coauthorship = G_coauthorship.simplify(loops=False, combine_edges='sum')"
1598 | ]
1599 | },
1600 | {
1601 | "cell_type": "markdown",
1602 | "metadata": {},
1603 | "source": [
1604 | "\n",
1605 | "What is the sum of
n_joint_papers_frac over all co-authors? Then shouldn't the strength sum up to a whole number? Why isn't that the case here? (Hint: look at the authors of publication
'WOS:000242241600004'"
1607 | ]
1608 | },
1609 | {
1610 | "cell_type": "code",
1611 | "execution_count": null,
1612 | "metadata": {},
1613 | "outputs": [],
1614 | "source": [
1615 | "publications_df.loc['WOS:000242241600004', 'AU']"
1616 | ]
1617 | },
1618 | {
1619 | "cell_type": "markdown",
1620 | "metadata": {},
1621 | "source": [
1622 | "### Betweenness centrality"
1623 | ]
1624 | },
1625 | {
1626 | "cell_type": "markdown",
1627 | "metadata": {},
1628 | "source": [
1629 | "Betweenness centrality is much more elaborate, and gives an indication of the number of times a node is on the shortest path from one node to another node.\n",
1630 | "\n",
1631 | "As you can imagine, this can take quite some time to calculate for all nodes. We will therefore use the somewhat smaller bibliographic coupling network of journals."
1632 | ]
1633 | },
1634 | {
1635 | "cell_type": "markdown",
1636 | "metadata": {},
1637 | "source": [
1638 | "\n",
1639 | " Note: On larger networks, it may take a long time to calculate the betweenness centrality.\n",
1640 | "
"
1641 | ]
1642 | },
1643 | {
1644 | "cell_type": "code",
1645 | "execution_count": null,
1646 | "metadata": {},
1647 | "outputs": [],
1648 | "source": [
1649 | "G_coupling.vs['betweenness'] = G_coupling.betweenness()"
1650 | ]
1651 | },
1652 | {
1653 | "cell_type": "markdown",
1654 | "metadata": {},
1655 | "source": [
1656 | "Now we can look at the journals that have the highest betweenness."
1657 | ]
1658 | },
1659 | {
1660 | "cell_type": "code",
1661 | "execution_count": null,
1662 | "metadata": {},
1663 | "outputs": [],
1664 | "source": [
1665 | "sorted(G_coupling.vs, key=lambda v: v['betweenness'], reverse=True)[:5]"
1666 | ]
1667 | },
1668 | {
1669 | "cell_type": "markdown",
1670 | "metadata": {},
1671 | "source": [
1672 | "As we did previously when dealing with shortest paths, we can also use a weight for determining the shortest paths."
1673 | ]
1674 | },
1675 | {
1676 | "cell_type": "code",
1677 | "execution_count": null,
1678 | "metadata": {},
1679 | "outputs": [],
1680 | "source": [
1681 | "G_coupling.vs['betweenness_weighted'] = G_coupling.betweenness(weights='coupling')"
1682 | ]
1683 | },
1684 | {
1685 | "cell_type": "markdown",
1686 | "metadata": {},
1687 | "source": [
1688 | "\n",
1689 | "What is journal with the highest weighted betweenness centrality? Does this make sense if you compare it to the unweighted betweenness centrality?\n",
1690 | "
"
1691 | ]
1692 | },
1693 | {
1694 | "cell_type": "code",
1695 | "execution_count": null,
1696 | "metadata": {},
1697 | "outputs": [],
1698 | "source": []
1699 | },
1700 | {
1701 | "cell_type": "markdown",
1702 | "metadata": {},
1703 | "source": [
1704 | "\n",
1705 | " Attention! Weighted shortest paths have the lowest total weight.\n",
1706 | "
"
1707 | ]
1708 | },
1709 | {
1710 | "cell_type": "markdown",
1711 | "metadata": {},
1712 | "source": [
1713 | "### Pagerank"
1714 | ]
1715 | },
1716 | {
1717 | "cell_type": "markdown",
1718 | "metadata": {},
1719 | "source": [
1720 | "One way of identifying central nodes relies on the idea of a random walk in a network. We will study this in the journal bibliographic coupling network. When performing such a random walk, we simply go from one journal to the next, following the bibliographic coupling links. The journal that is most frequently visited during such a random walk is then seen as most central. This is actually the idea that underlies Google's famous search engine. Luckily, we can compute that a lot faster than betweenness."
1721 | ]
1722 | },
1723 | {
1724 | "cell_type": "code",
1725 | "execution_count": null,
1726 | "metadata": {},
1727 | "outputs": [],
1728 | "source": [
1729 | "G_coupling.vs['pagerank'] = G_coupling.pagerank()"
1730 | ]
1731 | },
1732 | {
1733 | "cell_type": "markdown",
1734 | "metadata": {},
1735 | "source": [
1736 | "\n",
1737 | "Get the top 5 most central journals according to Pagerank. Who is the most central? Are the results very different from the betweenness?\n",
1738 | "
"
1739 | ]
1740 | },
1741 | {
1742 | "cell_type": "code",
1743 | "execution_count": null,
1744 | "metadata": {},
1745 | "outputs": [],
1746 | "source": []
1747 | },
1748 | {
1749 | "cell_type": "markdown",
1750 | "metadata": {},
1751 | "source": [
1752 | "We can again take into account the weights. In pagerank this means that a journal that is a more closely bibliographically coupled will be more likely to be visited during a random walk. This is actually much more in line with our intuition than the shortest path. Let us see what we get if we do that."
1753 | ]
1754 | },
1755 | {
1756 | "cell_type": "code",
1757 | "execution_count": null,
1758 | "metadata": {},
1759 | "outputs": [],
1760 | "source": [
1761 | "G_coupling.vs['pagerank_weighted'] = G_coupling.pagerank(weights='coupling')"
1762 | ]
1763 | },
1764 | {
1765 | "cell_type": "markdown",
1766 | "metadata": {},
1767 | "source": [
1768 | "\n",
1769 | "Are the results different for the weighted version of pagerank?\n",
1770 | "
"
1771 | ]
1772 | },
1773 | {
1774 | "cell_type": "code",
1775 | "execution_count": null,
1776 | "metadata": {},
1777 | "outputs": [],
1778 | "source": []
1779 | },
1780 | {
1781 | "cell_type": "markdown",
1782 | "metadata": {},
1783 | "source": [
1784 | "\n",
1785 | "Pagerank is very similar to the techniques that underly the journal \"Eigenfactor\" and the \"SCImago Journal Rank\", which are seen as indicators of the scientific impact of a journal. Do you think it makes sense to interpret Pagerank on a bibliographic coupling network as the scientific impact of a journal? Why (not)?\n",
1786 | "
"
1787 | ]
1788 | },
1789 | {
1790 | "cell_type": "markdown",
1791 | "metadata": {},
1792 | "source": [
1793 | "## Co-authorship using bipartite projection (optional)"
1794 | ]
1795 | },
1796 | {
1797 | "cell_type": "markdown",
1798 | "metadata": {},
1799 | "source": [
1800 | "We can also create co-authorship using a more theoretical approach from graph theory. We can first construct a network consisting of publications and authors."
1801 | ]
1802 | },
1803 | {
1804 | "cell_type": "markdown",
1805 | "metadata": {},
1806 | "source": [
1807 | "We first again `explode` all authors for each publication, and create a graph out of it."
1808 | ]
1809 | },
1810 | {
1811 | "cell_type": "code",
1812 | "execution_count": null,
1813 | "metadata": {},
1814 | "outputs": [],
1815 | "source": [
1816 | "author_pubs_df = publications_df['AU_split'].explode()\n",
1817 | "\n",
1818 | "G_pub_authors = ig.Graph.TupleList(\n",
1819 | " edges=author_pubs_df.reset_index().values,\n",
1820 | " vertex_name_attr='name',\n",
1821 | " directed=False\n",
1822 | " )"
1823 | ]
1824 | },
1825 | {
1826 | "cell_type": "markdown",
1827 | "metadata": {},
1828 | "source": [
1829 | "This network consists of two types: publications and authors. This is called a *bipartite* graph. We can automatically get the types using `is_bipartite`."
1830 | ]
1831 | },
1832 | {
1833 | "cell_type": "code",
1834 | "execution_count": null,
1835 | "metadata": {},
1836 | "outputs": [],
1837 | "source": [
1838 | "is_bipartite, types = G_pub_authors.is_bipartite(return_types = True)\n",
1839 | "print(is_bipartite)"
1840 | ]
1841 | },
1842 | {
1843 | "cell_type": "markdown",
1844 | "metadata": {},
1845 | "source": [
1846 | "The actual types are simply returned as a list of `True` and `False` values, which are arbitrary labels for publications and authors. Let us see what the first label stands for."
1847 | ]
1848 | },
1849 | {
1850 | "cell_type": "code",
1851 | "execution_count": null,
1852 | "metadata": {},
1853 | "outputs": [],
1854 | "source": [
1855 | "print(types[0])\n",
1856 | "print(G_pub_authors.vs[0])"
1857 | ]
1858 | },
1859 | {
1860 | "cell_type": "markdown",
1861 | "metadata": {},
1862 | "source": [
1863 | "From the `name` of node `0` we can see that it refers to a publication, and so `False` indicates publications, while `True` indicates authors."
1864 | ]
1865 | },
1866 | {
1867 | "cell_type": "markdown",
1868 | "metadata": {},
1869 | "source": [
1870 | "We now would like to perform a so-called *bipartite projection* onto the authors. This is exactly the type of operation that leads to a co-authorship network. If we were to *project* onto the publication, we would end up with a network of publications where each pair of publications is linked if it is authored by the same author."
1871 | ]
1872 | },
1873 | {
1874 | "cell_type": "code",
1875 | "execution_count": null,
1876 | "metadata": {},
1877 | "outputs": [],
1878 | "source": [
1879 | "G_author_projection = G_pub_authors.bipartite_projection(types=types, which=True)"
1880 | ]
1881 | },
1882 | {
1883 | "cell_type": "markdown",
1884 | "metadata": {},
1885 | "source": [
1886 | "By default, it keeps track of the *multiplicity* (i.e. the number of joint papers) in the `weight` edge attribute. Unfortunately, it is not possible to do fractional counting using this approach."
1887 | ]
1888 | },
1889 | {
1890 | "cell_type": "markdown",
1891 | "metadata": {},
1892 | "source": [
1893 | "\n",
1894 | " Check the number of nodes in the bipartite projection. Why is it different from the number of nodes in the earlier constructed G_coauthorship? (Hint: checkout the degree.)\n",
1895 | "
"
1896 | ]
1897 | },
1898 | {
1899 | "cell_type": "code",
1900 | "execution_count": null,
1901 | "metadata": {},
1902 | "outputs": [],
1903 | "source": []
1904 | },
1905 | {
1906 | "cell_type": "markdown",
1907 | "metadata": {},
1908 | "source": [
1909 | "# Analysis of your own data"
1910 | ]
1911 | },
1912 | {
1913 | "cell_type": "markdown",
1914 | "metadata": {},
1915 | "source": [
1916 | "You have now learned the basics of handling WoS files and transforming them into scientometric networks. Please take some time now to do your own analysis."
1917 | ]
1918 | },
1919 | {
1920 | "cell_type": "markdown",
1921 | "metadata": {},
1922 | "source": [
1923 | "\n",
1924 | "Go to
Web of Science and select a publication set of interest. Make sure that the number of publications is higher than 1000, but lower than 5000. Export the files as follows:\n",
1925 | "
\n",
1926 | " - Export using \"Save to Other File Formats\".\n",
1927 | "
- Select the appropriate records (e.g. 1-500, 501-1000, etc...).\n",
1928 | "
- Select the Record Content \"Full Record and Cited References\".\n",
1929 | "
- Select the File Format \"Tab delimited (Win, UTF8)\".\n",
1930 | "
- Click on Send.\n",
1931 | "
\n",
1932 | "Repeat the above steps for each batch of 500 publications.\n",
1933 | "\n",
1934 | "Load the data from all files you downloaded using
pandas\n",
1935 | "
\n",
1950 | "Create a co-authorship network of your publications. Hint: use the approach you encountered earlier.\n",
1951 | "
"
1952 | ]
1953 | },
1954 | {
1955 | "cell_type": "code",
1956 | "execution_count": null,
1957 | "metadata": {},
1958 | "outputs": [],
1959 | "source": []
1960 | },
1961 | {
1962 | "cell_type": "markdown",
1963 | "metadata": {},
1964 | "source": [
1965 | "\n",
1966 | "Identify the authors that are most central to the coauthorship network and interpret the results.\n",
1967 | "
"
1968 | ]
1969 | },
1970 | {
1971 | "cell_type": "code",
1972 | "execution_count": null,
1973 | "metadata": {},
1974 | "outputs": [],
1975 | "source": []
1976 | },
1977 | {
1978 | "cell_type": "markdown",
1979 | "metadata": {},
1980 | "source": [
1981 | "\n",
1982 | "Create a co-citation network of your publications. Hint: use the bibliographic coupling approach, but switch the roles of the source and the target.\n",
1983 | "
"
1984 | ]
1985 | },
1986 | {
1987 | "cell_type": "code",
1988 | "execution_count": null,
1989 | "metadata": {},
1990 | "outputs": [],
1991 | "source": []
1992 | },
1993 | {
1994 | "cell_type": "markdown",
1995 | "metadata": {},
1996 | "source": [
1997 | "\n",
1998 | "Identify the publications that are most central to the co-citation network and interpret the results. Are they relatively recent publications or not?\n",
1999 | "
"
2000 | ]
2001 | },
2002 | {
2003 | "cell_type": "code",
2004 | "execution_count": null,
2005 | "metadata": {},
2006 | "outputs": [],
2007 | "source": []
2008 | }
2009 | ],
2010 | "metadata": {
2011 | "kernelspec": {
2012 | "display_name": "Python 3",
2013 | "language": "python",
2014 | "name": "python3"
2015 | },
2016 | "language_info": {
2017 | "codemirror_mode": {
2018 | "name": "ipython",
2019 | "version": 3
2020 | },
2021 | "file_extension": ".py",
2022 | "mimetype": "text/x-python",
2023 | "name": "python",
2024 | "nbconvert_exporter": "python",
2025 | "pygments_lexer": "ipython3",
2026 | "version": "3.8.3"
2027 | }
2028 | },
2029 | "nbformat": 4,
2030 | "nbformat_minor": 2
2031 | }
2032 |
--------------------------------------------------------------------------------