Entrainement d'un modèle de Machine Learning.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Entrainer un réseau en le modifiant pour une tâche spécifique"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Utiliser notre jeu de données dans PyTorch\n",
    "\n",
    "Tout se fait très rapidement avec la classe `ImageFolder`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from multiprocessing import cpu_count\n",
    "from os.path import join\n",
    "from tempfile import NamedTemporaryFile\n",
    "\n",
    "from IPython.core.display import Image, display\n",
    "from torch.utils.data import DataLoader\n",
    "from torchvision.datasets import ImageFolder\n",
    "import torchvision.transforms as transforms\n",
    "from torchvision.utils import save_image\n",
    "\n",
    "BATCH_SIZE = 8\n",
    "NUM_WORKERS = cpu_count()\n",
    "\n",
    "# Data loading code\n",
    "traindir = join(\"pics\", \"train\")\n",
    "valdir = join(\"pics\", \"val\")\n",
    "\n",
    "normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],\n",
    "                                 std=[0.229, 0.224, 0.225])\n",
    "\n",
    "train_dataset = ImageFolder(traindir, transforms.Compose([\n",
    "    transforms.Resize((256, 256)),\n",
    "    # Get some data for free\n",
    "    transforms.RandomCrop((224, 224)),\n",
    "    transforms.RandomHorizontalFlip(),\n",
    "    transforms.ToTensor(),\n",
    "    normalize,\n",
    "]))\n",
    "eval_dataset = ImageFolder(valdir, transforms.Compose([\n",
    "    transforms.Resize((256, 256)),\n",
    "    transforms.CenterCrop((224, 224)),\n",
    "    transforms.ToTensor(),\n",
    "    normalize,\n",
    "]))\n",
    "\n",
    "train_dataloader = DataLoader(\n",
    "    train_dataset, batch_size = BATCH_SIZE, shuffle=True,\n",
    "    num_workers=NUM_WORKERS)\n",
    "eval_dataloader = DataLoader(\n",
    "    eval_dataset, batch_size = BATCH_SIZE, shuffle=False,\n",
    "    num_workers=NUM_WORKERS)\n",
    "\n",
    "with NamedTemporaryFile(suffix=\".png\") as fh:\n",
    "    save_image(train_dataset[0][0], fh.name)\n",
    "    print(\"Example input:\")\n",
    "    display(Image(fh.name))\n",
    "print(\"Example target: %d\" % train_dataset[0][1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Récupérer un modèle et l'adapter\n",
    "\n",
    "PyTorch dispose de quelques modèles pré-entrainés sur Imagenet qui sont très utiles pour faire de petites applis pour traiter des images. On va voir ici comment les adapter à une tâche différente de celle sur laquelle ils ont été entrainés."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from torch.nn import Linear\n",
    "from torchvision.models import resnet50\n",
    "\n",
    "model = resnet50(pretrained=True)\n",
    "for child in model.children():\n",
    "    for param in child.parameters():\n",
    "        param.requires_grad = False\n",
    "\n",
    "print(\"Couche finale, avant : %s\" % model.fc)\n",
    "\n",
    "model.fc = Linear(in_features=2048, out_features=2, bias=True)\n",
    "\n",
    "print(\"Couche finale, après : %s\" % model.fc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Fonction de perte et optimisation des poids\n",
    "\n",
    "On définit une fonction de perte (pour savoir si nos prédictions sont bonnes ou non) et un optimisateur qui va décider comment changer les poids de notre réseau en fonction de l'erreur commise pour des exemples donnés."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from torch.nn import CrossEntropyLoss\n",
    "from torch.optim import Adam\n",
    "\n",
    "criterion = CrossEntropyLoss()\n",
    "\n",
    "optimizer = Adam(model.parameters())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Entrainement\n",
    "\n",
    "On peut maintenant entrainer notre réseau \\o/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "import torch\n",
    "from tqdm import tqdm\n",
    "\n",
    "for epoch in range(1, 11):\n",
    "    print(\"***\")\n",
    "    print(\"Training on complete training data\", flush=True)\n",
    "    model.train()\n",
    "    for image, label in tqdm(train_dataloader):\n",
    "        output = model.forward(image)\n",
    "        loss = criterion(output, label)\n",
    "        optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "\n",
    "    print(\"Evaluating on complete evaluation data\", flush=True)\n",
    "    total_correct = 0\n",
    "    total = 0\n",
    "    model.eval()\n",
    "    for image, label in tqdm(eval_dataloader):\n",
    "        output = model.forward(image)\n",
    "        total_correct += (output.argmax(dim=1) == label).sum().item()\n",
    "        total += output.size(0)\n",
    "    print(\"Accuraccy at epoch %d: %.2f\" % (epoch, total_correct / total), flush=True)\n",
    "torch.save(model.state_dict(), \"model.pth\")"
   ]
  }
 ],
 "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}