diff --git a/.gitignore b/.gitignore
index ab001f7915484904466b352cfbe9a15ab7d58ab5..b1de0772616ee12e984a859acbdb08ae6cd97f3d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,5 @@
 AED/
 image_resized/
 *.jpg
-*.npy
\ No newline at end of file
+*.npy
+images/
\ No newline at end of file
diff --git a/MLBD.pdf b/MLBD.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..01aa4f9e744f154143544d16f2445624d75d3d60
Binary files /dev/null and b/MLBD.pdf differ
diff --git a/binary_cross_full_unet.png b/binary_cross_full_unet.png
deleted file mode 100644
index a1a625768add1d613f2a60c472363e8f5b0d997d..0000000000000000000000000000000000000000
Binary files a/binary_cross_full_unet.png and /dev/null differ
diff --git a/binary_cross_full_unet2.png b/binary_cross_full_unet2.png
deleted file mode 100644
index efed4c88da7b15a37b8e520f74d77d9ce2c63f4b..0000000000000000000000000000000000000000
Binary files a/binary_cross_full_unet2.png and /dev/null differ
diff --git a/elephant.ipynb b/elephant.ipynb
deleted file mode 100644
index d5c04672239b70d5cc9c908489155bbc0309456f..0000000000000000000000000000000000000000
--- a/elephant.ipynb
+++ /dev/null
@@ -1,417 +0,0 @@
-{
-  "cells": [
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "# Counting Elephants from Aerial Photography"
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Load datasets - train and test"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": 1,
-      "metadata": {},
-      "outputs": [
-        {
-          "name": "stderr",
-          "output_type": "stream",
-          "text": [
-            "2023-01-14 13:30:10.704717: I tensorflow/core/platform/cpu_feature_guard.cc:193] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  AVX2 AVX512F AVX512_VNNI FMA\n",
-            "To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
-            "2023-01-14 13:30:11.049283: I tensorflow/core/util/port.cc:104] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n",
-            "2023-01-14 13:30:11.115777: W tensorflow/compiler/xla/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcudart.so.11.0'; dlerror: libcudart.so.11.0: cannot open shared object file: No such file or directory\n",
-            "2023-01-14 13:30:11.115796: I tensorflow/compiler/xla/stream_executor/cuda/cudart_stub.cc:29] Ignore above cudart dlerror if you do not have a GPU set up on your machine.\n",
-            "2023-01-14 13:30:12.140982: W tensorflow/compiler/xla/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libnvinfer.so.7'; dlerror: libnvinfer.so.7: cannot open shared object file: No such file or directory\n",
-            "2023-01-14 13:30:12.141028: W tensorflow/compiler/xla/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libnvinfer_plugin.so.7'; dlerror: libnvinfer_plugin.so.7: cannot open shared object file: No such file or directory\n",
-            "2023-01-14 13:30:12.141032: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Cannot dlopen some TensorRT libraries. If you would like to use Nvidia GPU with TensorRT, please make sure the missing libraries mentioned above are installed properly.\n",
-            "/tmp/ipykernel_6726/1584571933.py:11: DeprecationWarning: Please use `gaussian_filter` from the `scipy.ndimage` namespace, the `scipy.ndimage.filters` namespace is deprecated.\n",
-            "  from scipy.ndimage.filters import gaussian_filter\n"
-          ]
-        },
-        {
-          "name": "stdout",
-          "output_type": "stream",
-          "text": [
-            "env: SM_FRAMEWORK=tf.keras\n",
-            "Segmentation Models: using `tf.keras` framework.\n"
-          ]
-        }
-      ],
-      "source": [
-        "# Imports\n",
-        "import numpy as np\n",
-        "import matplotlib.pyplot as plt\n",
-        "#imports for the neural network\n",
-        "import tensorflow as tf\n",
-        "from tensorflow import keras\n",
-        "import pandas as pd\n",
-        "import os\n",
-        "import cv2\n",
-        "import shutil\n",
-        "from scipy.ndimage.filters import gaussian_filter\n",
-        "%env SM_FRAMEWORK=tf.keras\n",
-        "from segmentation_models import Unet\n"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": 2,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# load dataset in AED/training_images\n",
-        "train_path = 'AED/training_images'\n",
-        "test_path = 'AED/test_images'\n",
-        "\n",
-        "train_image_list = os.listdir(train_path)\n",
-        "test_image_list = os.listdir(test_path)\n",
-        "\n",
-        "train_image_list = train_image_list[:10]\n",
-        "test_image_list = test_image_list[:10]\n",
-        "\n",
-        "train = []\n",
-        "test = []\n",
-        "train_masks = []\n",
-        "test_masks = []\n",
-        "\n",
-        "# get the point for each image where elephant are located put in a mask\n",
-        "df_train_csv = pd.read_csv('AED/training_elephants.csv')\n",
-        "df_test_csv = pd.read_csv('AED/test_elephants.csv')"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": 3,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "def getCoordinatesFromImage(imageId):\n",
-        "    imageId = imageId.split('.')[0]\n",
-        "    new_df = df_train_csv[df_train_csv['image_id'] == imageId]\n",
-        "    return new_df"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": 4,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "def prepare_data(image_list, path):\n",
-        "    data = []\n",
-        "    image_counter = 0\n",
-        "    \n",
-        "    for image in image_list:\n",
-        "        firstTimeForImage = True\n",
-        "\n",
-        "        image_elephant = cv2.imread(os.path.join(path, image))\n",
-        "\n",
-        "        mask_image = np.zeros((image_elephant.shape[0], image_elephant.shape[1]), dtype=np.float32)\n",
-        "        \n",
-        "        coordDF = getCoordinatesFromImage(image)\n",
-        "        for index, row in coordDF.iterrows():\n",
-        "            mask_image[row['y'], row['x']] = 1\n",
-        "    \n",
-        "        # add a gaussian filter to the mask\n",
-        "        mask_image = cv2.GaussianBlur(mask_image, (7, 7), 0)\n",
-        "        # mask_image[:, :]= gaussian_filter(mask_image[:, :], sigma=10)\n",
-        "\n",
-        "        # reduce the size of the image and the mask to make them divisible by 256\n",
-        "        width = height = 256\n",
-        "        factor_x = image_elephant.shape[0] / 256\n",
-        "        factor_y = image_elephant.shape[1] / 256\n",
-        "        fact_new_x = int(height - (height * (factor_x % 1))) if factor_x != 0 else 0\n",
-        "        fact_new_y = int(width - (width * (factor_y % 1))) if factor_y != 0 else 0\n",
-        "        image_elephant_resize = cv2.copyMakeBorder(image_elephant, 0, fact_new_x, 0, fact_new_y, cv2.BORDER_CONSTANT)\n",
-        "        mask_resize = cv2.copyMakeBorder(mask_image, 0, fact_new_x, 0, fact_new_y, cv2.BORDER_CONSTANT)\n",
-        "        \n",
-        "        # create multiple image and mask from the original image and mask\n",
-        "        cpt = 0\n",
-        "        next_background = False\n",
-        "        for i in range(0, int(image_elephant_resize.shape[0] / 256)):\n",
-        "            for j in range(0, int(image_elephant_resize.shape[1] / 256)):\n",
-        "                if width * i > 0:\n",
-        "                    xstart = width * i\n",
-        "                else:\n",
-        "                    xstart = 0\n",
-        "\n",
-        "                if width * j > 0:\n",
-        "                    ystart = width * j\n",
-        "                else:\n",
-        "                    ystart = 0\n",
-        "\n",
-        "                xstop = width + width * i\n",
-        "                ystop = height + height * j\n",
-        "\n",
-        "                image_crop = image_elephant_resize[xstart:xstop, ystart:ystop, :]\n",
-        "                mask_crop = mask_resize[xstart:xstop, ystart:ystop]\n",
-        "\n",
-        "                # count the number of white pixel in the mask => keep only the image with elephant\n",
-        "                nb_white_pixel = np.count_nonzero(mask_crop)\n",
-        "                if nb_white_pixel > 0:\n",
-        "                    np.save('./image_resized/image/' + str(image) + \"_\" + str(cpt), image_crop)\n",
-        "                    np.save('./image_resized/masks/' + str(image) + \"_\" + str(cpt), mask_crop)\n",
-        "                    if firstTimeForImage:\n",
-        "                        next_background = True\n",
-        "                        firstTimeForImage = False\n",
-        "                elif next_background:\n",
-        "                    np.save('./image_resized/image/' + str(image) + \"_\" + str(cpt), image_crop)\n",
-        "                    np.save('./image_resized/masks/' + str(image) + \"_\" + str(cpt), mask_crop)\n",
-        "                    next_background = False\n",
-        "                cpt += 1\n",
-        "\n",
-        "        print(\"Image \" + str(image_counter) + \" done\")\n",
-        "        image_counter += 1\n"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": 5,
-      "metadata": {
-        "id": "SHcv-gSkFGsL"
-      },
-      "outputs": [
-        {
-          "name": "stdout",
-          "output_type": "stream",
-          "text": [
-            "prepare data\n",
-            "Image 0 done\n",
-            "Image 1 done\n",
-            "Image 2 done\n",
-            "Image 3 done\n",
-            "Image 4 done\n",
-            "Image 5 done\n",
-            "Image 6 done\n",
-            "Image 7 done\n",
-            "Image 8 done\n",
-            "Image 9 done\n",
-            "Image 0 done\n",
-            "Image 1 done\n",
-            "Image 2 done\n",
-            "Image 3 done\n",
-            "Image 4 done\n",
-            "Image 5 done\n",
-            "Image 6 done\n",
-            "Image 7 done\n",
-            "Image 8 done\n",
-            "Image 9 done\n"
-          ]
-        }
-      ],
-      "source": [
-        "# clear the folder \"image_resized/image\" and \"image_resized/masks\"\n",
-        "shutil.rmtree('./image_resized/image')\n",
-        "shutil.rmtree('./image_resized/masks')\n",
-        "\n",
-        "os.mkdir('./image_resized/image')\n",
-        "os.mkdir('./image_resized/masks')\n",
-        "\n",
-        "\n",
-        "# prepare data\n",
-        "print(\"prepare data\")\n",
-        "prepare_data(train_image_list, train_path)\n",
-        "prepare_data(test_image_list, test_path)\n",
-        "\n"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": 6,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# creation of the UNET\n",
-        "# import relu \n",
-        "from keras.layers import LeakyReLU\n",
-        "\n",
-        "def down_block(x, filters, kernel_size=(3, 3), padding=\"same\", strides=1):\n",
-        "    c = keras.layers.Conv2D(filters, kernel_size, padding=padding, strides=strides, activation=LeakyReLU(alpha=0.1),kernel_initializer=keras.initializers.he_uniform(seed=None))(x)\n",
-        "    c = keras.layers.Conv2D(filters, kernel_size, padding=padding, strides=strides, activation=LeakyReLU(alpha=0.1),kernel_initializer=keras.initializers.he_uniform(seed=None))(c)\n",
-        "    c = keras.layers.BatchNormalization()(c)\n",
-        "    c = keras.layers.Conv2D(filters, kernel_size, padding=padding, strides=strides, activation=LeakyReLU(alpha=0.1),kernel_initializer=keras.initializers.he_uniform(seed=None))(c)\n",
-        "    c = keras.layers.Conv2D(filters, kernel_size, padding=padding, strides=strides, activation=LeakyReLU(alpha=0.1),kernel_initializer=keras.initializers.he_uniform(seed=None))(c)\n",
-        "    p = keras.layers.MaxPool2D((2, 2), (2, 2))(c)\n",
-        "    p = keras.layers.BatchNormalization(trainable=True)(p)\n",
-        "    return c, p\n",
-        "\n",
-        "def up_block(x, skip, filters, kernel_size=(3, 3), padding=\"same\", strides=1):\n",
-        "    us = keras.layers.UpSampling2D((2, 2))(x)\n",
-        "    us = keras.layers.BatchNormalization()(us)\n",
-        "    concat = keras.layers.Concatenate()([us, skip])\n",
-        "    c = keras.layers.Conv2D(filters, kernel_size, padding=padding, strides=strides, activation=LeakyReLU(alpha=0.1),kernel_initializer=keras.initializers.he_uniform(seed=None))(concat)\n",
-        "    c = keras.layers.Conv2D(filters, kernel_size, padding=padding, strides=strides, activation=LeakyReLU(alpha=0.1),kernel_initializer=keras.initializers.he_uniform(seed=None))(c)\n",
-        "    c = keras.layers.BatchNormalization(trainable=True)(c)\n",
-        "    c = keras.layers.Conv2D(filters, kernel_size, padding=padding, strides=strides, activation=LeakyReLU(alpha=0.1),kernel_initializer=keras.initializers.he_uniform(seed=None))(c)\n",
-        "    c = keras.layers.Conv2D(filters, kernel_size, padding=padding, strides=strides, activation=LeakyReLU(alpha=0.1),kernel_initializer=keras.initializers.he_uniform(seed=None))(c)\n",
-        "    return c\n",
-        "\n",
-        "def bottleneck(x, filters, kernel_size=(3, 3), padding=\"same\", strides=1):\n",
-        "    c = keras.layers.Conv2D(filters, kernel_size, padding=padding, strides=strides, activation=LeakyReLU(alpha=0.1),kernel_initializer=keras.initializers.he_uniform(seed=None))(x)\n",
-        "    c = keras.layers.Conv2D(filters, kernel_size, padding=padding, strides=strides, activation=LeakyReLU(alpha=0.1),kernel_initializer=keras.initializers.he_uniform(seed=None))(c)\n",
-        "    c = keras.layers.BatchNormalization()(c)\n",
-        "    c = keras.layers.Conv2D(filters, kernel_size, padding=padding, strides=strides, activation=LeakyReLU(alpha=0.1),kernel_initializer=keras.initializers.he_uniform(seed=None))(c)\n",
-        "    c = keras.layers.Conv2D(filters, kernel_size, padding=padding, strides=strides, activation=LeakyReLU(alpha=0.1),kernel_initializer=keras.initializers.he_uniform(seed=None))(c)\n",
-        "    return c\n",
-        "\n",
-        "def UNET(image_size=256):\n",
-        "    f = [16, 32, 64, 128, 256, 512]\n",
-        "    inputs = keras.layers.Input((image_size, image_size, 3))\n",
-        "\n",
-        "    p0 = inputs\n",
-        "    c1, p1 = down_block(p0, f[0])  # 128 -> 64\n",
-        "    c2, p2 = down_block(p1, f[1])  # 64 -> 32\n",
-        "    c3, p3 = down_block(p2, f[2])  # 32 -> 16\n",
-        "    c4, p4 = down_block(p3, f[3])  # 16->8\n",
-        "    c5, p5 = down_block(p4, f[4])  # 16->8\n",
-        "\n",
-        "    bn = bottleneck(p5, f[5])\n",
-        "\n",
-        "    u1 = up_block(bn, c5, f[4])  # 8 -> 16\n",
-        "    u2 = up_block(u1, c4, f[3])  # 16 -> 32\n",
-        "    u3 = up_block(u2, c3, f[2])  # 32 -> 64\n",
-        "    u4 = up_block(u3, c2, f[1])  # 64 -> 128\n",
-        "    u5 = up_block(u4, c1, f[0])  # 32 -> 64\n",
-        "\n",
-        "    outputs = keras.layers.Conv2D(1, (1, 1), padding=\"same\", activation=\"sigmoid\")(u5)\n",
-        "    outputs = keras.layers.Conv2D(1, (11, 11), padding=\"same\", activation=\"sigmoid\")(outputs)\n",
-        "    model = keras.models.Model(inputs, outputs)\n",
-        "    return model"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": 7,
-      "metadata": {},
-      "outputs": [
-        {
-          "name": "stderr",
-          "output_type": "stream",
-          "text": [
-            "2023-01-14 13:30:21.996187: W tensorflow/compiler/xla/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcuda.so.1'; dlerror: libcuda.so.1: cannot open shared object file: No such file or directory; LD_LIBRARY_PATH: /usr/local/lib/python3.10/dist-packages/cv2/../../lib64:\n",
-            "2023-01-14 13:30:21.996213: W tensorflow/compiler/xla/stream_executor/cuda/cuda_driver.cc:265] failed call to cuInit: UNKNOWN ERROR (303)\n",
-            "2023-01-14 13:30:21.996228: I tensorflow/compiler/xla/stream_executor/cuda/cuda_diagnostics.cc:156] kernel driver does not appear to be running on this host (pop-os): /proc/driver/nvidia/version does not exist\n",
-            "2023-01-14 13:30:21.997258: I tensorflow/core/platform/cpu_feature_guard.cc:193] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  AVX2 AVX512F AVX512_VNNI FMA\n",
-            "To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.\n"
-          ]
-        },
-        {
-          "name": "stdout",
-          "output_type": "stream",
-          "text": [
-            "model compiled\n"
-          ]
-        }
-      ],
-      "source": [
-        "# create a unet model for densification of the mask\n",
-        "\n",
-        "unet_model = UNET(image_size=256)\n",
-        "# compile the model\n",
-        "unet_model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy', 'mean_squared_error'])\n",
-        "\n",
-        "\n",
-        "print(\"model compiled\")"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": 8,
-      "metadata": {},
-      "outputs": [],
-      "source": [
-        "# load with np resized images and masks\n",
-        "train_image_list = os.listdir('./image_resized/image')\n",
-        "test_image_list = os.listdir('./image_resized/masks')\n",
-        "\n",
-        "# np load the images and masks\n",
-        "train_image_list = [np.load('./image_resized/image/' + image) for image in train_image_list]\n",
-        "test_image_list = [np.load('./image_resized/masks/' + image) for image in test_image_list]\n",
-        "\n"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": 9,
-      "metadata": {},
-      "outputs": [
-        {
-          "name": "stdout",
-          "output_type": "stream",
-          "text": [
-            "Epoch 1/10\n",
-            "39/39 [==============================] - 21s 349ms/step - loss: 0.6456 - accuracy: 0.7465 - mean_squared_error: 0.2268\n",
-            "Epoch 2/10\n",
-            "39/39 [==============================] - 13s 343ms/step - loss: 0.1516 - accuracy: 0.9991 - mean_squared_error: 0.0273\n",
-            "Epoch 3/10\n",
-            "39/39 [==============================] - 14s 347ms/step - loss: 0.0204 - accuracy: 0.9992 - mean_squared_error: 0.0022\n",
-            "Epoch 4/10\n",
-            "39/39 [==============================] - 13s 344ms/step - loss: 0.0059 - accuracy: 0.9992 - mean_squared_error: 3.1575e-04\n",
-            "Epoch 5/10\n",
-            "39/39 [==============================] - 13s 346ms/step - loss: 0.0042 - accuracy: 0.9992 - mean_squared_error: 1.6982e-04\n",
-            "Epoch 6/10\n",
-            "39/39 [==============================] - 13s 339ms/step - loss: 0.0033 - accuracy: 0.9992 - mean_squared_error: 8.9449e-05\n",
-            "Epoch 7/10\n",
-            "39/39 [==============================] - 13s 342ms/step - loss: 0.0090 - accuracy: 0.9992 - mean_squared_error: 0.0021\n",
-            "Epoch 8/10\n",
-            "39/39 [==============================] - 14s 369ms/step - loss: 0.0070 - accuracy: 0.9992 - mean_squared_error: 0.0011\n",
-            "Epoch 9/10\n",
-            "39/39 [==============================] - 15s 391ms/step - loss: 0.0025 - accuracy: 0.9992 - mean_squared_error: 9.3979e-05\n",
-            "Epoch 10/10\n",
-            "39/39 [==============================] - 14s 352ms/step - loss: 0.0027 - accuracy: 0.9992 - mean_squared_error: 1.0419e-04\n"
-          ]
-        }
-      ],
-      "source": [
-        "# train the model\n",
-        "unet_model.fit(np.array(train_image_list), np.array(test_image_list), epochs=10, batch_size=1)\n",
-        "\n",
-        "# save the model\n",
-        "unet_model.save('unet_model.h5')\n"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {},
-      "outputs": [],
-      "source": []
-    }
-  ],
-  "metadata": {
-    "colab": {
-      "provenance": []
-    },
-    "kernelspec": {
-      "display_name": "Python 3.10.4 64-bit",
-      "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.10.4"
-    },
-    "vscode": {
-      "interpreter": {
-        "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1"
-      }
-    }
-  },
-  "nbformat": 4,
-  "nbformat_minor": 0
-}
diff --git a/launch.png b/launch.png
deleted file mode 100644
index 0d7001516bc770ce460d7f266a54875c4042fe41..0000000000000000000000000000000000000000
Binary files a/launch.png and /dev/null differ
diff --git a/masque.png b/masque.png
deleted file mode 100644
index 39da237a67f8b829d46571efdc77b729a1ec4507..0000000000000000000000000000000000000000
Binary files a/masque.png and /dev/null differ
diff --git a/quadrillage.png b/quadrillage.png
deleted file mode 100644
index a0c6b22f883d84423c02b105226b40147dd6dd87..0000000000000000000000000000000000000000
Binary files a/quadrillage.png and /dev/null differ
diff --git a/rapport.md b/rapport.md
deleted file mode 100644
index 459847c36ac5d499453b7ee5013a8ee56c8979c3..0000000000000000000000000000000000000000
--- a/rapport.md
+++ /dev/null
@@ -1,36 +0,0 @@
-# Page 1
-## Counting Elephants from Aerial Photography 
-Pour le cours "Machine learning on big data" en Master à l'HES-SO, Suisse, 2022-23
-| name | email |
-| --- | --- |
-| Arintsoa Kiady | kiady.arintsoa@hes-so.ch |
-| Cirilli Simon | simon.cirilli@hes-so.ch |
-
-
-## Liens utiles et sources du travail
-Un papier sur le projet :
-https://openaccess.thecvf.com/content_CVPRW_2019/papers/DOAI/Naude_The_Aerial_Elephant_Dataset_A_New_Public_Benchmark_for_Aerial_CVPRW_2019_paper.pdf
-
-Un github avec une implémentation du projet dont nous nous inspirons :
-https://github.com/cpadubidri/Counting-Sea-Lions-and-Elephants-from-Aerial-Photography-using-Deep-Learning-with-Density-Maps
-
-Un autre papier sur le projet :
-https://animalbiotelemetry.biomedcentral.com/articles/10.1186/s40317-021-00247-x
-
-
-##  General context and objectives of the project 
-L'objectif de manière général à ce projet est de 
-
-# Page 2
-## Database description
-
-## Data pre-processing & feature extraction
-
-# Page 3
-##  A brief description mentioning the ML techniques used and explaining why you chose them. Present the parameters of your model and explain how you selected them (e.g., in the case of an ANN: topology, activation functions, number of layers, number of hidden neurones per layer, etc). Present the parameters of the learning algorithm and explain how you selected them
-
-# Page 4
-## Experiments and results: describe the experiments and the results. Explain the reasoning behind those experiments, e.g., what are the hypothesis ? Use performance measures to evaluate them and explain the results. (1 page)
-
-# Page 5
-## Analysis and conclusions
\ No newline at end of file
diff --git a/rapport.pdf b/rapport.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..f11c304bdf122248d465b48f15d85fe51ae6cb22
Binary files /dev/null and b/rapport.pdf differ
diff --git a/runsh.png b/runsh.png
deleted file mode 100644
index dbecf5f5cb5963590ecff56a9de87e7fc651a82f..0000000000000000000000000000000000000000
Binary files a/runsh.png and /dev/null differ
diff --git a/main.py b/scripts/main.py
similarity index 87%
rename from main.py
rename to scripts/main.py
index b9ad8100d00236c38a7104d37a3e27ff1ba6b04c..750738b5239437428dd467207fb89e4390bb44e7 100644
--- a/main.py
+++ b/scripts/main.py
@@ -67,19 +67,19 @@ def UNET(image_size=256):
     inputs = keras.layers.Input((image_size, image_size, 3))
 
     p0 = inputs
-    c1, p1 = down_block(p0, f[0])  # 128 -> 64
-    c2, p2 = down_block(p1, f[1])  # 64 -> 32
-    c3, p3 = down_block(p2, f[2])  # 32 -> 16
-    c4, p4 = down_block(p3, f[3])  # 16->8
-    c5, p5 = down_block(p4, f[4])  # 16->8
+    c1, p1 = down_block(p0, f[0]) 
+    c2, p2 = down_block(p1, f[1])  
+    c3, p3 = down_block(p2, f[2])  
+    c4, p4 = down_block(p3, f[3])  
+    c5, p5 = down_block(p4, f[4])  
 
     bn = bottleneck(p5, f[5])
 
-    u1 = up_block(bn, c5, f[4])  # 8 -> 16
-    u2 = up_block(u1, c4, f[3])  # 16 -> 32
-    u3 = up_block(u2, c3, f[2])  # 32 -> 64
-    u4 = up_block(u3, c2, f[1])  # 64 -> 128
-    u5 = up_block(u4, c1, f[0])  # 32 -> 64
+    u1 = up_block(bn, c5, f[4])  
+    u2 = up_block(u1, c4, f[3])  
+    u3 = up_block(u2, c3, f[2])  
+    u4 = up_block(u3, c2, f[1])  
+    u5 = up_block(u4, c1, f[0])  
 
     outputs = keras.layers.Conv2D(1, (1, 1), padding="same", activation="sigmoid")(u5)
     outputs = keras.layers.Conv2D(1, (11, 11), padding="same", activation="sigmoid")(outputs)
@@ -92,19 +92,19 @@ def UNET_2(image_size=256):
     inputs = keras.layers.Input((image_size, image_size, 3))
 
     p0 = inputs
-    c1, p1 = down_block_2(p0, f[0])  # 128 -> 64
-    c2, p2 = down_block_2(p1, f[1])  # 64 -> 32
-    c3, p3 = down_block_2(p2, f[2])  # 32 -> 16
-    c4, p4 = down_block_2(p3, f[3])  # 16->8
-    c5, p5 = down_block_2(p4, f[4])  # 16->8
+    c1, p1 = down_block_2(p0, f[0])  
+    c2, p2 = down_block_2(p1, f[1])  
+    c3, p3 = down_block_2(p2, f[2])  
+    c4, p4 = down_block_2(p3, f[3])  
+    c5, p5 = down_block_2(p4, f[4])  
 
     bn = bottleneck_2(p5, f[5])
 
-    u1 = up_block_2(bn, c5, f[4])  # 8 -> 16
-    u2 = up_block_2(u1, c4, f[3])  # 16 -> 32
-    u3 = up_block_2(u2, c3, f[2])  # 32 -> 64
-    u4 = up_block_2(u3, c2, f[1])  # 64 -> 128
-    u5 = up_block_2(u4, c1, f[0])  # 32 -> 64
+    u1 = up_block_2(bn, c5, f[4])  
+    u2 = up_block_2(u1, c4, f[3])  
+    u3 = up_block_2(u2, c3, f[2])  
+    u4 = up_block_2(u3, c2, f[1])  
+    u5 = up_block_2(u4, c1, f[0]) 
 
     outputs = keras.layers.Conv2D(1, (1, 1), padding="same", activation="sigmoid")(u5)
     outputs = keras.layers.Conv2D(1, (11, 11), padding="same", activation="sigmoid")(outputs)
@@ -115,7 +115,7 @@ def UNET_2(image_size=256):
 unet_model = UNET(image_size=256)
 
 # compile the model
-# loss test function : binary_crossentropy, focal_loss à tester : dice_coef_loss
+# loss test function : binary_crossentropy, focal_loss, à tester : dice_coef_loss
 def focal_loss(gamma=2., alpha=.25):
     def focal_loss_fixed(y_true, y_pred):
         pt_1 = tf.where(tf.equal(y_true, 1), y_pred, tf.ones_like(y_pred))
diff --git a/prepare.py b/scripts/prepare.py
similarity index 100%
rename from prepare.py
rename to scripts/prepare.py
diff --git a/pres.py b/scripts/pres.py
similarity index 100%
rename from pres.py
rename to scripts/pres.py
diff --git a/testModel.py b/scripts/testModel.py
similarity index 100%
rename from testModel.py
rename to scripts/testModel.py
diff --git a/unet_model.h5 b/unet_model.h5
deleted file mode 100644
index eb0bf2d78c37629e11266221dfaa55bf54382bbd..0000000000000000000000000000000000000000
Binary files a/unet_model.h5 and /dev/null differ
diff --git a/launch.sh b/yggdasil_scripts/launch.sh
similarity index 100%
rename from launch.sh
rename to yggdasil_scripts/launch.sh
diff --git a/prep.sh b/yggdasil_scripts/prep.sh
similarity index 100%
rename from prep.sh
rename to yggdasil_scripts/prep.sh
diff --git a/prepare.sh b/yggdasil_scripts/prepare.sh
similarity index 100%
rename from prepare.sh
rename to yggdasil_scripts/prepare.sh
diff --git a/run.sh b/yggdasil_scripts/run.sh
similarity index 100%
rename from run.sh
rename to yggdasil_scripts/run.sh
diff --git a/zoomedQuadri.png b/zoomedQuadri.png
deleted file mode 100644
index 974b7a44fb2bbb08ad80f82430417a21150d13ea..0000000000000000000000000000000000000000
Binary files a/zoomedQuadri.png and /dev/null differ