09-echo_data.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Traduction en français du notebook *09* du cours ***Deep Learning*** d'Alfredo Canziani, professeur assistant à la *New York University* : \n",
    "https://github.com/Atcold/pytorch-Deep-Learning/blob/master/09-echo_data.ipynb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Echo du signal\n",
    "\n",
    "L'écho des signaux `n` étapes est un exemple de tâche synchronisée many-to-many (plusieurs à plusieurs)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from res.sequential_tasks import EchoData\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "# import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "\n",
    "torch.manual_seed(1);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_size = 5\n",
    "echo_step = 3\n",
    "series_length = 20_000\n",
    "BPTT_T = 20\n",
    "\n",
    "train_data = EchoData(\n",
    "    echo_step=echo_step,\n",
    "    batch_size=batch_size,\n",
    "    series_length=series_length,\n",
    "    truncated_length=BPTT_T,\n",
    ")\n",
    "train_size = len(train_data)\n",
    "\n",
    "test_data = EchoData(\n",
    "    echo_step=echo_step,\n",
    "    batch_size=batch_size,\n",
    "    series_length=series_length,\n",
    "    truncated_length=BPTT_T,\n",
    ")\n",
    "test_size = len(test_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Premiere sequence d entrée)  x: 0 0 1 1 0 0 0 1 0 0 0 1 1 0 0 0 0 1 1 1 ... \n",
      "(Premiere sequence cible) y: 0 0 0 0 0 1 1 0 0 0 1 0 0 0 1 1 0 0 0 0 ... \n"
     ]
    }
   ],
   "source": [
    "# Affichons les 20 premiers pas des premières séquences pour voir les données d'écho :\n",
    "print('(Premiere sequence d entrée)  x:', *train_data.x_batch[0, :20], '... ')\n",
    "print('(Premiere sequence cible) y:', *train_data.y_batch[0, :20], '... ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_batch:\n",
      "0 0 1 1 0 0 0 1 0 0 0 1 1 0 0 0 0 1 1 1 ...\n",
      "1 0 1 0 1 1 1 1 1 0 0 0 1 0 1 1 1 1 0 0 ...\n",
      "0 1 1 0 1 0 0 0 1 1 1 1 0 0 1 0 1 0 0 0 ...\n",
      "1 0 0 0 1 1 1 1 0 0 1 0 0 1 1 0 1 0 1 0 ...\n",
      "0 0 1 0 0 0 0 0 0 1 0 1 1 0 0 0 0 1 0 1 ...\n",
      "x_batch de taille: (5, 20000)\n",
      "\n",
      "y_batch:\n",
      "0 0 0 0 0 1 1 0 0 0 1 0 0 0 1 1 0 0 0 0 ...\n",
      "0 0 0 1 0 1 0 1 1 1 1 1 0 0 0 1 0 1 1 1 ...\n",
      "0 0 0 0 1 1 0 1 0 0 0 1 1 1 1 0 0 1 0 1 ...\n",
      "0 0 0 1 0 0 0 1 1 1 1 0 0 1 0 0 1 1 0 1 ...\n",
      "0 0 0 0 0 1 0 0 0 0 0 0 1 0 1 1 0 0 0 0 ...\n",
      "y_batch de taille: (5, 20000)\n"
     ]
    }
   ],
   "source": [
    "# des séquences différentes de batch_size sont créées :\n",
    "print('x_batch:', *(str(d)[1:-1] + ' ...' for d in train_data.x_batch[:, :20]), sep='\\n')\n",
    "print('x_batch de taille:', train_data.x_batch.shape)\n",
    "print()\n",
    "print('y_batch:', *(str(d)[1:-1] + ' ...' for d in train_data.y_batch[:, :20]), sep='\\n')\n",
    "print('y_batch de taille:', train_data.y_batch.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_chunk:\n",
      "[0 0 1 1 0 0 0 1 0 0 0 1 1 0 0 0 0 1 1 1]\n",
      "[1 0 1 0 1 1 1 1 1 0 0 0 1 0 1 1 1 1 0 0]\n",
      "[0 1 1 0 1 0 0 0 1 1 1 1 0 0 1 0 1 0 0 0]\n",
      "[1 0 0 0 1 1 1 1 0 0 1 0 0 1 1 0 1 0 1 0]\n",
      "[0 0 1 0 0 0 0 0 0 1 0 1 1 0 0 0 0 1 0 1]\n",
      "Premier x_chunk de taille: (5, 20, 1)\n",
      "\n",
      "y_chunk:\n",
      "[0 0 0 0 0 1 1 0 0 0 1 0 0 0 1 1 0 0 0 0]\n",
      "[0 0 0 1 0 1 0 1 1 1 1 1 0 0 0 1 0 1 1 1]\n",
      "[0 0 0 0 1 1 0 1 0 0 0 1 1 1 1 0 0 1 0 1]\n",
      "[0 0 0 1 0 0 0 1 1 1 1 0 0 1 0 0 1 1 0 1]\n",
      "[0 0 0 0 0 1 0 0 0 0 0 0 1 0 1 1 0 0 0 0]\n",
      "Premier y_chunk de taille: (5, 20, 1)\n"
     ]
    }
   ],
   "source": [
    "# Pour utiliser les RNN, les données sont organisées en\n",
    "# morceaux de taille [batch_size, T, feature_dim]\n",
    "print('x_chunk:', *train_data.x_chunks[0].squeeze(), sep='\\n')\n",
    "print('Premier x_chunk de taille:', train_data.x_chunks[0].shape)\n",
    "print()\n",
    "print('y_chunk:', *train_data.y_chunks[0].squeeze(), sep='\\n')\n",
    "print('Premier y_chunk de taille:', train_data.y_chunks[0].shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class SimpleRNN(nn.Module):\n",
    "    def __init__(self, input_size, rnn_hidden_size, output_size):\n",
    "        super().__init__()\n",
    "        self.rnn_hidden_size = rnn_hidden_size\n",
    "        self.rnn = torch.nn.RNN(\n",
    "            input_size=input_size,\n",
    "            hidden_size=rnn_hidden_size,\n",
    "            num_layers=1,\n",
    "            nonlinearity='relu',\n",
    "            batch_first=True\n",
    "        )\n",
    "        self.linear = torch.nn.Linear(\n",
    "            in_features=rnn_hidden_size,\n",
    "            out_features=1\n",
    "        )\n",
    "\n",
    "    def forward(self, x, hidden):\n",
    "        x, hidden = self.rnn(x, hidden)  \n",
    "        x = self.linear(x)\n",
    "        return x, hidden"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(hidden):\n",
    "    model.train()\n",
    "       \n",
    "    correct = 0\n",
    "    for batch_idx in range(train_size):\n",
    "        data, target = train_data[batch_idx]\n",
    "        data, target = torch.from_numpy(data).float().to(device), torch.from_numpy(target).float().to(device)\n",
    "        optimizer.zero_grad()\n",
    "        if hidden is not None: hidden.detach_()\n",
    "        logits, hidden = model(data, hidden)\n",
    "        loss = criterion(logits, target)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        \n",
    "        pred = (torch.sigmoid(logits) > 0.5)\n",
    "        correct += (pred == target.byte()).int().sum().item()\n",
    "        \n",
    "    return correct, loss.item(), hidden"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def test(hidden):\n",
    "    model.eval()   \n",
    "    correct = 0\n",
    "    with torch.no_grad():\n",
    "        for batch_idx in range(test_size):\n",
    "            data, target = test_data[batch_idx]\n",
    "            data, target = torch.from_numpy(data).float().to(device), torch.from_numpy(target).float().to(device)\n",
    "            logits, hidden = model(data, hidden)\n",
    "            \n",
    "            pred = (torch.sigmoid(logits) > 0.5)\n",
    "            correct += (pred == target.byte()).int().sum().item()\n",
    "\n",
    "    return correct"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "feature_dim = 1 #puisque nous avons une série scalaire\n",
    "h_units = 4\n",
    "\n",
    "model = SimpleRNN(\n",
    "    input_size=1,\n",
    "    rnn_hidden_size=h_units,\n",
    "    output_size=feature_dim\n",
    ").to(device)\n",
    "hidden = None\n",
    "        \n",
    "criterion = torch.nn.BCEWithLogitsLoss()\n",
    "optimizer = torch.optim.RMSprop(model.parameters(), lr=0.001)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Epoch: 1/5, loss: 0.538, accuracy 59.5%\n",
      "Train Epoch: 2/5, loss: 0.082, accuracy 87.1%\n",
      "Train Epoch: 3/5, loss: 0.001, accuracy 100.0%\n",
      "Train Epoch: 4/5, loss: 0.000, accuracy 100.0%\n",
      "Train Epoch: 5/5, loss: 0.000, accuracy 100.0%\n",
      "Test accuracy: 100.0%\n"
     ]
    }
   ],
   "source": [
    "n_epochs = 5\n",
    "epoch = 0\n",
    "\n",
    "while epoch < n_epochs:\n",
    "    correct, loss, hidden = train(hidden)\n",
    "    epoch += 1\n",
    "    train_accuracy = float(correct) / train_size\n",
    "    print(f'Train Epoch: {epoch}/{n_epochs}, loss: {loss:.3f}, accuracy {train_accuracy:.1f}%')\n",
    "\n",
    "#test    \n",
    "correct = test(hidden)\n",
    "test_accuracy = float(correct) / test_size\n",
    "print(f'Test accuracy: {test_accuracy:.1f}%')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 1, 1, 1,\n",
      "         0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 1,\n",
      "         0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 0,\n",
      "         0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0,\n",
      "         1, 1, 0, 0]], dtype=torch.uint8)\n",
      "tensor([[ True,  True, False, False,  True,  True,  True,  True, False, False,\n",
      "          True,  True,  True,  True,  True,  True, False,  True,  True, False,\n",
      "         False,  True, False, False,  True,  True,  True, False,  True, False,\n",
      "         False,  True,  True, False,  True,  True,  True,  True, False, False,\n",
      "          True,  True, False, False, False, False,  True,  True,  True, False,\n",
      "          True, False, False,  True,  True, False,  True,  True, False,  True,\n",
      "         False, False,  True,  True,  True, False,  True,  True, False,  True,\n",
      "          True,  True,  True, False, False, False, False, False,  True,  True,\n",
      "          True,  True,  True,  True,  True, False, False, False, False, False,\n",
      "         False,  True,  True,  True,  True,  True,  True, False, False,  True]])\n"
     ]
    }
   ],
   "source": [
    "# Essayons un peu d'écho\n",
    "my_input = torch.empty(1, 100, 1).random_(2).to(device)\n",
    "hidden = None\n",
    "my_out, _ = model(my_input, hidden)\n",
    "print(my_input.view(1, -1).byte(), (my_out > 0).view(1, -1), sep='\\n')"
   ]
  }
 ],
 "metadata": {
  "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.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}