{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "Model training with training data generated on the fly\n",
    "=======================================================\n",
    "\n",
    "Depending on the concrete usecase, data generation speed with AcouPipe can be fast enough to directly incorporate the generated data for model training without the need of intermediate file saving.\n",
    "\n",
    "This example demonstrates how to **generate training data on the fly** for the most simple **supervised source localization** tasks.\n",
    "\n",
    "Here, the example demonstrates **single source localization** model training similar to [KHS19], but without predicting the source strength. \n",
    "For demonstration, the **Beamforming map** is created with calculation `mode=\"wishart\"` (no time data is simulated).\n",
    "\n",
    "To prevent thread overloading due to parallel data generation, the number of parallel numba threads was limited by exporting the variable `export NUMBA_NUM_THREADS=1` before running the script.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-11-14 14:28:06,089\tINFO worker.py:1673 -- Started a local Ray instance.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Num GPUs: 1\n",
      "Num CPUs: 48\n",
      "Numba number of concurrent threads: 1\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3' \n",
    "import multiprocessing\n",
    "import numba\n",
    "import tensorflow as tf\n",
    "import ray\n",
    "ray.shutdown() # shutdown existing tasks\n",
    "ray.init(log_to_driver=False) # start a ray server (without logging the details for clean documentation)\n",
    "physical_devices = tf.config.list_physical_devices('GPU')\n",
    "\n",
    "print(\"Num GPUs:\", len(physical_devices))\n",
    "print(\"Num CPUs:\", multiprocessing.cpu_count())\n",
    "print(\"Numba number of concurrent threads:\", numba.config.NUMBA_NUM_THREADS)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Build the dataset generator\n",
    "\n",
    "At first, we manipulate the dataset config to only create single source examples on a coarser grid of size $32 \\times 32$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.8/dist-packages/acoupipe/datasets/features.py:104: Warning: Queried frequency (1000 Hz) not in set of discrete FFT sample frequencies. Using frequency 1071.88 Hz instead.\n",
      "  fidx = [get_frequency_index_range(\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "from acoupipe.datasets.synthetic import DatasetSynthetic\n",
    "\n",
    "# create dataset (calculated on a GPU Workstation with several cpus)\n",
    "dataset = DatasetSynthetic(max_nsources=1, tasks=multiprocessing.cpu_count(), mode='wishart')       \n",
    "\n",
    "# we manipulate the grid to have a coarser resolution \n",
    "dataset.config.grid.increment = 1/31 # 32 x 32 grid\n",
    "\n",
    "# build TensorFlow datasets for training and validation\n",
    "training_dataset = dataset.get_tf_dataset(\n",
    "    features=[\"sourcemap\",\"loc\"], f=1000, split=\"training\",size=100000000) # quasi infinite\n",
    "validation_dataset = dataset.get_tf_dataset(\n",
    "    features=[\"sourcemap\",\"loc\"], f=1000, split=\"validation\",size=100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The TensorFlow dataset API can be used to build a data pipeline from the data generator. Here, batches with 16 source cases are used. We use the `prefetch` method to generate data when during training steps on the GPU, where the CPUs are usually idle. For the validation_dataset, the `cache` method prevents recalculation of the validation data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf \n",
    "\n",
    "def yield_features_and_labels(data):   \n",
    "    feature = data['sourcemap'][0]\n",
    "    f_max = tf.reduce_max(feature)\n",
    "    feature /= f_max\n",
    "    label = data['loc'][:2]\n",
    "    return (feature,label)\n",
    "\n",
    "training_dataset = training_dataset.map(yield_features_and_labels).batch(16).prefetch(tf.data.AUTOTUNE)\n",
    "validation_dataset = validation_dataset.map(yield_features_and_labels).batch(16).cache()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train the model\n",
    "\n",
    "Now, one can build the ResNet50V2 model and use the data to fit the model. This may take up to a few hours, depending on the computational infrastructure. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/5\n",
      "10000/10000 - 493s - loss: 0.0167 - val_loss: 0.7074 - 493s/epoch - 49ms/step\n",
      "Epoch 2/5\n",
      "10000/10000 - 443s - loss: 0.0062 - val_loss: 0.0046 - 443s/epoch - 44ms/step\n",
      "Epoch 3/5\n",
      "10000/10000 - 443s - loss: 0.0042 - val_loss: 0.0403 - 443s/epoch - 44ms/step\n",
      "Epoch 4/5\n",
      "10000/10000 - 433s - loss: 0.0019 - val_loss: 0.0104 - 433s/epoch - 43ms/step\n",
      "Epoch 5/5\n",
      "10000/10000 - 432s - loss: 0.0011 - val_loss: 0.0133 - 432s/epoch - 43ms/step\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<keras.src.callbacks.History at 0x7f58804836a0>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# build model architecture\n",
    "model = tf.keras.Sequential(\n",
    "    tf.keras.applications.resnet_v2.ResNet50V2(\n",
    "    include_top=False,\n",
    "    weights=None,\n",
    "    input_shape=(32,32,1),\n",
    "    ))\n",
    "model.add(tf.keras.layers.Flatten())\n",
    "model.add(tf.keras.layers.Dense(2, activation=None))\n",
    "\n",
    "# compile and fit\n",
    "model.compile(optimizer=tf.optimizers.Adam(),loss='mse')\n",
    "model.fit(training_dataset,validation_data=validation_dataset, epochs=5,steps_per_epoch=10000, verbose=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After successfully training, the model can be used for source localization."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1/1 [==============================] - 0s 40ms/step\n",
      "[ 0.23072581 -0.0644986 ]\n"
     ]
    }
   ],
   "source": [
    "dataset.tasks=1\n",
    "test_dataset = dataset.get_tf_dataset(\n",
    "    features=[\"sourcemap\",\"loc\"], f=1000, split=\"validation\",size=1, start_idx=2) \n",
    "test_dataset = test_dataset.map(yield_features_and_labels).batch(1)\n",
    "sourcemap, labels = next(iter(test_dataset))\n",
    "\n",
    "prediction = model.predict(sourcemap)[0]\n",
    "print(prediction)\n",
    "\n",
    "sourcemap = sourcemap.numpy().squeeze()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "from acoular import L_p\n",
    "\n",
    "extent = dataset.config.grid.extend() \n",
    "loc = labels[0]\n",
    "\n",
    "plt.figure()\n",
    "plt.imshow(L_p(sourcemap).T,\n",
    "            vmax=L_p(sourcemap.max()),\n",
    "            vmin=L_p(sourcemap.max())-15,\n",
    "            extent=extent,\n",
    "            origin=\"lower\")\n",
    "plt.plot(prediction[0],prediction[1],'x',label=\"prediction\")\n",
    "plt.plot(loc[0],loc[1],'x',label=\"label\")\n",
    "plt.colorbar()\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "vscode": {
   "interpreter": {
    "hash": "8b84133aa5d27198834684dc5cf37286f31547fcb562f18c04d9e25d99e7281e"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}