diff --git a/README.md b/README.md
old mode 100644
new mode 100755
index 6b48508b0fc3abe68c7875548344f6bafa79fe7e..499cc73047f58096bc46ba407cec3cad3f54ad17
--- a/README.md
+++ b/README.md
@@ -9,20 +9,23 @@ Finding a real estate in a new city is still a challenge. We often arrive in a c
 ## Installation instructions
 
 ### Requirements
+
 - Python, version >=3
 - [MongoDB](https://www.mongodb.com/), version >=4 for importing the database about neighbourhoods.
 
 ### Installation
 
-For installing Predihood, type in a terminal:
+For installing Predihood, clone or download this git repository.
+
+Go in the downloaded `predihood/` directory (which contains `setup.py`) and run in a terminal:
 
 ```
-python3 -m pip install -e predihood/ --process-dependency-links
+python3 -m pip install -e . -r requirements.txt
 ```
 
-This command install dependencies, including [mongiris](https://gitlab.liris.cnrs.fr/fduchate/mongiris) which provide the querying of the MongoDB database containing information about neighbourhoods.
+This command install dependencies, including [mongiris](https://gitlab.liris.cnrs.fr/fduchate/mongiris), a lightweight API which enables the querying of the MongoDB database containing information about French neighbourhoods. Note that the download time may be quite long, as the mongiris API includes a dump of French neighbourhoods (700 MB).
 
-Create this database is mandatory. To achieve this, execute this command (from the MongoDB's executables directory if needed):
+Next, to install the database, run the MongoDB server and execute this command (from the MongoDB's executables directory if needed):
 
 ```
 ./mongorestore --archive=/path/to/dump-iris.bin
@@ -32,13 +35,13 @@ where `/path/to/` is the path to the dump file of the IRIS collection (provided
 
 ### Run Predihood
 
-For running *Predihood*, type in a terminal:
+For running *Predihood*, go in the `predihood/predihood/` directory (which contains `main.py`) and run in a terminal:
 
 ```
 python3 main.py
 ```
 
-After some information, the terminal displays the URL for testing *Predihood* : `http://localhost:8080/`.
+After some logging information, the terminal displays the URL for testing *Predihood* : `http://localhost:8081/`.
 
 ## Example usage
 
diff --git a/paper.bib b/paper.bib
index 76d214a4967e5e59bbcbed3469f39533283920d2..e56fb6e615cb09643ffec9f96fcefee95048cd0b 100644
--- a/paper.bib
+++ b/paper.bib
@@ -3,7 +3,8 @@
   author={Cranshaw, Justin and Schwartz, Raz and Hong, Jason I and Sadeh, Norman},
   booktitle={International AAAI Conference on Weblogs and Social Media},
   pages={58},
-  year={2012}
+  year={2012},
+  url = {https://ssrn.com/abstract=2168428}
 }
 
 @inproceedings{zhang2013hoodsquare,
@@ -12,11 +13,17 @@
   booktitle={2013 International Conference on Social Computing},
   pages={69--74},
   year={2013},
-  organization={IEEE}
+  organization={IEEE},
+  doi={10.1109/socialcom.2013.17}
 }
 
-@article{barretpredicting,
-  title={Predicting the enviornment of a neighbourhood: a use case for France},
-  author={Barret, Nelly and Duchateau, Fabien and Favetta, Franck and Bonneval, Loic},
-  year={2020}
+@INPROCEEDINGS{data2020,
+  title = {Predicting the Environment of a Neighborhood: a Use Case for France},
+  publisher = {SciTePress},
+  year = {2020},
+  isbn = {978-989-758-440-4},
+  author = {Nelly Barret and Fabien Duchateau and Franck Favetta and Loïc Bonneval},
+  booktitle = {International Conference on Data Management Technologies and Applications (DATA)},
+  pages = {294-301},
+  doi={10.5220/0009885702940301}
 }
\ No newline at end of file
diff --git a/paper.md b/paper.md
index 4bbe2e7d86fad265f271344ca94b8d4b5bea822c..55e6cc98841663912b511d47fd4d35f3720dddba 100644
--- a/paper.md
+++ b/paper.md
@@ -20,57 +20,60 @@ authors:
 affiliations:
  - name: LIRIS UMR5205, Université Claude Bernard Lyon 1, Lyon, France
    index: 1
-date: 16 July 2020
+date: 16 September 2020
 bibliography: paper.bib
 ---
 
 
 # Introduction
 
-Finding a real estate in a new city is still a challenge. We often arrive in a city we don't know, thus finding the perfect living place becomes complex. Nearby public transport on one hand, a rural landscape on the other hand, an animated neighbourhood for some, far from urban hustle and bustle for others: there are many criteria for choosing your future neighbourhood. 
+Finding a real estate in a new city is a real challenge. We often arrive in a city we do not know, and finding the perfect living area becomes complex. Nearby public transportation on one hand, rural landscape on the other hand, an animated neighbourhood for some, far from urban hustle and bustle for others: there are many criteria for choosing a future neighbourhood. Our tool Predihood enables to define neighbourhoods with a set of indicators and predict their environment using supervised learning.
 
 # Statement of need
 
-Some projects focuses on qualifying neighbourhoods, such as Livehoods [@cranshaw2012livehoods], Hoodsquare [@zhang2013hoodsquare] and [DataFrance](https://datafrance.info/). The Livehoods project aims at defining and computing dynamics of neighbourhoods based on data gathered from social networks. The Hoodsquare project detects similar areas based on Foursquare check-ins. DataFrance is an interface that integrates data from several sources, such as indicators provided by the National Institute of Statistics ([INSEE](https://insee.fr/en/accueil)), geographical information from the National Geographic Institute ([IGN](http://www.ign.fr/institut/activites/geoservices-ign)) and surveys from newspapers for prices (L'Express).
-
+Several projects focus on qualifying neighbourhoods using social networks. For instance, the Livehoods project defines and computes dynamics of neighbourhoods [@cranshaw2012livehoods] while the Hoodsquare project detects similar areas based on Foursquare check-ins [@zhang2013hoodsquare]. Crowd-based systems are interesting but may be biased. [DataFrance](https://datafrance.info/) is an interface that integrates data from several sources, such as indicators provided by the National Institute of Statistics ([INSEE](https://insee.fr/en/)), geographical information from the National Geographic Institute ([IGN](http://www.ign.fr/institut/activites/geoservices-ign)) and surveys from newspapers for prices (L'Express). DataFrance enables the visualization of hundreds of indicators, but makes it difficult to judge on the environment of a neighbourhood. There is no simple description of neighbourhood's environment.
 
 # Methodology
 
-Our approach Predihood aims at facilitating the comparison between neighbourhoods. It defines and predicts the environment of any neighbourhood in France using supervised learning.
+In order to describe in the most accurate way the environment of a neighbourhood, social science researchers have defined six environment variables, each with a limited number of values [@data2020]. These six variables are the _building type_, the _building usage_, the _landscape_, the _social class_, the _morphological position_ and the _geographical position_. As an example, the _landscape_ can be evaluated as _urban_, _green areas_, _forest_ or _countryside_ while the _social class_ have values from _lower_ to _upper_. These variables are commonly accepted and easily understandable.
 
-## Describing neighbourhoods
+Predihood provides the following functionnalities:
+- adding new neighbourhoods and indicators to describe them;
+- predict the environment of a neighbourhood by configuring and using predefined algorithms;
+- adding new predictive algorithms.
 
-In order to describe in the most accurate way the environment of a neighbourhood, social science researchers have defined six environment variables with a limited number of values for each one. These six variables are the _building type_, the _building usage_, the _landscape_, the _social class_, the _morphological position_ and the _geographical position_. As an example, the _landscape_ can be evaluated as _urban_, _green areas_, _forest_ or _countryside_ while the _social class_ have values from _lower_ to _upper_. These variables are commonly accepted and easily understandable.
+## Adding new data
 
-## Predicting neighbourhoods
+Neighbourhoods are represented as [GeoJSON objects](https://geojson.org/) and include:
 
-There are mainly four steps: producing supervised neighbourhoods, collecting data about neighbourhoods, compute datasets and finally running algorithms to predict environment.
+- a geometry (multi-polygons), which describes the shape of the neighbourhood;
+- properties, with descriptive information (e.g., name, city postcode) and indicators which quantify the environment (e.g., number of restaurants, of bakeries, average income, unemployment rate, number of houses with a superficy above 250 $m^2$). These hundreds of indicators are used for predicting the values of environment variables.
 
-The first step of producing supervised neighbourhoods is a manual task that has been done by social science researchers. This task consists of giving a value for each environment variable. This has been done by investigating Google Street View (building and streets pictures, parked cars, facilities and greens areas) and requires between one to two hours for a single neighbourhood. A total of 300 neighbourhoods have been annotated.
+To add new neighbourhoods, it is necessary to store them as GeoJSON and make them accessible by Predihood. Besides, some neighbourhoods have to be manually annotated (i.e., giving a value for each of the six environment variables).
 
-The second step is about collecting data that represents neighbourhoods. There are mainly two types of data:
+The current version of Predihood is bundled with data from France using the [mongiris](https://gitlab.liris.cnrs.fr/fduchate/mongiris) project (in which unit divisions named [IRIS](https://www.insee.fr/en/metadonnees/definition/c1523/) stand for neighbourhoods).
+It includes about 50,000 neighbourhoods with 640 indicators, and 270 neighbouhoods were annotated by social science researchers (one to two hours per neighbourhood to investigate building and streets pictures, parked cars, facilities and green areas from services such as Google Street View).
 
-- The geometry, stored as a GeoJSON object, which describe the shape of the neighbourhood.
-- The indicators which quantify the environment. Each neighbourhood can be described by thousands of indicators, such as the number of restaurants, the average income or even the number of houses over 250 $m^2$. Even if it is not possible to manually exploit these indicators, they are useful in an automatic approach.
+## Predicting environment
 
-Predihood integrates such data for France by using [mongiris](https://gitlab.liris.cnrs.fr/fduchate/mongiris), an interface for querying French administrative areas. Predihood is instantiated only for French data, but this can be easily extended to other countries.
+Machine learning algorithms need a dataset, as illustrated by Figure 1. In Predihood, a dataset is composed of the identifier of the neighbourhood (grey column), its indicators (yellow columns, showing only a subset) that have been normalized by density of population (green column) and optionnaly the assessment of social science researchers for the six environment variables (blue columns). The objective of Predihood is to fill automatically question marks for neighbourhoods that are not yet assessed.
 
-The third step aims at computing datasets that will aggregate aforementioned data. A dataset looks like Figure 1 and is composed of the code INSEE of the neighbourhood (grey column), its indicators (yellow columns) that have been normalized by density of population (green column) and the assessment of social science researchers for the six environment variables (blue columns). As a reminder, our approach Predihood aims at automatically filling question marks for neighbourhoods that are not yet assessed.
+![A subset of the computed dataset.](predihood-indicators.png)
 
-![An example of the computed dataset.](predihood-indicators.png)
+To perform prediction, a selection process first selects subsets of relevant indicators. These subsets, called _lists_, contain from 10 to 100 indicators. Predihood provides a cartographic web interface based on [Leaflet](https://leafletjs.com/) and [Open Street Map](https://www.openstreetmap.org/), as shown in Figure 2. It enables to search for a neighbourhood and predict its environment by selecting an algorithm. The current version of Predihood currently includes 8 predictive algorithms from [scikit-learn](https://scikit-learn.org/) (e.g., Random Forest).
 
-The last step predicts the environment of any neighbourhood in France. Because neighbourhoods are represented by hundreds of indicators, a selection process selects subsets of relevant indicators. These subsets are called _lists_ and contain from 10 to 100 indicators. They are used in the Predihood interface to predict environment.
+![Screenshot of the cartographic interface of Predihood](predihood-predictions.png)
 
-## Algorithmic interface
+## Adding new algorithms
 
-Because the prediction of these variables is a complex task, we have to test several algorithms to compare results. In order to facilitate the tuning and the using of the algorithms, Predihood proposes a generic and easy-to-use interface for algorithms. This interface is based on [Scikit-learn](https://scikit-learn.org/stable/) algorithms but can handle hand-made ones. To implement your own algorithm and test it on our dataset, follow these steps:
+Because the prediction of these environment variables is a complex task, testing different algorithms and comparing their results may help increase the overall quality. In order to facilitate this task, Predihood proposes a generic and easy-to-use programming structure for machine learning algorithms, based on [Scikit-learn](https://scikit-learn.org/stable/) algorithms. Thus, experts can implement hand-made algorithms and run experiments in Predihood. Adding a new algorithm only requires 4 steps:
 
 1. Create a new class that represents your algorithm, e.g. `MyOwnClassifier`, and inherits from `Classifier`.
-2. Implement the core of your algorithm by coding `fit()` and `predict()` functions. The `fit` function aims at fitting your classifier on assessed neighbourhoods while the `predict` function aims at predicting environment variables for a given neighbourhood.
+2. Implement the core of your algorithm by coding the `fit()` and `predict()` functions. The `fit` function aims at fitting your classifier on assessed neighbourhoods while the `predict` function aims at predicting environment variables for a given neighbourhood.
 3. Add `get_params()` to be compatible with Scikit-learn framework.
-5. Comment your classifier with the Numpy style in order to be able to tune it in the interface.
+4. Comment your classifier with the Numpy style in order to be able to tune it in the interface.
 
-Below is a very simple example to illustrate the aforementioned steps.
+Below is a very simple example to illustrate the aforementioned steps. Note that your algorithm is automatically loaded in Predihood.
 
 ```python
 # file ./algorithms/MyOwnClassifier.py
@@ -94,7 +97,7 @@ class MyOwnClassifier(Classifier):
   def fit(self, X, y):
     # do stuff here
 
-  def predict(self, X):
+  def predict(self, df):
     # do stuff here
 
   def get_params(self, deep=True):
@@ -102,22 +105,13 @@ class MyOwnClassifier(Classifier):
     return {"a": self.a, "b": self.b}
 ```
 
-After that, your algorithm is ready to be used in Predihood.
-
-Figure 2 shows the generic interface of Predihood for tuning algorithms. The left panel allows to tune parameters and hyper parameters, such as training and test sizes. On the right, the table illustrates the accuracies obtained for each list (generated during the selection process) and each environment variable. You can export these results by clicking on the download icon.
+In addition, Predihood provides an interface for easily tuning and testing algorithms on a dataset, as shown in Figure 3. The left panel allows to select an algorithm and tune its parameters and hyper parameters, such as training and test sizes. On the right, the table illustrates the accuracies obtained for each list of indicators (generated during the selection process) and each environment variable. Results can be exported in CSV.
 
 ![Screenshot of algorithmic interface of Predihood](predihood-accuracies.png)
 
-## Cartographic interface
-
-Figure 3 exposes the cartographic interface of Predihood, used mostly by people who search for a new living place. By searching an area in the inputs on the left and then clicking on neighbourhoods, you will be able to choose an algorithm to predict environment variables of the chosen neighbourhood. For beginners, `Random Forest` classifier is recommended. For example, Alice is an IT commercial and has been recruited for a mission in Lyon for 6 months before going back to Paris. She compares easily many neighbourdhoods in the CBD (Central Business District) of Lyon and chooses the "Part-Dieu" neighbourhood.
-
-![Screenshot of the cartographic interface of Predihood](predihood-predictions.png)
-
 # Mentions of Predihood
 
-Our approach Predihood has been presented during the DATA conference [@barretpredicting].
-Results vary from 30% to 65% depending on the environment variable, but proposing new algorithms can help to improve these results.
+Our Predihood tool has been presented during the DATA conference [@data2020]. Prediction results using 6 algorithms from Scikit-learn range from 30% to 65% depending on the environment variable, and designing new algorithms could help improving these results.
 
 The project is available here: [https://gitlab.liris.cnrs.fr/fduchate/predihood](https://gitlab.liris.cnrs.fr/fduchate/predihood).
 
diff --git a/predihood-accuracies.png b/predihood-accuracies.png
index f927c82a25287930ca23bdf0c14ca4276cb93c84..b20d698aa34235cc9f8f3f7734298ebdb4415b26 100644
Binary files a/predihood-accuracies.png and b/predihood-accuracies.png differ
diff --git a/predihood/algorithms/MyOwnClassifier.py b/predihood/algorithms/MyOwnClassifier.py
index fcb5dc982e382cc096645986389cd454f3277a6e..c8098ac8caf084b34ae4bf3fc694da1b076119b3 100644
--- a/predihood/algorithms/MyOwnClassifier.py
+++ b/predihood/algorithms/MyOwnClassifier.py
@@ -18,7 +18,7 @@ class MyOwnClassifier(Classifier):
     def fit(self, X, y):
         return self
 
-    def predict(self, X):
+    def predict(self, df):
         return self
 
     def get_params(self, deep=True):
diff --git a/predihood/main.py b/predihood/main.py
old mode 100644
new mode 100755
diff --git a/requirements.txt b/requirements.txt
old mode 100644
new mode 100755
index fa14102c4876d470bfabf1f8af2d966fbaa3485b..5741dc2726a8ca42aff4b1f82f0155cbfb494171
--- a/requirements.txt
+++ b/requirements.txt
@@ -2,12 +2,11 @@ setuptools~=41.2.0
 numpy~=1.18.3
 pandas~=1.0.3
 area~=1.1.1
-predihood~=0.13
-sklearn~=0.0
-scikit-learn~=0.22.2.post1
+scikit-learn~=0.22
 matplotlib~=3.2.1
 seaborn~=0.10.1
 Flask~=1.1.2
-mongiris~=0.40
 requests~=2.23.0
-StringDist~=1.0.9
\ No newline at end of file
+StringDist~=1.0.9
+https://gitlab.liris.cnrs.fr/fduchate/mongiris/-/archive/master/mongiris-master.zip
+
diff --git a/setup.cfg b/setup.cfg
old mode 100644
new mode 100755
index 1c3bdc4cd16201f869f042f9a12644a0d83b9abc..89e4a86af3e5c5c6e40c446466642b5a9a5397f6
--- a/setup.cfg
+++ b/setup.cfg
@@ -1,28 +1,18 @@
 [metadata]
 name = predihood
-version = 0.13
-description = This package aims at searching and printing IRIS on a map.
+version = 1.0
+description = This package aims at predicting and displaying neighbourhoods environment
 author = Fabien Duchateau
 author_email = fabien.duchateau@univ-lyon1.fr
-url = https://gitlab.liris.cnrs.fr/fduchate/predihood.git
-download_url = https://gitlab.liris.cnrs.fr/fduchate/predihood.git
-keywords = visualization search INSEE IRIS
+url = https://gitlab.liris.cnrs.fr/fduchate/predihood
+download_url = https://gitlab.liris.cnrs.fr/fduchate/predihood
+keywords = "machine learning" visualization "social science" neighbourhood environment
 license_file = LICENSE
 
 [options]
 packages = find:
 include_package_data = True
 zip_safe = False
-install_requires =
-    flask >= 1.0.2
-	mongiris >= 0.3
-dependency_links =
-	git+https://fduchate@gitlab.liris.cnrs.fr/fduchate/mongiris.git#egg=mongiris-0.3
-
-#[options.packages.find]
-#exclude =
-#    tests.*, 
-#	 data/HiL/*
 
 [options.package_data]
 # package_data is ignored when a MANIFEST.in is provided
diff --git a/setup.py b/setup.py
index d3d2f8a6066f83627122f8f839f012e8b01db05a..90fb308659a363a0c39aa15b518d1aa79e4a0ace 100755
--- a/setup.py
+++ b/setup.py
@@ -3,8 +3,10 @@ from setuptools import setup
 import shutil
 
 # python3 -m setup bdist_wheel sdist
-# python3 -m pip install -e ../predihood/
-# installation: python -m pip install -e ../predihood/ --process-dependency-links
+# python3 -m pip install -e . -r requirements.txt
+
+print("Starting to install predihood and its dependcies.")
+print("Note that this installation may take time due to the size of the mongiris dependency (700 MB).")
 
 def delete_dir(directories):  # delete directories (ignore errors such as read-only files)
     for directory in directories:
@@ -16,5 +18,5 @@ delete_dir(["./predihood.egg-info/", "./build/", "./dist/"])
 
 readme = open("README.md").read()
 
-setup(long_description=readme, install_requires=["scikit-learn", "eli5", "matplotlib", "numpy", "pandas", "requests"])
+setup(long_description=readme, install_requires=["scikit-learn", "eli5", "matplotlib", "numpy", "pandas", "requests", "flask"])