notebooks/Federated Random Forest with FLEX.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Federated Random Forest using FLEX library. \n",
    "\n",
    "\n",
    "In this notebook we show how to use the *Federated Random Forest* model, from the [paper](https://academic.oup.com/bioinformatics/article/38/8/2278/6525214).\n",
    "\n",
    "First we do all the imports needed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from flex.data import FedDataDistribution, FedDatasetConfig\n",
    "from flex.pool import FlexPool\n",
    "\n",
    "from flextrees.datasets.tabular_datasets import ildp\n",
    "\n",
    "from flextrees.pool import (\n",
    "    init_server_model_rf,\n",
    "    deploy_server_config_rf,\n",
    "    deploy_server_model_rf,\n",
    "    aggregate_trees_from_rf,\n",
    "    evaluate_global_rf_model,\n",
    "    evaluate_global_rf_model_at_clients,\n",
    "    evaluate_local_rf_model_at_clients,\n",
    "    train_rf,\n",
    "    collect_clients_trees_rf,\n",
    "    set_aggregated_trees_rf,\n",
    ")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loading the data using FLEX.\n",
    "\n",
    "In this tutorial we are going to use the **ildp** database. We can use it by importing the dataset using the flextrees library."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_data, test_data = ildp(ret_feature_names=False, categorical=False)\n",
    "n_clients = 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Federating the data using FLEX\n",
    "\n",
    "Once the data is loaded, we have to federate it. To do so we use the FLEX library. We show to ways of federating the data, using a iid distribution or a non-idd distribution. For the IID distribution we can just use the the `ìid_distribution` function from FedDataDistribution. If we are using a non-iid distribution, we have to use a custom configuration and, in this case, we just set the seed, the number of clients, and we can set manually the weights by creating them randomly or whatever the user wants. For more information, go to the FLEX library notebooks, and take a look at the notebook *Federating data with FLEXible*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dist = 'iid'\n",
    "\n",
    "if dist == 'iid':\n",
    "    federated_data = FedDataDistribution.iid_distribution(centralized_data=train_data,\n",
    "                                                        n_nodes=n_clients)\n",
    "else:\n",
    "    weights = np.random.dirichlet(np.repeat(1, n_clients), 1)[0] # To generate random weights (Full Non-IID)\n",
    "    config_nidd = FedDatasetConfig(seed=0, n_nodes=n_clients, \n",
    "                                replacement=False, weights=weights)\n",
    "\n",
    "    federated_data = FedDataDistribution.from_config(centralized_data=train_data,\n",
    "                                                        config=config_nidd)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating the federated architecture\n",
    "\n",
    "When creating the federated architecture, we use `FlexPool`. As we're running a client-server architecture, we use the function `client_server_architecture`. We need to give to this function the dimension of the dataset for creating the LSH functions in order of creating the planes to hash all the data from the clients."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set server config\n",
    "pool = FlexPool.client_server_pool(federated_data, init_server_model_rf)\n",
    "\n",
    "clients = pool.clients\n",
    "aggregator = pool.aggregators\n",
    "server = pool.servers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We set the number of estimators to be built within the federated model, and the number of estimators that each client must build."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Total number of estimators\n",
    "total_estimators = 100\n",
    "# Number of estimators per client\n",
    "nr_estimators = total_estimators // n_clients"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lastly, we set the configuration for all the clients for training the model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Deploy clients config\n",
    "server.map(func=deploy_server_config_rf, dst_pool=pool.clients)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training the model\n",
    "\n",
    "Now we use the primitives to build the different estimators. In this case, each client will train `nr_estimators`, then they will be collected into the server and aggregated. The server will send the aggregated forest of trees to the clients."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "clients.map(func=train_rf)\n",
    "clients.map(func=evaluate_local_rf_model_at_clients)\n",
    "aggregator.map(func=collect_clients_trees_rf, dst_pool=pool.clients, nr_estimators=nr_estimators)\n",
    "aggregator.map(func=aggregate_trees_from_rf)\n",
    "aggregator.map(func=set_aggregated_trees_rf, dst_pool=pool.servers)\n",
    "server.map(func=deploy_server_model_rf, dst_pool=pool.clients)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Evaluating the models\n",
    "\n",
    "We use the primitives for evaluating the model within a global test at the server's side, and at client's side, so we test if the federated model is really improving or not the local model built by each client."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "server.map(func=evaluate_global_rf_model, test_data=test_data)\n",
    "clients.map(func=evaluate_global_rf_model_at_clients)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# End of notebook"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "flextrees",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.3"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}