This repository provides the source code for EvalNE, an open-source Python library designed for assessing and comparing the performance of Network Embedding (NE) methods on Link Prediction (LP), Sign prediction (SP), Network Reconstruction (NR) and Node Classification (NC) tasks. The library intends to simplify these complex and time consuming evaluation processes by providing automation and abstraction of tasks such as hyper-parameter tuning and model validation, node and edge sampling, node-pair embedding computation, results reporting and data visualization.
The library can be used both as a command line tool and an API. In its current version, EvalNE can evaluate unweighted directed and undirected simple networks.
A Graphical User Interface based on Plotly Dash has been recently added to EvalNE. The interface allows users to set up and execute EvalNE evaluations in an intuitive and interactive way, monitor system resources and browse previous evaluations. Check out the project here -> EvalNE-gui.
Interested in robustness evaluation? That can also be done using EvalNE! Check out the following project (we will port it into the main library very soon): EvalNE-robustness.
The library is maintained by Alexandru Mara (alexandru.mara(at)ugent.be). The full documentation of EvalNE is hosted by Read the Docs and can be found here.
A command line interface in combination with a configuration file (describing datasets, methods and evaluation setup) allows the user to evaluate any embedding method and compare it to the state of the art or replicate the experimental setup of existing papers without the need to write additional code. EvalNE does not provide implementations of any NE methods but offers the necessary environment to evaluate any off-the-shelf algorithm. Implementations of NE methods can be obtained from libraries such as OpenNE or GEM as well as directly from the web pages of the authors e.g. Deepwalk, Node2vec, LINE, PRUNE, Metapath2vec, CNE.
EvalNE does, however, includes the following LP heuristics for both directed and undirected networks (in and out node neighbourhoods), which can be used as baselines for different downstream tasks:
When used as an API, EvalNE provides functions to:
The latest version of the library (v0.4.0) has been tested on Python 3.8.
EvalNE depends on the following packages:
Before installing EvalNE make sure that pip
and python-tk
packages are installed
on your system, this can be done by running:
sudo apt-get install python3-pip
sudo apt-get install python3-tk
Option 1: Install the library using pip:
pip install evalne
Option 2: Cloning the code and installing:
Clone the EvalNE repository:
git clone https://github.com/Dru-Mara/EvalNE.git
cd EvalNE
Download dependencies and install the library:
# System-wide install
sudo python setup.py install
# Alternative install for a single user
python setup.py install --user
Check the installation by running simple_example.py
or functions_example.py
as shown below.
If you have installed the package using pip, you will need to download the examples folder from
the github repository first.
cd examples/
python simple_example.py
NOTE: In order to run the evaluator_example.py
script, the
OpenNE library, PRUNE and Metapath2Vec are required. The instructions for installing
them are available
here, here,
and here,
respectively. The instructions on how to run evaluations using .ini files are
provided in the next section.
The library takes as input an .ini configuration file. This file allows the user to specify the evaluation settings, from the task to perform to the networks to use, data preprocessing, methods and baselines to evaluate, and types of output to provide.
An example conf.ini
file is provided describing the available options
for each parameter. This file can be either modified to simulate different
evaluation settings or used as a template to generate other .ini files.
Additional configuration (.ini) files are provided replicating the experimental
sections of different papers in the NE literature. These can be found in different
folders under examples/replicated_setups
. One such configuration file is
examples/replicated_setups/node2vec/conf_node2vec.ini
. This file simulates the link
prediction experiments of the paper "Scalable Feature Learning for Networks" by A. Grover
and J. Leskovec.
Once the configuration is set, the evaluation can be run as indicated in the next subsection.
In order to run the evaluations using the provided conf.ini
or any other .ini
file, the following steps are necessary:
Download/Install the methods you want to test:
Download the datasets used in the examples:
conf.ini
:
Set the correct dataset paths in the INPATHS option of the corresponding .ini file. And the correct method paths under METHODS_OPNE and/or METHODS_OTHER options.
Run the evaluation:
# For conf.ini run:
python -m evalne ./examples/conf.ini
# For conf_node2vec.ini run:
python -m evalne ./examples/node2vec/conf_node2vec.ini
Note: The input networks for EvalNE are required to be in edgelist format.
The library can be imported and used like any other Python module. Next, we
present a very basic LP example, for more complete ones we refer the user to the
examples
folder and the docstring documentation of the evaluator and the split submodules.
from evalne.evaluation.evaluator import LPEvaluator
from evalne.evaluation.split import LPEvalSplit
from evalne.evaluation.score import Scoresheet
from evalne.utils import preprocess as pp
# Load and preprocess the network
G = pp.load_graph('../evalne/tests/data/network.edgelist')
G, _ = pp.prep_graph(G)
# Create an evaluator and generate train/test edge split
traintest_split = LPEvalSplit()
traintest_split.compute_splits(G)
nee = LPEvaluator(traintest_split)
# Create a Scoresheet to store the results
scoresheet = Scoresheet()
# Set the baselines
methods = ['random_prediction', 'common_neighbours', 'jaccard_coefficient']
# Evaluate baselines
for method in methods:
result = nee.evaluate_baseline(method=method)
scoresheet.log_results(result)
try:
# Check if OpenNE is installed
import openne
# Set embedding methods from OpenNE
methods = ['node2vec', 'deepwalk', 'GraRep']
commands = [
'python -m openne --method node2vec --graph-format edgelist --p 1 --q 1',
'python -m openne --method deepWalk --graph-format edgelist --number-walks 40',
'python -m openne --method grarep --graph-format edgelist --epochs 10']
edge_emb = ['average', 'hadamard']
# Evaluate embedding methods
for i in range(len(methods)):
command = commands[i] + " --input {} --output {} --representation-size {}"
results = nee.evaluate_cmd(method_name=methods[i], method_type='ne', command=command,
edge_embedding_methods=edge_emb, input_delim=' ', output_delim=' ')
scoresheet.log_results(results)
except ImportError:
print("The OpenNE library is not installed. Reporting results only for the baselines...")
pass
# Get output
scoresheet.print_tabular()
The library stores all the output generated in a single folder per execution. The name
of this folder is: {task}_eval_{month}{day}_{hour}{min}
. Where {task}
is one of:
lp, sp, nr or nc.
The library can provide two types of outputs, depending on the value of the SCORES option
of the configuration file. If the keyword all is specified, the library will generate a
file named eval_output.txt
containing for each method and network analysed all the
metrics available (auroc, precision, f-score, etc.). If more than one experiment repeat
is requested the values reported will be the average over all the repeats.
Setting the SCORES option to %(maximize)
will generate a similar output file as before.
The content of this file, however, will be a table (Alg. x Networks) containing exclusively
the score specified in the MAXIMIZE option for each combination of method and network
averaged over all experiment repeats. In addition a second table indicating the average
execution time per method and dataset will be generated.
If the option CURVES is set to a valid option then for each method dataset and experiment repeat a PR or ROC curve will be generated. If the option SAVE_PREP_NW is set to True, each evaluated network will be stored, in edgelist format, in a folder with the same name as the network.
Finally, the library also generates an eval.log
file and a eval.pkl
. The first file
contains important information regarding the evaluation process such as methods whose
execution has failed, or validation scores. The second one encapsulates all the evaluation
results as a pickle file. This file can be conveniently loaded and the results can be
transformed into e.g. pandas dataframes or latex tables.
EvalNE makes extensive use of numpy for most operations. Numpy, in turn,
uses other libraries such as OpenMP, MKL, etc., to provide parallelization. In order to allow for
certain control on the maximum number of threads used during execution, we include a simple bash
script (set_numpy_threads.sh
). The script located inside the scripts
folder can be given execution
permissions and run as follows:
# Give execution permissions:
chmod +x set_numpy_threads.sh
# Run the script:
source set_numpy_threads.sh
# The script will then ask for the maximum number of threads to use.
Contributions are greatly appreciated. If you want to help us improve EvalNE, please fork the repo and create a new pull request. Don't forget to give the project a star! Thanks!
git checkout -b feature/AmazingFeature
)git commit -m 'Add some AmazingFeature'
)git push origin feature/AmazingFeature
)Alternatively, you can make suggestions or report bugs by opening a new issue with the appropriate tag ("feature" or "bug") and following our Contributing template.
Distributed under the MIT License. See LICENSE.txt
for more information.
If you have found EvaNE useful in your research, please consider giving the repo a star and citing our paper:
@article{MARA2022evalne,
title = {EvalNE: A Framework for Network Embedding Evaluation},
author = {Alexandru Mara and Jefrey Lijffijt and Tijl {De Bie}},
journal = {SoftwareX},
volume = {17},
pages = {},
year = {2022},
issn = {100997},
doi = {10.1016/j.softx.2022.100997},
url = {https://www.sciencedirect.com/science/article/pii/S2352711022000139}
}