fake_image_detection_project.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "-Yly4fQhA-LO"
   },
   "source": [
    "# DEEPFAKE DETECTION PROJECT"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 122
    },
    "id": "CsuOcZk9A-Li",
    "outputId": "b0b721bc-adeb-48e3-c457-4ca7bef5d1d1"
   },
   "outputs": [],
   "source": [
    "from google.colab import drive\n",
    "drive.mount(\"/content/gdrive\")\n",
    "\n",
    "base_path = '/content/gdrive/My Drive/Colab Notebooks/deepfake/'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 377
    },
    "id": "_Zd--KllNPNy",
    "outputId": "bbedcac0-23e2-4d2a-d9ff-569126b4847c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Collecting poutyne\n",
      "\u001b[?25l  Downloading https://files.pythonhosted.org/packages/d8/83/6beb7cc2206e429342fa6385f92e1eccf1d2af8f4cbcdc5e7402cf65a5c5/Poutyne-0.7.2-py3-none-any.whl (75kB)\n",
      "\u001b[K     |████████████████████████████████| 81kB 2.2MB/s eta 0:00:011\n",
      "\u001b[?25hRequirement already satisfied: torch in /usr/local/lib/python3.6/dist-packages (from poutyne) (1.5.0+cu101)\n",
      "Requirement already satisfied: numpy in /usr/local/lib/python3.6/dist-packages (from poutyne) (1.18.4)\n",
      "Requirement already satisfied: future in /usr/local/lib/python3.6/dist-packages (from torch->poutyne) (0.16.0)\n",
      "Installing collected packages: poutyne\n",
      "Successfully installed poutyne-0.7.2\n",
      "Collecting efficientnet-pytorch\n",
      "  Downloading https://files.pythonhosted.org/packages/b8/cb/0309a6e3d404862ae4bc017f89645cf150ac94c14c88ef81d215c8e52925/efficientnet_pytorch-0.6.3.tar.gz\n",
      "Requirement already satisfied: torch in /usr/local/lib/python3.6/dist-packages (from efficientnet-pytorch) (1.5.0+cu101)\n",
      "Requirement already satisfied: numpy in /usr/local/lib/python3.6/dist-packages (from torch->efficientnet-pytorch) (1.18.4)\n",
      "Requirement already satisfied: future in /usr/local/lib/python3.6/dist-packages (from torch->efficientnet-pytorch) (0.16.0)\n",
      "Building wheels for collected packages: efficientnet-pytorch\n",
      "  Building wheel for efficientnet-pytorch (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
      "  Created wheel for efficientnet-pytorch: filename=efficientnet_pytorch-0.6.3-cp36-none-any.whl size=12422 sha256=b786e3d9c6628e493b9a05eb922a5bd3f82a9445ec03a1e5360aacd4c3431082\n",
      "  Stored in directory: /root/.cache/pip/wheels/42/1e/a9/2a578ba9ad04e776e80bf0f70d8a7f4c29ec0718b92d8f6ccd\n",
      "Successfully built efficientnet-pytorch\n",
      "Installing collected packages: efficientnet-pytorch\n",
      "Successfully installed efficientnet-pytorch-0.6.3\n"
     ]
    }
   ],
   "source": [
    "!pip3 install --quiet poutyne efficientnet-pytorch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "hjhgKOh9A-Lu"
   },
   "outputs": [],
   "source": [
    "import sys\n",
    "sys.path.append(base_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "tWguqkOXA-Lz"
   },
   "outputs": [],
   "source": [
    "import os\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import cv2\n",
    "\n",
    "from PIL import Image\n",
    "from tqdm import tqdm\n",
    "\n",
    "from pathlib import Path\n",
    "from concurrent.futures import ThreadPoolExecutor\n",
    "from functools import partial\n",
    "\n",
    "from blazeface import BlazeFace\n",
    "\n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "from torchvision import transforms\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "import torchvision\n",
    "from efficientnet_pytorch import EfficientNet\n",
    "from poutyne.framework import Model, ModelCheckpoint, BestModelRestore, CSVLogger\n",
    "\n",
    "\n",
    "device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "U6rFYG20A-L9"
   },
   "source": [
    "## Datasets Preprocessing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "8zrO7GjUA-L_"
   },
   "outputs": [],
   "source": [
    "FFPP_SRC = os.path.join(base_path, 'datasets')\n",
    "VIDEODF_SRC = os.path.join(FFPP_SRC, 'ffpp_videos.pkl')\n",
    "\n",
    "BLAZEFACE_WEIGHTS = os.path.join(base_path, \"blazeface/blazeface.pth\")\n",
    "BLAZEFACE_ANCHORS = os.path.join(base_path, \"blazeface/anchors.npy\")\n",
    "\n",
    "FACES_DST = os.path.join(FFPP_SRC, 'extract_faces')\n",
    "FACESDF_DST = os.path.join(FACES_DST, 'ffpp_faces.pkl')\n",
    "CHECKPOINT_DST = os.path.join(FACES_DST, 'checkpoint')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "hkMswaAHA-MF"
   },
   "source": [
    "### FF++ Preprocessing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Wkz8jXImA-MH"
   },
   "outputs": [],
   "source": [
    "def preprocess_ffpp(source_dir, video_dataset_path):\n",
    "    \"\"\"\n",
    "        Preprocessing video dataset : Set the label of each video {0 for real video, \n",
    "        1 for fake video} and the video original of fake videos.\n",
    "        :param source_dir: The parent directory that contains all videos (real or fake)\n",
    "        :param video_dataset_path: The path to save the videos DataFrame[path, name, \n",
    "                                    label, original]\n",
    "    \"\"\" \n",
    "    source_dir = Path(source_dir)\n",
    "    video_dataset_path = Path(video_dataset_path)\n",
    "    \n",
    "    # Create ouput folder (if doesn't exist)\n",
    "    video_dataset_path.parent.mkdir(parents=True, exist_ok=True)\n",
    "\n",
    "    ## DataFrame\n",
    "    if video_dataset_path.exists():\n",
    "        print('Loading video DataFrame')\n",
    "        df_videos = pd.read_pickle(video_dataset_path)\n",
    "    else:\n",
    "        print('Creating video DataFrame')\n",
    "        df_videos = pd.DataFrame({'path': [f.relative_to(source_dir) \n",
    "                                          for f in source_dir.rglob('*.mp4')]})\n",
    "        \n",
    "        # 1 if fake, otherwise 0\n",
    "        df_videos['label'] = df_videos['path'].map(\n",
    "            lambda x: 1 if x.parts[0] == 'manipulated_sequences' else 0)\n",
    "        \n",
    "        source = df_videos['path'].map(lambda x: x.parts[1]).astype('category')\n",
    "        df_videos['name'] = df_videos['path'].map(lambda x: x.with_suffix('').parts[-1])\n",
    "        df_videos['path'] = df_videos['path'].map(lambda x: str(x))\n",
    "\n",
    "        df_videos['original'] = -1 * np.ones(len(df_videos), dtype=np.int16)\n",
    "        df_videos.loc[(df_videos['label'] == 1) & (source != 'DeepFakeDetection'), 'original'] = \\\n",
    "            df_videos[(df_videos['label'] == 1) & (source != 'DeepFakeDetection')]['name'].map(\n",
    "                lambda x: df_videos.index[np.flatnonzero(df_videos['name'] == x.split('_')[0])[0]]\n",
    "            )\n",
    "        df_videos.loc[(df_videos['label'] == 1) & (source == 'DeepFakeDetection'), 'original'] = \\\n",
    "            df_videos[(df_videos['label'] == 1) & (source == 'DeepFakeDetection')]['name'].map(\n",
    "                lambda x: df_videos.index[\n",
    "                    np.flatnonzero(df_videos['name'] == x.split('_')[0] + '__' + x.split('__')[1])[0]]\n",
    "            )\n",
    "\n",
    "        print('Saving video DataFrame to {}'.format(video_dataset_path))\n",
    "        df_videos.to_pickle(str(video_dataset_path))\n",
    "\n",
    "    print('Real videos: {:d}'.format(sum(df_videos['label'] == 0)))\n",
    "    print('Fake videos: {:d}'.format(sum(df_videos['label'] == 1)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 68
    },
    "id": "50I8DTgAA-MX",
    "outputId": "50299075-5427-4974-ffbd-15c48da73d86"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loading video DataFrame\n",
      "Real videos: 1363\n",
      "Fake videos: 7068\n"
     ]
    }
   ],
   "source": [
    "# preprocess ff++ data\n",
    "preprocess_ffpp(FFPP_SRC, VIDEODF_SRC)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "8YjT22kUA-MN"
   },
   "source": [
    "### Extract faces"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "J7r42lQjA-MP"
   },
   "outputs": [],
   "source": [
    "def extract_faces_on_video(video_df, source_dir, faces_dir, checkpoint_dir, \n",
    "                           blazeface, num_frames, face_size=224, margin=0.25):\n",
    "    \"\"\"\n",
    "        This function extracts `num_frames` frames from the videos that contain a face.\n",
    "        :param video_df: The DataFrame that contains all information about the datasets. \n",
    "            It has the following columns: [path, name, label, original].\n",
    "        :param source_dir: The parent directory that contains the datasets\n",
    "        :param faces_dir: The directory path to save the extracted faces from the datasets\n",
    "        :param checkpoint_dir: The directory path to save the DataFrame[path, label, video, \n",
    "            original, frame_index, score, detection] of the extracted faces\n",
    "        :param blazeface: A Balazeface object that will be used as the face detector in all \n",
    "            frames\n",
    "        :param num_frames: The number of frames to extract in each video\n",
    "        :param face_size (default = 224) : Each frame extracted will have the size \n",
    "            face_size x face_size\n",
    "        :param margin (default = 0.25) : The offset margin for face detection.\n",
    "    \"\"\"\n",
    "    video_idx, video_df = video_df\n",
    "    faces_checkpoint_path = Path(checkpoint_dir).joinpath(video_df['path'].split('.')[0] + '_faces.pkl')\n",
    "    if faces_checkpoint_path.exists():\n",
    "        faces = pd.read_pickle(faces_checkpoint_path)\n",
    "        return faces\n",
    "    \n",
    "    reader = cv2.VideoCapture(str(Path(source_dir).joinpath(video_df['path'])))\n",
    "    frame_count = int(reader.get(cv2.CAP_PROP_FRAME_COUNT))\n",
    "    frame_idx = np.unique(np.linspace(0, frame_count - 1, num_frames, dtype=int))\n",
    "    # Get the frames choosen\n",
    "    frames, idx = [], 0\n",
    "    while reader.grab():\n",
    "        if idx in frame_idx:\n",
    "            ret, frame = reader.retrieve()\n",
    "            if not ret or frame is None:\n",
    "                print(\"Error retrieving frame %d from movie %s\" % (frame_idx, path))\n",
    "                break\n",
    "            frames.append(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))\n",
    "        idx += 1\n",
    "    frames = np.stack(frames)\n",
    "\n",
    "    target_w, target_h = blazeface.input_size\n",
    "    # For each frame, get some tiles with target_w x target_h as size\n",
    "    num_frames, height, width, _ = frames.shape\n",
    "\n",
    "    split_size = min(height, width, 720)\n",
    "    x_step = (width - split_size) // 2\n",
    "    y_step = (height - split_size) // 2\n",
    "    num_h = (height - split_size) // y_step + 1 if y_step > 0 else 1\n",
    "    num_w = (width - split_size) // x_step + 1 if x_step > 0 else 1\n",
    "\n",
    "    tiles = np.zeros((num_frames * num_h * num_w, target_h, target_w, 3), \n",
    "                     dtype=np.uint8)\n",
    "    i = 0\n",
    "    for f in range(num_frames):\n",
    "        y = 0\n",
    "        for _ in range(num_h):\n",
    "            x = 0\n",
    "            for __ in range(num_w):\n",
    "                crop = frames[f, y:y + split_size, x:x + split_size, :]\n",
    "                tiles[i] = cv2.resize(crop, (target_w, target_h), \n",
    "                                      interpolation=cv2.INTER_AREA)\n",
    "                x += x_step\n",
    "                i += 1\n",
    "            y += y_step\n",
    "\n",
    "    # Run the face detector. The result is a list of PyTorch tensors\n",
    "    detections = blazeface.predict_on_batch(tiles, apply_nms=False)\n",
    "    # Convert the detections from 128x128 back to the original frame size\n",
    "    for i in range(len(detections)):\n",
    "        # ymin, xmin, ymax, xmax\n",
    "        for k in range(2):\n",
    "            detections[i][:, k * 2] = (detections[i][:, k * 2] * target_h) * split_size / target_h\n",
    "            detections[i][:, k * 2 + 1] = (detections[i][:, k * 2 + 1] * target_w) * split_size / target_w\n",
    "\n",
    "    # Because we have several tiles for each frame, combine the predictions from these tiles.\n",
    "    combined_detections = []\n",
    "    i = 0\n",
    "    for f in range(num_frames):\n",
    "        detections_for_frame = []\n",
    "        y = 0\n",
    "        for _ in range(num_h):\n",
    "            x = 0\n",
    "            for __ in range(num_w):\n",
    "                # Adjust the coordinates based on the split positions.\n",
    "                if detections[i].shape[0] > 0:\n",
    "                    for k in range(2):\n",
    "                        detections[i][:, k * 2] += y\n",
    "                        detections[i][:, k * 2 + 1] += x\n",
    "                \n",
    "                detections_for_frame.append(detections[i])\n",
    "                x += x_step\n",
    "                i += 1\n",
    "            y += y_step\n",
    "            \n",
    "        combined_detections.append(torch.cat(detections_for_frame))\n",
    "    if len(combined_detections) == 0:\n",
    "        return None\n",
    "    detections = blazeface.nms(combined_detections)\n",
    "    # Crop the faces out of the original frame.\n",
    "    faces = []\n",
    "    for i in range(len(detections)):\n",
    "        offset = torch.round(margin * (detections[i][:, 2] - detections[i][:, 0])) # margin 0.2\n",
    "        detections[i][:, 0] = torch.clamp(detections[i][:, 0] - offset * 2, min=0)  # ymin\n",
    "        detections[i][:, 1] = torch.clamp(detections[i][:, 1] - offset, min=0)  # xmin\n",
    "        detections[i][:, 2] = torch.clamp(detections[i][:, 2] + offset, max=height)  # ymax\n",
    "        detections[i][:, 3] = torch.clamp(detections[i][:, 3] + offset, max=width)  # xmax\n",
    "        \n",
    "        # Get the first best scored face\n",
    "        score, face, detection = 0, None, None\n",
    "        for j in range(len(detections[i])):\n",
    "            if score < detections[i][j][16].cpu():\n",
    "                detection = detections[i][j].cpu()\n",
    "                ymin, xmin, ymax, xmax = detection[:4].cpu().numpy().astype(int)\n",
    "                face = frames[i][ymin:ymax, xmin:xmax, :]\n",
    "                score = detection[16]\n",
    "                break\n",
    "        if face is not None:\n",
    "            image = Image.fromarray(face)\n",
    "            # Crop the image to face_size x face_size\n",
    "            top, left, bottom, right = detection[:4].cpu().numpy().astype(int)\n",
    "            x_ctr = (left + right) // 2\n",
    "            y_ctr = (top + bottom) // 2\n",
    "            new_top = max(y_ctr - face_size // 2, 0)\n",
    "            new_bottom = min(new_top + face_size, height)\n",
    "            new_left = max(x_ctr - face_size // 2, 0)\n",
    "            new_right = min(new_left + face_size, width)\n",
    "            image.crop([new_left, new_top, new_right, new_bottom])\n",
    "            # Save image\n",
    "            face_path = Path(faces_dir).joinpath(video_df['path']).joinpath('frame_{}.jpg'.format(frame_idx[i]))\n",
    "            face_path.parent.mkdir(parents=True, exist_ok=True)\n",
    "            image.save(face_path)\n",
    "            \n",
    "            faces.append({\n",
    "                'path': str(Path(video_df['path']).joinpath('frame_{}.jpg'.format(frame_idx[i]))),\n",
    "                'label': video_df['label'],\n",
    "                'video': video_idx,\n",
    "                'original': video_df['original'],\n",
    "                'frame_index': frame_idx[i],\n",
    "                'score': float(score.numpy()),\n",
    "                'detection': detection[:4].cpu().numpy().astype(int)\n",
    "            })\n",
    "        # Save checkpoint\n",
    "        faces_checkpoint_path.parent.mkdir(parents=True, exist_ok=True)\n",
    "        pd.DataFrame(faces).to_pickle(str(faces_checkpoint_path))\n",
    "        \n",
    "    return faces"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "qIy8YsWJA-MU"
   },
   "outputs": [],
   "source": [
    "def extract_faces(source_dir, videos_df, faces_dir, faces_df, checkpoint_dir, \n",
    "                  frames_per_video=15, batch_size=16, face_size=224, thread_num=4):\n",
    "    \"\"\"\n",
    "        This function extracts all frames from the dataset that contain a face.\n",
    "        :param source_dir: The parent directory that contains the datasets\n",
    "        :param videos_df: The path of the DataFrame containing all information \n",
    "            about the videos in the dataset.\n",
    "        :param faces_dir: The directory path to save the extracted faces from the datasets\n",
    "        :param faces_df: The path to save the DataFrame containing all informations \n",
    "            about the extracted faces\n",
    "        :param checkpoint_dir: The directory path to save the DataFrame[path, label, \n",
    "            video, original, frame_index, score, detection] of the extracted faces\n",
    "        :param blazeface_weights: The Blazeface weights directory\n",
    "        :param blazeface_weights: The Blazeface anchors directory\n",
    "        :param frames_per_video (default = 15): The number of frames to extract in each video\n",
    "        :param batch_size (default = 16): The batch size of videos to process together\n",
    "        :param face_size (default = 224) : Each frame extracted will have the size face_size x face_size\n",
    "        :thread_num (default = 4): The number of threads to be used during the extraction\n",
    "    \"\"\"\n",
    "    if Path(faces_df).exists():\n",
    "        df_faces = pd.read_pickle(faces_df)\n",
    "        print('We got {} faces'.format(len(df_faces)))\n",
    "        print('Faces DataFrame Loaded')\n",
    "        return df_faces\n",
    "    \n",
    "    device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')\n",
    "    \n",
    "    print('Loading video DataFrame')\n",
    "    df_videos = pd.read_pickle(videos_df)\n",
    "    \n",
    "    print('Loading Blazeface model')\n",
    "    blazeface_net = BlazeFace().to(device)\n",
    "    blazeface_net.load_weights(BLAZEFACE_WEIGHTS)\n",
    "    blazeface_net.load_anchors(BLAZEFACE_ANCHORS)    \n",
    "    blazeface_net.min_score_thresh = 0.8\n",
    "    \n",
    "    ## Face extraction\n",
    "    with ThreadPoolExecutor(thread_num) as pool:\n",
    "        for batch_idx0 in tqdm(np.arange(start=0, stop=len(df_videos), step=batch_size),\n",
    "                               desc='Extracting faces'):\n",
    "            list(pool.map(partial(extract_faces_on_video,\n",
    "                          source_dir=source_dir,\n",
    "                          faces_dir=faces_dir,\n",
    "                          checkpoint_dir=checkpoint_dir,\n",
    "                          blazeface=blazeface_net,\n",
    "                          num_frames=frames_per_video,\n",
    "                          face_size=face_size,\n",
    "                          ),\n",
    "                          df_videos.iloc[batch_idx0:batch_idx0 + batch_size].iterrows()))\n",
    "    \n",
    "    faces_dataset = []\n",
    "    for _, df in tqdm(df_videos.iterrows(), total=len(df_videos), desc='Collecting faces results'):\n",
    "        face_checkpoint = Path(checkpoint_dir).joinpath(df['path'].split('.')[0] + '_faces.pkl')\n",
    "        if face_checkpoint.exists():\n",
    "            faces_dataset.append(pd.read_pickle(str(face_checkpoint)))\n",
    "    df_faces = pd.concat(faces_dataset, axis=0)\n",
    "    df_faces.to_pickle(faces_df)\n",
    "    print('We got {} faces'.format(len(df_faces)))\n",
    "    print('Completed!')\n",
    "    return df_faces"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 51
    },
    "id": "Wy0Y5AwtA-Mb",
    "outputId": "9767bcf6-8915-4771-9682-4f7f5fad372a"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "We got 126008 faces\n",
      "Faces DataFrame Loaded\n"
     ]
    }
   ],
   "source": [
    "# Run extraction\n",
    "df_faces = extract_faces(FFPP_SRC, VIDEODF_SRC, FACES_DST, FACESDF_DST,  CHECKPOINT_DST)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "mIzeeGplA-NQ"
   },
   "source": [
    "## Dataset processing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "6_y-9WSIA-NR"
   },
   "outputs": [],
   "source": [
    "IMG_SIZE = 224\n",
    "BATCH_SIZE = 128"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "hb3FfzYeA-NU"
   },
   "source": [
    "### Split dataset on original video"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "rLAoN8D1A-NU"
   },
   "outputs": [],
   "source": [
    "def make_splits(df_faces, train_ratio=0.7, val_ratio=0.15):\n",
    "    \"\"\"\n",
    "    Splitting the dataset into three subsets : train, validation and test.\n",
    "    \"\"\"\n",
    "    random_original_videos = np.random.permutation(df_faces[(df_faces['label'] == 0)]['video'].unique())\n",
    "    train_num = int(len(random_original_videos) * train_ratio)\n",
    "    val_num = int(len(random_original_videos) * val_ratio)\n",
    "    train_original = random_original_videos[:train_num]\n",
    "    val_original = random_original_videos[train_num: train_num + val_num]\n",
    "    test_original = random_original_videos[train_num + val_num:]\n",
    "    \n",
    "    df_train = pd.concat([df_faces[df_faces['original'].isin(train_original)], \n",
    "                          df_faces[df_faces['video'].isin(train_original)]], ignore_index=True)\n",
    "    df_val = pd.concat([df_faces[df_faces['original'].isin(val_original)], \n",
    "                        df_faces[df_faces['video'].isin(val_original)]], ignore_index=True)\n",
    "    df_test = pd.concat([df_faces[df_faces['original'].isin(test_original)], \n",
    "                         df_faces[df_faces['video'].isin(test_original)]], ignore_index=True)\n",
    "    \n",
    "    return df_train, df_val, df_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "dtLSibzXCXIA"
   },
   "outputs": [],
   "source": [
    "df_faces = pd.read_pickle(FACESDF_DST)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 204
    },
    "id": "2FdyPSuBChgk",
    "outputId": "c538a570-93ac-40f5-f9c3-c2985a55d974"
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>path</th>\n",
       "      <th>label</th>\n",
       "      <th>video</th>\n",
       "      <th>original</th>\n",
       "      <th>frame_index</th>\n",
       "      <th>score</th>\n",
       "      <th>detection</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>original_sequences/youtube/c23/videos/443.mp4/...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>-1</td>\n",
       "      <td>0</td>\n",
       "      <td>0.943969</td>\n",
       "      <td>[49, 365, 208, 501]</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>original_sequences/youtube/c23/videos/443.mp4/...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>-1</td>\n",
       "      <td>81</td>\n",
       "      <td>0.953632</td>\n",
       "      <td>[56, 367, 209, 498]</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>original_sequences/youtube/c23/videos/443.mp4/...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>-1</td>\n",
       "      <td>163</td>\n",
       "      <td>0.969033</td>\n",
       "      <td>[55, 370, 211, 504]</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>original_sequences/youtube/c23/videos/443.mp4/...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>-1</td>\n",
       "      <td>245</td>\n",
       "      <td>0.982940</td>\n",
       "      <td>[81, 367, 229, 495]</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>original_sequences/youtube/c23/videos/443.mp4/...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>-1</td>\n",
       "      <td>327</td>\n",
       "      <td>0.959360</td>\n",
       "      <td>[75, 368, 222, 495]</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                path  ...            detection\n",
       "0  original_sequences/youtube/c23/videos/443.mp4/...  ...  [49, 365, 208, 501]\n",
       "1  original_sequences/youtube/c23/videos/443.mp4/...  ...  [56, 367, 209, 498]\n",
       "2  original_sequences/youtube/c23/videos/443.mp4/...  ...  [55, 370, 211, 504]\n",
       "3  original_sequences/youtube/c23/videos/443.mp4/...  ...  [81, 367, 229, 495]\n",
       "4  original_sequences/youtube/c23/videos/443.mp4/...  ...  [75, 368, 222, 495]\n",
       "\n",
       "[5 rows x 7 columns]"
      ]
     },
     "execution_count": 15,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_faces.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "KLy4qAuQA-NZ"
   },
   "outputs": [],
   "source": [
    "df_train, df_val, df_test = make_splits(df_faces)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 85
    },
    "id": "AlpQAHFPA-Nc",
    "outputId": "dfdbc799-3d9e-4b5a-e550-53630693cfc6"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total dataset : 126008\n",
      "Total train : 90254\n",
      "Total val : 17455\n",
      "Total test : 18299\n"
     ]
    }
   ],
   "source": [
    "r_train, _ = df_train.shape\n",
    "r_val, _ = df_val.shape\n",
    "r_test, _ = df_test.shape\n",
    "\n",
    "print('Total dataset : {}'.format(r_train+r_val+r_test))\n",
    "print('Total train : {}'.format(r_train))\n",
    "print('Total val : {}'.format(r_val))\n",
    "print('Total test : {}'.format(r_test))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "4pVM8ty6A-Nf"
   },
   "source": [
    "### Transforms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "RR0i7TC5A-Nf"
   },
   "outputs": [],
   "source": [
    "pre_trained_mean, pre_trained_std = [0.485, 0.456, 0.406], [0.229, 0.224, 0.225]\n",
    "\n",
    "train_transform = transforms.Compose([\n",
    "    transforms.Resize((IMG_SIZE, IMG_SIZE)),\n",
    "    transforms.RandomHorizontalFlip(),\n",
    "    transforms.RandomAffine(degrees=40, scale=(.9, 1.1), shear=0),\n",
    "    transforms.RandomPerspective(distortion_scale=0.2),\n",
    "    transforms.ColorJitter(brightness=0.5, contrast=0.5, saturation=0.5),\n",
    "    transforms.ToTensor(),\n",
    "    transforms.RandomErasing(scale=(0.02, 0.16), ratio=(0.3, 1.6)),\n",
    "    transforms.Normalize(mean=pre_trained_mean, std=pre_trained_std)\n",
    "])\n",
    "\n",
    "val_tranform = transforms.Compose([\n",
    "    transforms.Resize((IMG_SIZE, IMG_SIZE)),\n",
    "    transforms.ToTensor(),\n",
    "    transforms.Normalize(mean=pre_trained_mean, std=pre_trained_std)\n",
    "])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "f8iG1vBAA-Ni"
   },
   "source": [
    "### Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "_YB92wiiA-Nj"
   },
   "outputs": [],
   "source": [
    "class FFPPDataset(Dataset):\n",
    "    def __init__(self, df_faces, faces_dir=FACES_DST, transform=None):\n",
    "        super().__init__()\n",
    "        self.faces_dir = Path(faces_dir)\n",
    "        self.data, self.targets = df_faces['path'], df_faces['label']\n",
    "        self.transform = transform\n",
    "        \n",
    "    def __getitem__(self, index):\n",
    "        img_path, target = self.data[index], self.targets[index]\n",
    "        target = np.array([target,]).astype(np.float32)\n",
    "        # read the image\n",
    "        img = Image.open(str(self.faces_dir.joinpath(img_path)))\n",
    "        \n",
    "        if self.transform is not None:\n",
    "            img = self.transform(img)\n",
    "        return img, target\n",
    "    \n",
    "    def __len__(self):\n",
    "        return len(self.data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "rxBdI_boA-Nm"
   },
   "outputs": [],
   "source": [
    "train_dataset = FFPPDataset(df_train, transform=train_transform)\n",
    "train_loader = DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True, \n",
    "                          num_workers=24, pin_memory=True)\n",
    "\n",
    "valid_dataset = FFPPDataset(df_val, transform=val_tranform)\n",
    "val_loader = DataLoader(valid_dataset, batch_size=BATCH_SIZE, num_workers=24, \n",
    "                        pin_memory=True)\n",
    "\n",
    "test_dataset = FFPPDataset(df_test, transform=val_tranform)\n",
    "test_loader = DataLoader(test_dataset, batch_size=BATCH_SIZE, num_workers=24, \n",
    "                         pin_memory=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Y7swTRXvMbld"
   },
   "source": [
    "## Entraîner le réseau EfficientNet\n",
    "\n",
    "Modèle pré-entraîner nommé : efficientnet-b4\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "BVLsLQ3N1Ha5"
   },
   "outputs": [],
   "source": [
    "# Training configuration\n",
    "# number of epochs to train for\n",
    "num_epochs = 10\n",
    "\n",
    "# learning rate\n",
    "learning_rate = 1e-4\n",
    "\n",
    "# loss_function\n",
    "criterion = nn.BCEWithLogitsLoss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "8NTgHso71zkG"
   },
   "outputs": [],
   "source": [
    "def train(net, model_name):\n",
    "  model_path = os.path.join(base_path, \n",
    "                            f'models/{model_name}' + '/best_epoch_{epoch}.ckpt')\n",
    "  Path(model_path).parent.mkdir(parents=True, exist_ok=True)\n",
    "  logs_file = os.path.join(base_path, f'logs/{model_name}/log.tsv')\n",
    "  Path(logs_file).parent.mkdir(parents=True, exist_ok=True)\n",
    "\n",
    "  callbacks = [\n",
    "    # Save the weights in a new file when the current model is better than all \n",
    "    # previous models.\n",
    "    ModelCheckpoint(model_path, monitor='val_bin_acc', mode='max', \n",
    "                    save_best_only=True, restore_best=True, verbose=True, \n",
    "                    temporary_filename=model_name + '_best_epoch.ckpt.tmp'),\n",
    "    \n",
    "    # Save the losses and accuracies for each epoch in a TSV.\n",
    "    CSVLogger(logs_file, separator='\\t'),\n",
    "  ]\n",
    "\n",
    "  params = (p for p in net.parameters() if p.requires_grad)\n",
    "  optimizer = optim.Adam(params, lr=learning_rate, weight_decay=0.000001)\n",
    "\n",
    "  model = Model(net, optimizer, criterion, batch_metrics=['bin_acc'])\n",
    "  model.to(device)\n",
    "\n",
    "  if Path(logs_file).exists():\n",
    "    logs = pd.read_csv(logs_file, sep='\\t')\n",
    "    epochs = list(logs['epoch'])\n",
    "    if len(epochs) != 0:\n",
    "      best_epoch_idx = logs['val_bin_acc'].idxmax()\n",
    "      best_epoch = int(logs.loc[best_epoch_idx]['epoch'])\n",
    "      model.load_weights(model_path.format(epoch=best_epoch))\n",
    "      if num_epochs not in epochs:\n",
    "        # Train\n",
    "        model.fit_generator(train_loader, val_loader, epochs=num_epochs, \n",
    "                            initial_epoch=epochs[-1], callbacks=callbacks)\n",
    "    else:\n",
    "      model.fit_generator(train_loader, val_loader, epochs=num_epochs, \n",
    "                          callbacks=callbacks)\n",
    "  else:\n",
    "    model.fit_generator(train_loader, val_loader, epochs=num_epochs, \n",
    "                        callbacks=callbacks)\n",
    "\n",
    "  logs = pd.read_csv(logs_file, sep='\\t')\n",
    "\n",
    "  best_epoch_idx = logs['val_bin_acc'].idxmax()\n",
    "  best_epoch = int(logs.loc[best_epoch_idx]['epoch'])\n",
    "  print(\"Best epoch: %d\" % best_epoch)\n",
    "\n",
    "  metrics = ['loss', 'val_loss']\n",
    "  plt.plot(logs['epoch'], logs[metrics])\n",
    "  plt.legend(metrics)\n",
    "  plt.title('Loss')\n",
    "  plt.show()\n",
    "\n",
    "  metrics = ['bin_acc', 'val_bin_acc']\n",
    "  plt.plot(logs['epoch'], logs[metrics])\n",
    "  plt.legend(metrics)\n",
    "  plt.title('Accuracy')\n",
    "  plt.show()\n",
    "\n",
    "  return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "nKbzkBCb-vQ3"
   },
   "outputs": [],
   "source": [
    "def test(model, test_loader):\n",
    "  test_loss, test_acc = model.evaluate_generator(test_loader)\n",
    "  print('Test:\\n\\tLoss: {}\\n\\tAccuracy: {}'.format(test_loss, test_acc))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Oc8EM1TS1FyQ"
   },
   "source": [
    "### Freezant tous les paramètres de convolution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 630
    },
    "id": "gkzbm95FFODY",
    "outputId": "5cdc683b-a6c8-45e5-c17b-6ca6ac962b2e"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loaded pretrained weights for efficientnet-b4\n",
      "Best epoch: 10\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light",
      "tags": []
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light",
      "tags": []
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test:\n",
      "\tLoss: 0.4520243748678985\n",
      "\tAccuracy: 83.44119377440231\n"
     ]
    }
   ],
   "source": [
    "efficientnet_a = EfficientNet.from_pretrained('efficientnet-b4')\n",
    "efficientnet_a._fc = nn.Linear(efficientnet_a._conv_head.out_channels, 1)\n",
    "\n",
    "for name, param in efficientnet_a.named_parameters():\n",
    "  if not name.startswith('_fc'):\n",
    "    param.requires_grad = False\n",
    "\n",
    "model_a = train(efficientnet_a, 'efficientnet_a')\n",
    "test(model_a, test_loader)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "T5_FQ-nrQAYz"
   },
   "source": [
    "### En réentraînant quelques blocs\n",
    "\n",
    "Réentraîner les 8 derniers blocs avec les deux dernières couches (couche de convolution et classificateur)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 1000,
     "referenced_widgets": [
      "070eb8acf3da4a90b422357a557c02de",
      "a97360270ec9405185501d1d5d1dcb49",
      "be1a54c2a1584186aad0ccb38ce488e6",
      "d1e20ce9d6334d43bdca7187103ba40b",
      "1b7d182d4e714faea9e3f810e5432408",
      "14f55ce43863405ab8adbe64cbbc86fb",
      "e58c63dc8ef649afb481b3f92aafd1fd",
      "d3c6935c60c84e2a857ac0040d837288"
     ]
    },
    "id": "mGvhRsFfULPj",
    "outputId": "49589859-6fe6-47f7-ee04-9b75ffb02010"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Downloading: \"https://github.com/lukemelas/EfficientNet-PyTorch/releases/download/1.0/efficientnet-b4-6ed6700e.pth\" to /root/.cache/torch/checkpoints/efficientnet-b4-6ed6700e.pth\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "070eb8acf3da4a90b422357a557c02de",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0, max=77999237.0), HTML(value='')))"
      ]
     },
     "metadata": {
      "tags": []
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Loaded pretrained weights for efficientnet-b4\n",
      "Epoch 1/10 3872.36s Step 691/691: loss: 0.395768, bin_acc: 83.936739, val_loss: 0.354313, val_bin_acc: 84.736467\n",
      "Epoch 1: val_bin_acc improved from -inf to 84.73647, saving file to /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_b/best_epoch_1.ckpt\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.6/dist-packages/poutyne/framework/callbacks/_utils.py:24: UserWarning: Impossible to move the file to its final destination: os.replace(efficientnet_b_best_epoch.ckpt.tmp, /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_b/best_epoch_1.ckpt) -> [Errno 18] Invalid cross-device link: 'efficientnet_b_best_epoch.ckpt.tmp' -> '/content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_b/best_epoch_1.ckpt'\n",
      "  \"os.replace(%s, %s) -> %s\" % (tmp_filename, filename, e))\n",
      "/usr/local/lib/python3.6/dist-packages/poutyne/framework/callbacks/_utils.py:27: UserWarning: Saving /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_b/best_epoch_1.ckpt non-atomically instead.\n",
      "  warnings.warn('Saving %s non-atomically instead.' % filename)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 2/10 462.96s Step 691/691: loss: 0.341417, bin_acc: 85.448082, val_loss: 0.326545, val_bin_acc: 85.893709\n",
      "Epoch 2: val_bin_acc improved from 84.73647 to 85.89371, saving file to /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_b/best_epoch_2.ckpt\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.6/dist-packages/poutyne/framework/callbacks/_utils.py:24: UserWarning: Impossible to move the file to its final destination: os.replace(efficientnet_b_best_epoch.ckpt.tmp, /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_b/best_epoch_2.ckpt) -> [Errno 18] Invalid cross-device link: 'efficientnet_b_best_epoch.ckpt.tmp' -> '/content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_b/best_epoch_2.ckpt'\n",
      "  \"os.replace(%s, %s) -> %s\" % (tmp_filename, filename, e))\n",
      "/usr/local/lib/python3.6/dist-packages/poutyne/framework/callbacks/_utils.py:27: UserWarning: Saving /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_b/best_epoch_2.ckpt non-atomically instead.\n",
      "  warnings.warn('Saving %s non-atomically instead.' % filename)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 3/10 462.81s Step 691/691: loss: 0.315877, bin_acc: 86.420550, val_loss: 0.324939, val_bin_acc: 86.228267\n",
      "Epoch 3: val_bin_acc improved from 85.89371 to 86.22827, saving file to /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_b/best_epoch_3.ckpt\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.6/dist-packages/poutyne/framework/callbacks/_utils.py:24: UserWarning: Impossible to move the file to its final destination: os.replace(efficientnet_b_best_epoch.ckpt.tmp, /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_b/best_epoch_3.ckpt) -> [Errno 18] Invalid cross-device link: 'efficientnet_b_best_epoch.ckpt.tmp' -> '/content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_b/best_epoch_3.ckpt'\n",
      "  \"os.replace(%s, %s) -> %s\" % (tmp_filename, filename, e))\n",
      "/usr/local/lib/python3.6/dist-packages/poutyne/framework/callbacks/_utils.py:27: UserWarning: Saving /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_b/best_epoch_3.ckpt non-atomically instead.\n",
      "  warnings.warn('Saving %s non-atomically instead.' % filename)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 4/10 465.53s Step 691/691: loss: 0.300288, bin_acc: 87.072635, val_loss: 0.310694, val_bin_acc: 86.623156\n",
      "Epoch 4: val_bin_acc improved from 86.22827 to 86.62316, saving file to /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_b/best_epoch_4.ckpt\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.6/dist-packages/poutyne/framework/callbacks/_utils.py:24: UserWarning: Impossible to move the file to its final destination: os.replace(efficientnet_b_best_epoch.ckpt.tmp, /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_b/best_epoch_4.ckpt) -> [Errno 18] Invalid cross-device link: 'efficientnet_b_best_epoch.ckpt.tmp' -> '/content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_b/best_epoch_4.ckpt'\n",
      "  \"os.replace(%s, %s) -> %s\" % (tmp_filename, filename, e))\n",
      "/usr/local/lib/python3.6/dist-packages/poutyne/framework/callbacks/_utils.py:27: UserWarning: Saving /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_b/best_epoch_4.ckpt non-atomically instead.\n",
      "  warnings.warn('Saving %s non-atomically instead.' % filename)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 5/10 463.99s Step 691/691: loss: 0.286216, bin_acc: 87.691890, val_loss: 0.305189, val_bin_acc: 86.952229\n",
      "Epoch 5: val_bin_acc improved from 86.62316 to 86.95223, saving file to /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_b/best_epoch_5.ckpt\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.6/dist-packages/poutyne/framework/callbacks/_utils.py:24: UserWarning: Impossible to move the file to its final destination: os.replace(efficientnet_b_best_epoch.ckpt.tmp, /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_b/best_epoch_5.ckpt) -> [Errno 18] Invalid cross-device link: 'efficientnet_b_best_epoch.ckpt.tmp' -> '/content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_b/best_epoch_5.ckpt'\n",
      "  \"os.replace(%s, %s) -> %s\" % (tmp_filename, filename, e))\n",
      "/usr/local/lib/python3.6/dist-packages/poutyne/framework/callbacks/_utils.py:27: UserWarning: Saving /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_b/best_epoch_5.ckpt non-atomically instead.\n",
      "  warnings.warn('Saving %s non-atomically instead.' % filename)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 6/10 463.47s Step 691/691: loss: 0.272688, bin_acc: 88.273785, val_loss: 0.299904, val_bin_acc: 87.242911\n",
      "Epoch 6: val_bin_acc improved from 86.95223 to 87.24291, saving file to /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_b/best_epoch_6.ckpt\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.6/dist-packages/poutyne/framework/callbacks/_utils.py:24: UserWarning: Impossible to move the file to its final destination: os.replace(efficientnet_b_best_epoch.ckpt.tmp, /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_b/best_epoch_6.ckpt) -> [Errno 18] Invalid cross-device link: 'efficientnet_b_best_epoch.ckpt.tmp' -> '/content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_b/best_epoch_6.ckpt'\n",
      "  \"os.replace(%s, %s) -> %s\" % (tmp_filename, filename, e))\n",
      "/usr/local/lib/python3.6/dist-packages/poutyne/framework/callbacks/_utils.py:27: UserWarning: Saving /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_b/best_epoch_6.ckpt non-atomically instead.\n",
      "  warnings.warn('Saving %s non-atomically instead.' % filename)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 7/10 463.90s Step 691/691: loss: 0.264562, bin_acc: 88.503600, val_loss: 0.304763, val_bin_acc: 87.401963\n",
      "Epoch 7: val_bin_acc improved from 87.24291 to 87.40196, saving file to /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_b/best_epoch_7.ckpt\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.6/dist-packages/poutyne/framework/callbacks/_utils.py:24: UserWarning: Impossible to move the file to its final destination: os.replace(efficientnet_b_best_epoch.ckpt.tmp, /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_b/best_epoch_7.ckpt) -> [Errno 18] Invalid cross-device link: 'efficientnet_b_best_epoch.ckpt.tmp' -> '/content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_b/best_epoch_7.ckpt'\n",
      "  \"os.replace(%s, %s) -> %s\" % (tmp_filename, filename, e))\n",
      "/usr/local/lib/python3.6/dist-packages/poutyne/framework/callbacks/_utils.py:27: UserWarning: Saving /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_b/best_epoch_7.ckpt non-atomically instead.\n",
      "  warnings.warn('Saving %s non-atomically instead.' % filename)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 8/10 464.97s Step 691/691: loss: 0.254212, bin_acc: 89.057193, val_loss: 0.307122, val_bin_acc: 87.462294\n",
      "Epoch 8: val_bin_acc improved from 87.40196 to 87.46229, saving file to /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_b/best_epoch_8.ckpt\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.6/dist-packages/poutyne/framework/callbacks/_utils.py:24: UserWarning: Impossible to move the file to its final destination: os.replace(efficientnet_b_best_epoch.ckpt.tmp, /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_b/best_epoch_8.ckpt) -> [Errno 18] Invalid cross-device link: 'efficientnet_b_best_epoch.ckpt.tmp' -> '/content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_b/best_epoch_8.ckpt'\n",
      "  \"os.replace(%s, %s) -> %s\" % (tmp_filename, filename, e))\n",
      "/usr/local/lib/python3.6/dist-packages/poutyne/framework/callbacks/_utils.py:27: UserWarning: Saving /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_b/best_epoch_8.ckpt non-atomically instead.\n",
      "  warnings.warn('Saving %s non-atomically instead.' % filename)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 9/10 465.45s Step 691/691: loss: 0.247119, bin_acc: 89.353802, val_loss: 0.296591, val_bin_acc: 87.577469\n",
      "Epoch 9: val_bin_acc improved from 87.46229 to 87.57747, saving file to /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_b/best_epoch_9.ckpt\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.6/dist-packages/poutyne/framework/callbacks/_utils.py:24: UserWarning: Impossible to move the file to its final destination: os.replace(efficientnet_b_best_epoch.ckpt.tmp, /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_b/best_epoch_9.ckpt) -> [Errno 18] Invalid cross-device link: 'efficientnet_b_best_epoch.ckpt.tmp' -> '/content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_b/best_epoch_9.ckpt'\n",
      "  \"os.replace(%s, %s) -> %s\" % (tmp_filename, filename, e))\n",
      "/usr/local/lib/python3.6/dist-packages/poutyne/framework/callbacks/_utils.py:27: UserWarning: Saving /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_b/best_epoch_9.ckpt non-atomically instead.\n",
      "  warnings.warn('Saving %s non-atomically instead.' % filename)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 10/10 465.80s Step 691/691: loss: 0.239817, bin_acc: 89.693429, val_loss: 0.294364, val_bin_acc: 87.840728\n",
      "Epoch 10: val_bin_acc improved from 87.57747 to 87.84073, saving file to /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_b/best_epoch_10.ckpt\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.6/dist-packages/poutyne/framework/callbacks/_utils.py:24: UserWarning: Impossible to move the file to its final destination: os.replace(efficientnet_b_best_epoch.ckpt.tmp, /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_b/best_epoch_10.ckpt) -> [Errno 18] Invalid cross-device link: 'efficientnet_b_best_epoch.ckpt.tmp' -> '/content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_b/best_epoch_10.ckpt'\n",
      "  \"os.replace(%s, %s) -> %s\" % (tmp_filename, filename, e))\n",
      "/usr/local/lib/python3.6/dist-packages/poutyne/framework/callbacks/_utils.py:27: UserWarning: Saving /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_b/best_epoch_10.ckpt non-atomically instead.\n",
      "  warnings.warn('Saving %s non-atomically instead.' % filename)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Restoring model from /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_b/best_epoch_10.ckpt\n",
      "Best epoch: 10\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light",
      "tags": []
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light",
      "tags": []
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test:\n",
      "\tLoss: 0.3369625567200436\n",
      "\tAccuracy: 86.94645886901155\n"
     ]
    }
   ],
   "source": [
    "efficientnet_b = EfficientNet.from_pretrained('efficientnet-b4')\n",
    "efficientnet_b._fc = nn.Linear(efficientnet_b._conv_head.out_channels, 1)\n",
    "\n",
    "names = [name for name, _ in list(efficientnet_b.named_parameters())[-109:]]\n",
    "for name, param in efficientnet_b.named_parameters():\n",
    "  if name not in names:\n",
    "    param.requires_grad = False\n",
    "\n",
    "model_b = train(efficientnet_b, 'efficientnet_b')\n",
    "test(model_b, test_loader)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Tq3kPtqzmEsJ"
   },
   "source": [
    "Réentraîner les 16 derniers blocs avec les deux dernières couches (couche de convolution et classificateur)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 1000,
     "referenced_widgets": [
      "69494fc6ec25404aafdb3039e766ced3",
      "fd12c8734c9e4366bb43665fa565d57e",
      "556ecf641eb744929281c8b94c929da6",
      "2477092084fe428fb571e8f9968ad796",
      "d5d44796e5014f48a389ab9717f1d9fa",
      "5438b806f5c248a6ada5935522b7d4bb",
      "4f780573f05d4d1a9668ca7f80921bf2",
      "951256577b0c45dea9278149903d5343"
     ]
    },
    "id": "e2phbJ577fhQ",
    "outputId": "cece2b2a-04c6-4c60-d4d4-38266a0a6f02"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Downloading: \"https://github.com/lukemelas/EfficientNet-PyTorch/releases/download/1.0/efficientnet-b4-6ed6700e.pth\" to /root/.cache/torch/checkpoints/efficientnet-b4-6ed6700e.pth\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "69494fc6ec25404aafdb3039e766ced3",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0, max=77999237.0), HTML(value='')))"
      ]
     },
     "metadata": {
      "tags": []
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Loaded pretrained weights for efficientnet-b4\n",
      "Epoch 1/10 5071.63s Step 689/689: loss: 0.362236, bin_acc: 84.894202, val_loss: 0.273707, val_bin_acc: 87.862728\n",
      "Epoch 1: val_bin_acc improved from -inf to 87.86273, saving file to /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_c/best_epoch_1.ckpt\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.6/dist-packages/poutyne/framework/callbacks/_utils.py:24: UserWarning: Impossible to move the file to its final destination: os.replace(efficientnet_c_best_epoch.ckpt.tmp, /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_c/best_epoch_1.ckpt) -> [Errno 18] Invalid cross-device link: 'efficientnet_c_best_epoch.ckpt.tmp' -> '/content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_c/best_epoch_1.ckpt'\n",
      "  \"os.replace(%s, %s) -> %s\" % (tmp_filename, filename, e))\n",
      "/usr/local/lib/python3.6/dist-packages/poutyne/framework/callbacks/_utils.py:27: UserWarning: Saving /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_c/best_epoch_1.ckpt non-atomically instead.\n",
      "  warnings.warn('Saving %s non-atomically instead.' % filename)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 2/10 614.08s Step 689/689: loss: 0.277134, bin_acc: 88.037506, val_loss: 0.236661, val_bin_acc: 89.772787\n",
      "Epoch 2: val_bin_acc improved from 87.86273 to 89.77279, saving file to /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_c/best_epoch_2.ckpt\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.6/dist-packages/poutyne/framework/callbacks/_utils.py:24: UserWarning: Impossible to move the file to its final destination: os.replace(efficientnet_c_best_epoch.ckpt.tmp, /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_c/best_epoch_2.ckpt) -> [Errno 18] Invalid cross-device link: 'efficientnet_c_best_epoch.ckpt.tmp' -> '/content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_c/best_epoch_2.ckpt'\n",
      "  \"os.replace(%s, %s) -> %s\" % (tmp_filename, filename, e))\n",
      "/usr/local/lib/python3.6/dist-packages/poutyne/framework/callbacks/_utils.py:27: UserWarning: Saving /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_c/best_epoch_2.ckpt non-atomically instead.\n",
      "  warnings.warn('Saving %s non-atomically instead.' % filename)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 3/10 616.49s Step 689/689: loss: 0.239755, bin_acc: 89.740272, val_loss: 0.240636, val_bin_acc: 90.108622\n",
      "Epoch 3: val_bin_acc improved from 89.77279 to 90.10862, saving file to /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_c/best_epoch_3.ckpt\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.6/dist-packages/poutyne/framework/callbacks/_utils.py:24: UserWarning: Impossible to move the file to its final destination: os.replace(efficientnet_c_best_epoch.ckpt.tmp, /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_c/best_epoch_3.ckpt) -> [Errno 18] Invalid cross-device link: 'efficientnet_c_best_epoch.ckpt.tmp' -> '/content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_c/best_epoch_3.ckpt'\n",
      "  \"os.replace(%s, %s) -> %s\" % (tmp_filename, filename, e))\n",
      "/usr/local/lib/python3.6/dist-packages/poutyne/framework/callbacks/_utils.py:27: UserWarning: Saving /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_c/best_epoch_3.ckpt non-atomically instead.\n",
      "  warnings.warn('Saving %s non-atomically instead.' % filename)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 4/10 616.14s Step 689/689: loss: 0.214578, bin_acc: 90.853880, val_loss: 0.226474, val_bin_acc: 90.921971\n",
      "Epoch 4: val_bin_acc improved from 90.10862 to 90.92197, saving file to /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_c/best_epoch_4.ckpt\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.6/dist-packages/poutyne/framework/callbacks/_utils.py:24: UserWarning: Impossible to move the file to its final destination: os.replace(efficientnet_c_best_epoch.ckpt.tmp, /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_c/best_epoch_4.ckpt) -> [Errno 18] Invalid cross-device link: 'efficientnet_c_best_epoch.ckpt.tmp' -> '/content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_c/best_epoch_4.ckpt'\n",
      "  \"os.replace(%s, %s) -> %s\" % (tmp_filename, filename, e))\n",
      "/usr/local/lib/python3.6/dist-packages/poutyne/framework/callbacks/_utils.py:27: UserWarning: Saving /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_c/best_epoch_4.ckpt non-atomically instead.\n",
      "  warnings.warn('Saving %s non-atomically instead.' % filename)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 5/10 615.53s Step 689/689: loss: 0.193290, bin_acc: 91.818780, val_loss: 0.234764, val_bin_acc: 91.446712\n",
      "Epoch 5: val_bin_acc improved from 90.92197 to 91.44671, saving file to /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_c/best_epoch_5.ckpt\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.6/dist-packages/poutyne/framework/callbacks/_utils.py:24: UserWarning: Impossible to move the file to its final destination: os.replace(efficientnet_c_best_epoch.ckpt.tmp, /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_c/best_epoch_5.ckpt) -> [Errno 18] Invalid cross-device link: 'efficientnet_c_best_epoch.ckpt.tmp' -> '/content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_c/best_epoch_5.ckpt'\n",
      "  \"os.replace(%s, %s) -> %s\" % (tmp_filename, filename, e))\n",
      "/usr/local/lib/python3.6/dist-packages/poutyne/framework/callbacks/_utils.py:27: UserWarning: Saving /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_c/best_epoch_5.ckpt non-atomically instead.\n",
      "  warnings.warn('Saving %s non-atomically instead.' % filename)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 6/10 615.40s Step 689/689: loss: 0.178180, bin_acc: 92.545294, val_loss: 0.238642, val_bin_acc: 91.352259\n",
      "Epoch 7/10 614.44s Step 689/689: loss: 0.166277, bin_acc: 92.994824, val_loss: 0.293976, val_bin_acc: 90.344755\n",
      "Epoch 8/10 616.44s Step 689/689: loss: 0.152883, bin_acc: 93.613495, val_loss: 0.219817, val_bin_acc: 91.740568\n",
      "Epoch 8: val_bin_acc improved from 91.44671 to 91.74057, saving file to /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_c/best_epoch_8.ckpt\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.6/dist-packages/poutyne/framework/callbacks/_utils.py:24: UserWarning: Impossible to move the file to its final destination: os.replace(efficientnet_c_best_epoch.ckpt.tmp, /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_c/best_epoch_8.ckpt) -> [Errno 18] Invalid cross-device link: 'efficientnet_c_best_epoch.ckpt.tmp' -> '/content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_c/best_epoch_8.ckpt'\n",
      "  \"os.replace(%s, %s) -> %s\" % (tmp_filename, filename, e))\n",
      "/usr/local/lib/python3.6/dist-packages/poutyne/framework/callbacks/_utils.py:27: UserWarning: Saving /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_c/best_epoch_8.ckpt non-atomically instead.\n",
      "  warnings.warn('Saving %s non-atomically instead.' % filename)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 9/10 616.44s Step 689/689: loss: 0.146024, bin_acc: 93.954048, val_loss: 0.271148, val_bin_acc: 91.263053\n",
      "Epoch 10/10 615.56s Step 689/689: loss: 0.137405, bin_acc: 94.296871, val_loss: 0.280972, val_bin_acc: 91.320775\n",
      "Restoring model from /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_c/best_epoch_8.ckpt\n",
      "Best epoch: 8\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light",
      "tags": []
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light",
      "tags": []
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test:\n",
      "\tLoss: 0.22855989386769696\n",
      "\tAccuracy: 91.10769394327875\n"
     ]
    }
   ],
   "source": [
    "efficientnet_c = EfficientNet.from_pretrained('efficientnet-b4')\n",
    "efficientnet_c._fc = nn.Linear(efficientnet_c._conv_head.out_channels, 1)\n",
    "\n",
    "names = [name for name, _ in list(efficientnet_c.named_parameters())[-213:]]\n",
    "for name, param in efficientnet_c.named_parameters():\n",
    "  if name not in names:\n",
    "    param.requires_grad = False\n",
    "\n",
    "model_c = train(efficientnet_c, 'efficientnet_c')\n",
    "test(model_c, test_loader)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "_tQJWTsnhWtk"
   },
   "source": [
    "## Mécanisme d'attention\n",
    "\n",
    "Ajouter un mécanisme d'attention visuelle : Spatial Transformer Network (Applique une transformation spatiale sur les\n",
    "feature maps, lors du forward pass) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "WhHp-pz8qX1X"
   },
   "outputs": [],
   "source": [
    "class EfficientNetAtt(EfficientNet):\n",
    "    def __init__(self, blocks_args=None, global_params=None):\n",
    "        super().__init__(blocks_args, global_params)\n",
    "        \n",
    "    def init_spatial_transformer(self):\n",
    "        self.block_idx = 20\n",
    "        \n",
    "        # Spatial transformer localization-network\n",
    "        self.localization = nn.Sequential(\n",
    "            nn.Conv2d(160, 160, kernel_size=5),\n",
    "            nn.MaxPool2d(2, stride=2),\n",
    "            nn.ReLU(True),\n",
    "            nn.Conv2d(160, 80, kernel_size=3),\n",
    "            nn.MaxPool2d(2, stride=2),\n",
    "            nn.ReLU(True)\n",
    "        )\n",
    "        \n",
    "        # Regressor for the 3 * 2 affine matrix\n",
    "        self.fc_loc = nn.Sequential(\n",
    "            nn.Linear(80 * 1 * 1, 32),\n",
    "            nn.ReLU(True),\n",
    "            nn.Linear(32, 3 * 2)\n",
    "        )\n",
    "        \n",
    "        # Initialize the weights/bias with identity transformation\n",
    "        self.fc_loc[2].weight.data.zero_()\n",
    "        self.fc_loc[2].bias.data.copy_(torch.tensor([1, 0, 0, 0, 1, 0], \n",
    "                                                    dtype=torch.float))\n",
    "    \n",
    "    def stn(self, inputs):\n",
    "        inputs = inputs.clone()\n",
    "        xs = self.localization(inputs)\n",
    "        xs = xs.view(-1, 80 * 1 * 1)\n",
    "        theta = self.fc_loc(xs)\n",
    "        theta = theta.view(-1, 2, 3)\n",
    "\n",
    "        grid = F.affine_grid(theta, inputs.size(), align_corners=False)\n",
    "        x = F.grid_sample(inputs, grid, align_corners=False)\n",
    "\n",
    "        return x\n",
    "    \n",
    "    def extract_features(self, inputs):\n",
    "        \"\"\" Returns output of the final convolution layer \"\"\"\n",
    "\n",
    "        # Stem\n",
    "        x = self._swish(self._bn0(self._conv_stem(inputs)))\n",
    "\n",
    "        # Blocks\n",
    "        for idx, block in enumerate(self._blocks):\n",
    "            drop_connect_rate = self._global_params.drop_connect_rate\n",
    "            if drop_connect_rate:\n",
    "                drop_connect_rate *= float(idx) / len(self._blocks)\n",
    "            x = block(x, drop_connect_rate=drop_connect_rate)\n",
    "            if idx == self.block_idx:\n",
    "                x *= self.stn(x)\n",
    "\n",
    "        # Head\n",
    "        x = self._swish(self._bn1(self._conv_head(x)))\n",
    "\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 1000,
     "referenced_widgets": [
      "b7ac4ff7d8004461b9ea3b5d83cee0b1",
      "f54f6addc4494529a4f8b7274aa98117",
      "52e77c570ca1490d9912a0ddc085e810",
      "35ed6513b0024b709df00f26e9b3cea4",
      "e4aeeb499d5a443baa963a3ed489d7ae",
      "0085da15665a4a46a08eb67d95457101",
      "182db4cbdac549f8840138a5dab43d58",
      "5e4d16b0351b4c1d85b9b883c2a65a8a"
     ]
    },
    "id": "uCefQSQCiKKa",
    "outputId": "69c2662a-bdb4-48e0-e448-8f87f91ff34c"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Downloading: \"https://github.com/lukemelas/EfficientNet-PyTorch/releases/download/1.0/efficientnet-b4-6ed6700e.pth\" to /root/.cache/torch/checkpoints/efficientnet-b4-6ed6700e.pth\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b7ac4ff7d8004461b9ea3b5d83cee0b1",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0, max=77999237.0), HTML(value='')))"
      ]
     },
     "metadata": {
      "tags": []
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Loaded pretrained weights for efficientnet-b4\n",
      "Epoch 1/10 5852.08s Step 706/706: loss: 0.384056, bin_acc: 84.608992, val_loss: 0.403463, val_bin_acc: 84.205099\n",
      "Epoch 1: val_bin_acc improved from -inf to 84.20510, saving file to /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_d/best_epoch_1.ckpt\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.6/dist-packages/poutyne/framework/callbacks/_utils.py:24: UserWarning: Impossible to move the file to its final destination: os.replace(efficientnet_d_best_epoch.ckpt.tmp, /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_d/best_epoch_1.ckpt) -> [Errno 18] Invalid cross-device link: 'efficientnet_d_best_epoch.ckpt.tmp' -> '/content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_d/best_epoch_1.ckpt'\n",
      "  \"os.replace(%s, %s) -> %s\" % (tmp_filename, filename, e))\n",
      "/usr/local/lib/python3.6/dist-packages/poutyne/framework/callbacks/_utils.py:27: UserWarning: Saving /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_d/best_epoch_1.ckpt non-atomically instead.\n",
      "  warnings.warn('Saving %s non-atomically instead.' % filename)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 2/10 633.27s Step 706/706: loss: 0.314204, bin_acc: 86.405035, val_loss: 0.311365, val_bin_acc: 87.086795\n",
      "Epoch 2: val_bin_acc improved from 84.20510 to 87.08679, saving file to /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_d/best_epoch_2.ckpt\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.6/dist-packages/poutyne/framework/callbacks/_utils.py:24: UserWarning: Impossible to move the file to its final destination: os.replace(efficientnet_d_best_epoch.ckpt.tmp, /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_d/best_epoch_2.ckpt) -> [Errno 18] Invalid cross-device link: 'efficientnet_d_best_epoch.ckpt.tmp' -> '/content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_d/best_epoch_2.ckpt'\n",
      "  \"os.replace(%s, %s) -> %s\" % (tmp_filename, filename, e))\n",
      "/usr/local/lib/python3.6/dist-packages/poutyne/framework/callbacks/_utils.py:27: UserWarning: Saving /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_d/best_epoch_2.ckpt non-atomically instead.\n",
      "  warnings.warn('Saving %s non-atomically instead.' % filename)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 3/10 632.25s Step 706/706: loss: 0.284038, bin_acc: 87.751235, val_loss: 0.325952, val_bin_acc: 87.247207\n",
      "Epoch 3: val_bin_acc improved from 87.08679 to 87.24721, saving file to /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_d/best_epoch_3.ckpt\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.6/dist-packages/poutyne/framework/callbacks/_utils.py:24: UserWarning: Impossible to move the file to its final destination: os.replace(efficientnet_d_best_epoch.ckpt.tmp, /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_d/best_epoch_3.ckpt) -> [Errno 18] Invalid cross-device link: 'efficientnet_d_best_epoch.ckpt.tmp' -> '/content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_d/best_epoch_3.ckpt'\n",
      "  \"os.replace(%s, %s) -> %s\" % (tmp_filename, filename, e))\n",
      "/usr/local/lib/python3.6/dist-packages/poutyne/framework/callbacks/_utils.py:27: UserWarning: Saving /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_d/best_epoch_3.ckpt non-atomically instead.\n",
      "  warnings.warn('Saving %s non-atomically instead.' % filename)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 4/10 631.88s Step 706/706: loss: 0.260851, bin_acc: 88.802712, val_loss: 0.311571, val_bin_acc: 87.608135\n",
      "Epoch 4: val_bin_acc improved from 87.24721 to 87.60814, saving file to /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_d/best_epoch_4.ckpt\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.6/dist-packages/poutyne/framework/callbacks/_utils.py:24: UserWarning: Impossible to move the file to its final destination: os.replace(efficientnet_d_best_epoch.ckpt.tmp, /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_d/best_epoch_4.ckpt) -> [Errno 18] Invalid cross-device link: 'efficientnet_d_best_epoch.ckpt.tmp' -> '/content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_d/best_epoch_4.ckpt'\n",
      "  \"os.replace(%s, %s) -> %s\" % (tmp_filename, filename, e))\n",
      "/usr/local/lib/python3.6/dist-packages/poutyne/framework/callbacks/_utils.py:27: UserWarning: Saving /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_d/best_epoch_4.ckpt non-atomically instead.\n",
      "  warnings.warn('Saving %s non-atomically instead.' % filename)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 5/10 633.93s Step 706/706: loss: 0.243251, bin_acc: 89.582733, val_loss: 0.293710, val_bin_acc: 88.003437\n",
      "Epoch 5: val_bin_acc improved from 87.60814 to 88.00344, saving file to /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_d/best_epoch_5.ckpt\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.6/dist-packages/poutyne/framework/callbacks/_utils.py:24: UserWarning: Impossible to move the file to its final destination: os.replace(efficientnet_d_best_epoch.ckpt.tmp, /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_d/best_epoch_5.ckpt) -> [Errno 18] Invalid cross-device link: 'efficientnet_d_best_epoch.ckpt.tmp' -> '/content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_d/best_epoch_5.ckpt'\n",
      "  \"os.replace(%s, %s) -> %s\" % (tmp_filename, filename, e))\n",
      "/usr/local/lib/python3.6/dist-packages/poutyne/framework/callbacks/_utils.py:27: UserWarning: Saving /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_d/best_epoch_5.ckpt non-atomically instead.\n",
      "  warnings.warn('Saving %s non-atomically instead.' % filename)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 6/10 632.12s Step 706/706: loss: 0.230056, bin_acc: 90.226472, val_loss: 0.261978, val_bin_acc: 89.137783\n",
      "Epoch 6: val_bin_acc improved from 88.00344 to 89.13778, saving file to /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_d/best_epoch_6.ckpt\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.6/dist-packages/poutyne/framework/callbacks/_utils.py:24: UserWarning: Impossible to move the file to its final destination: os.replace(efficientnet_d_best_epoch.ckpt.tmp, /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_d/best_epoch_6.ckpt) -> [Errno 18] Invalid cross-device link: 'efficientnet_d_best_epoch.ckpt.tmp' -> '/content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_d/best_epoch_6.ckpt'\n",
      "  \"os.replace(%s, %s) -> %s\" % (tmp_filename, filename, e))\n",
      "/usr/local/lib/python3.6/dist-packages/poutyne/framework/callbacks/_utils.py:27: UserWarning: Saving /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_d/best_epoch_6.ckpt non-atomically instead.\n",
      "  warnings.warn('Saving %s non-atomically instead.' % filename)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 7/10 631.22s Step 706/706: loss: 0.215666, bin_acc: 90.851375, val_loss: 0.295542, val_bin_acc: 88.083644\n",
      "Epoch 8/10 631.10s Step 706/706: loss: 0.207273, bin_acc: 91.346644, val_loss: 0.266242, val_bin_acc: 89.504440\n",
      "Epoch 8: val_bin_acc improved from 89.13778 to 89.50444, saving file to /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_d/best_epoch_8.ckpt\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.6/dist-packages/poutyne/framework/callbacks/_utils.py:24: UserWarning: Impossible to move the file to its final destination: os.replace(efficientnet_d_best_epoch.ckpt.tmp, /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_d/best_epoch_8.ckpt) -> [Errno 18] Invalid cross-device link: 'efficientnet_d_best_epoch.ckpt.tmp' -> '/content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_d/best_epoch_8.ckpt'\n",
      "  \"os.replace(%s, %s) -> %s\" % (tmp_filename, filename, e))\n",
      "/usr/local/lib/python3.6/dist-packages/poutyne/framework/callbacks/_utils.py:27: UserWarning: Saving /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_d/best_epoch_8.ckpt non-atomically instead.\n",
      "  warnings.warn('Saving %s non-atomically instead.' % filename)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 9/10 631.74s Step 706/706: loss: 0.197298, bin_acc: 91.659095, val_loss: 0.279429, val_bin_acc: 88.433114\n",
      "Epoch 10/10 630.41s Step 706/706: loss: 0.190137, bin_acc: 92.059078, val_loss: 0.257227, val_bin_acc: 89.670581\n",
      "Epoch 10: val_bin_acc improved from 89.50444 to 89.67058, saving file to /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_d/best_epoch_10.ckpt\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.6/dist-packages/poutyne/framework/callbacks/_utils.py:24: UserWarning: Impossible to move the file to its final destination: os.replace(efficientnet_d_best_epoch.ckpt.tmp, /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_d/best_epoch_10.ckpt) -> [Errno 18] Invalid cross-device link: 'efficientnet_d_best_epoch.ckpt.tmp' -> '/content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_d/best_epoch_10.ckpt'\n",
      "  \"os.replace(%s, %s) -> %s\" % (tmp_filename, filename, e))\n",
      "/usr/local/lib/python3.6/dist-packages/poutyne/framework/callbacks/_utils.py:27: UserWarning: Saving /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_d/best_epoch_10.ckpt non-atomically instead.\n",
      "  warnings.warn('Saving %s non-atomically instead.' % filename)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Restoring model from /content/gdrive/My Drive/Colab Notebooks/deepfake/models/efficientnet_d/best_epoch_10.ckpt\n",
      "Best epoch: 10\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light",
      "tags": []
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light",
      "tags": []
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test:\n",
      "\tLoss: 0.2243810468241617\n",
      "\tAccuracy: 91.07055030350372\n"
     ]
    }
   ],
   "source": [
    "efficientnet_d = EfficientNetAtt.from_pretrained('efficientnet-b4')\n",
    "efficientnet_d._fc = nn.Linear(efficientnet_d._conv_head.out_channels, 1)\n",
    "efficientnet_d.init_spatial_transformer()\n",
    "\n",
    "names = [name for name, _ in list(efficientnet_d.named_parameters())[-221:]]\n",
    "for name, param in efficientnet_d.named_parameters():\n",
    "  if name not in names:\n",
    "    param.requires_grad = False\n",
    "\n",
    "model_d = train(efficientnet_d, 'efficientnet_d')\n",
    "test(model_d, test_loader)"
   ]
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "machine_shape": "hm",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.4"
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "0085da15665a4a46a08eb67d95457101": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "070eb8acf3da4a90b422357a557c02de": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HBoxModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HBoxModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HBoxView",
      "box_style": "",
      "children": [
       "IPY_MODEL_be1a54c2a1584186aad0ccb38ce488e6",
       "IPY_MODEL_d1e20ce9d6334d43bdca7187103ba40b"
      ],
      "layout": "IPY_MODEL_a97360270ec9405185501d1d5d1dcb49"
     }
    },
    "14f55ce43863405ab8adbe64cbbc86fb": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "182db4cbdac549f8840138a5dab43d58": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "1b7d182d4e714faea9e3f810e5432408": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "ProgressStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "ProgressStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "bar_color": null,
      "description_width": "initial"
     }
    },
    "2477092084fe428fb571e8f9968ad796": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_951256577b0c45dea9278149903d5343",
      "placeholder": "​",
      "style": "IPY_MODEL_4f780573f05d4d1a9668ca7f80921bf2",
      "value": " 74.4M/74.4M [00:05&lt;00:00, 13.7MB/s]"
     }
    },
    "35ed6513b0024b709df00f26e9b3cea4": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_5e4d16b0351b4c1d85b9b883c2a65a8a",
      "placeholder": "​",
      "style": "IPY_MODEL_182db4cbdac549f8840138a5dab43d58",
      "value": " 74.4M/74.4M [00:05&lt;00:00, 13.2MB/s]"
     }
    },
    "4f780573f05d4d1a9668ca7f80921bf2": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "52e77c570ca1490d9912a0ddc085e810": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "FloatProgressModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "FloatProgressModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "ProgressView",
      "bar_style": "success",
      "description": "100%",
      "description_tooltip": null,
      "layout": "IPY_MODEL_0085da15665a4a46a08eb67d95457101",
      "max": 77999237,
      "min": 0,
      "orientation": "horizontal",
      "style": "IPY_MODEL_e4aeeb499d5a443baa963a3ed489d7ae",
      "value": 77999237
     }
    },
    "5438b806f5c248a6ada5935522b7d4bb": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "556ecf641eb744929281c8b94c929da6": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "FloatProgressModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "FloatProgressModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "ProgressView",
      "bar_style": "success",
      "description": "100%",
      "description_tooltip": null,
      "layout": "IPY_MODEL_5438b806f5c248a6ada5935522b7d4bb",
      "max": 77999237,
      "min": 0,
      "orientation": "horizontal",
      "style": "IPY_MODEL_d5d44796e5014f48a389ab9717f1d9fa",
      "value": 77999237
     }
    },
    "5e4d16b0351b4c1d85b9b883c2a65a8a": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "69494fc6ec25404aafdb3039e766ced3": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HBoxModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HBoxModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HBoxView",
      "box_style": "",
      "children": [
       "IPY_MODEL_556ecf641eb744929281c8b94c929da6",
       "IPY_MODEL_2477092084fe428fb571e8f9968ad796"
      ],
      "layout": "IPY_MODEL_fd12c8734c9e4366bb43665fa565d57e"
     }
    },
    "951256577b0c45dea9278149903d5343": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "a97360270ec9405185501d1d5d1dcb49": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "b7ac4ff7d8004461b9ea3b5d83cee0b1": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HBoxModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HBoxModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HBoxView",
      "box_style": "",
      "children": [
       "IPY_MODEL_52e77c570ca1490d9912a0ddc085e810",
       "IPY_MODEL_35ed6513b0024b709df00f26e9b3cea4"
      ],
      "layout": "IPY_MODEL_f54f6addc4494529a4f8b7274aa98117"
     }
    },
    "be1a54c2a1584186aad0ccb38ce488e6": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "FloatProgressModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "FloatProgressModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "ProgressView",
      "bar_style": "success",
      "description": "100%",
      "description_tooltip": null,
      "layout": "IPY_MODEL_14f55ce43863405ab8adbe64cbbc86fb",
      "max": 77999237,
      "min": 0,
      "orientation": "horizontal",
      "style": "IPY_MODEL_1b7d182d4e714faea9e3f810e5432408",
      "value": 77999237
     }
    },
    "d1e20ce9d6334d43bdca7187103ba40b": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_d3c6935c60c84e2a857ac0040d837288",
      "placeholder": "​",
      "style": "IPY_MODEL_e58c63dc8ef649afb481b3f92aafd1fd",
      "value": " 74.4M/74.4M [00:00&lt;00:00, 102MB/s]"
     }
    },
    "d3c6935c60c84e2a857ac0040d837288": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "d5d44796e5014f48a389ab9717f1d9fa": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "ProgressStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "ProgressStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "bar_color": null,
      "description_width": "initial"
     }
    },
    "e4aeeb499d5a443baa963a3ed489d7ae": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "ProgressStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "ProgressStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "bar_color": null,
      "description_width": "initial"
     }
    },
    "e58c63dc8ef649afb481b3f92aafd1fd": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "f54f6addc4494529a4f8b7274aa98117": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "fd12c8734c9e4366bb43665fa565d57e": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    }
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}