DroneDetector/train_scripts/Training_models_915-Copy1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "5a13ad6b-56c9-4381-b376-1765f6dd7553",
   "metadata": {
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "# Импортирование библиотек"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "7311cb4a-5bf3-4268-b431-43eea10e9ed6",
   "metadata": {
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cuda\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "from torch import default_generator, randperm\n",
    "from torch.utils.data.dataset import Subset\n",
    "import torchvision.transforms as transforms\n",
    "from torchvision.io import read_image\n",
    "from importlib import import_module\n",
    "import matplotlib.pyplot as plt\n",
    "from torchvision import models\n",
    "import torch, torchvision\n",
    "from pathlib import Path\n",
    "from PIL import Image\n",
    "import torch.nn as nn\n",
    "from tqdm import tqdm\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib\n",
    "import os, shutil\n",
    "import mlconfig\n",
    "import random\n",
    "import shutil\n",
    "import timeit\n",
    "import copy\n",
    "import time\n",
    "import cv2\n",
    "import csv\n",
    "import sys\n",
    "import io\n",
    "import gc\n",
    "\n",
    "plt.rcParams[\"savefig.bbox\"] = 'tight'\n",
    "torch.manual_seed(1)\n",
    "#matplotlib.use('Agg')\n",
    "device = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
    "print(device)\n",
    "torch.cuda.empty_cache()\n",
    "cv2.destroyAllWindows()\n",
    "gc.collect()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "384de097-82c6-41f5-bda9-b2f54bc99593",
   "metadata": {
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "# Подготовка и обучение детектирование"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "46e4dc99-6994-4fee-a32e-f3983bd991bd",
   "metadata": {},
   "outputs": [],
   "source": [
    "def prepare_and_learning_detection(num_classes, num_samples, path_dataset, model_name, config_name, model):\n",
    "    num_samples_per_class = num_samples // num_classes\n",
    "\n",
    "    #----------Создаём папку для сохранения результатов обучения--------------\n",
    "    \n",
    "    ind = 1\n",
    "    while True:\n",
    "        if os.path.exists(\"models/\" + model_name + str(ind)):\n",
    "            ind += 1\n",
    "        else:\n",
    "            os.mkdir(\"models/\" + model_name + str(ind))\n",
    "            path_res = \"models/\" + model_name + str(ind) + '/'\n",
    "            break\n",
    "    \n",
    "    #----------Создаём файл dataset.csv для обучения--------------\n",
    "    \n",
    "    pd_columns = ['file_name']\n",
    "    df = pd.DataFrame(columns=pd_columns)\n",
    "    \n",
    "    subdirs = os.listdir(path_dataset)\n",
    "    for subdir in subdirs:\n",
    "        files = os.listdir(path_dataset + subdir + '/')\n",
    "        num_samples_per_class = min(num_samples_per_class, len(files))\n",
    "    for subdir in subdirs:\n",
    "        files = os.listdir(path_dataset + subdir + '/')\n",
    "        random.shuffle(files)\n",
    "        files_to_process = files[:num_samples_per_class]\n",
    "        for file in files_to_process:\n",
    "            row = pd.DataFrame({pd_columns[0]: [str(path_dataset + subdir + '/' + file)]})\n",
    "            df = pd.concat([df, row], ignore_index=True)\n",
    "    \n",
    "    df.to_csv(path_res + 'dataset.csv', index=False)\n",
    "    \n",
    "    #----------Импортируем параметры для обучения--------------\n",
    "    \n",
    "    def load_function(attr):\n",
    "        module_, func = attr.rsplit('.', maxsplit=1)\n",
    "        return getattr(import_module(module_), func)\n",
    "    \n",
    "    config = mlconfig.load('config_' + config_name + '.yaml')\n",
    "    \n",
    "    #----------Создаём класс датасета--------------\n",
    "    \n",
    "    class MyDataset(Dataset):\n",
    "        def __init__(self, path_dataset, csv_file):\n",
    "            data=[]\n",
    "            with open(path_dataset + csv_file, newline='') as csvfile:\n",
    "                reader = csv.reader(csvfile, delimiter=' ', quotechar='|')\n",
    "                for row in list(reader)[1:]:\n",
    "                    row = str(row)\n",
    "                    data.append(row[2: len(row)-2])\n",
    "            self.sig_filenames = data\n",
    "            self.path_dataset = path_dataset\n",
    "    \n",
    "        def __len__(self):\n",
    "            return len(self.sig_filenames)\n",
    "    \n",
    "        def __getitem__(self, idx):\n",
    "            image_real = np.asarray(cv2.split(cv2.imread(self.sig_filenames[idx][:-8]+'real.jpg')), dtype=np.float32)\n",
    "            if 'drone' in list(self.sig_filenames[idx].split('/')):\n",
    "                label = torch.tensor(0)\n",
    "            if 'noise' in list(self.sig_filenames[idx].split('/')):\n",
    "                label = torch.tensor(1)\n",
    "            return image_real, label\n",
    "    \n",
    "    #----------Создаём датасет--------------\n",
    "    \n",
    "    dataset = MyDataset(path_dataset=path_res, csv_file='dataset.csv')\n",
    "    train_set, valid_set = torch.utils.data.random_split(dataset, [0.7, 0.3], generator=torch.Generator().manual_seed(42))\n",
    "    batch_size = config.batch_size\n",
    "    train_dataloader = torch.utils.data.DataLoader(train_set, batch_size=batch_size, shuffle=True, drop_last=True)\n",
    "    valid_dataloader = torch.utils.data.DataLoader(valid_set, batch_size=batch_size, shuffle=True, drop_last=True)\n",
    "    \n",
    "    dataloaders = {}\n",
    "    dataloaders['train'] = train_dataloader\n",
    "    dataloaders['val'] = valid_dataloader\n",
    "    dataset_sizes = {}\n",
    "    dataset_sizes['train'] = len(train_set)\n",
    "    dataset_sizes['val'] = len(valid_set)\n",
    "\n",
    "    #----------Обучаем модель--------------\n",
    "\n",
    "    val_loss = []\n",
    "    val_acc = []\n",
    "    train_loss = []\n",
    "    train_acc = []\n",
    "    epochs = config.epoch\n",
    "    \n",
    "    best_acc = 0.0\n",
    "    best_model = copy.deepcopy(model.state_dict())\n",
    "    limit = config.limit\n",
    "    epoch_limit = epochs\n",
    "    \n",
    "    start = timeit.default_timer()\n",
    "    for epoch in range(1, epochs+1):\n",
    "        print(f\"Epoch : {epoch}\\n\")\n",
    "        dataloader = None\n",
    "    \n",
    "        for phase in ['train', 'val']:\n",
    "            running_loss = 0.0\n",
    "            running_corrects = 0\n",
    "    \n",
    "            for (img, label) in tqdm(dataloaders[phase]):\n",
    "                img, label = img.to(device), label.to(device)\n",
    "                optimizer.zero_grad()\n",
    "    \n",
    "                with torch.set_grad_enabled(phase == 'train'):\n",
    "                    output = model(img)\n",
    "                    _, pred = torch.max(output.data, 1)\n",
    "                    loss = criterion(output, label)\n",
    "                    if phase=='train' :\n",
    "                        loss.backward()\n",
    "                        optimizer.step()\n",
    "                \n",
    "                running_loss += loss.item() * img.size(0)\n",
    "                running_corrects += torch.sum(pred == label.data)\n",
    "    \n",
    "            epoch_loss = running_loss / dataset_sizes[phase]\n",
    "            epoch_acc = running_corrects.double() / dataset_sizes[phase]\n",
    "                \n",
    "            print('{} Loss: {:.4f} Acc: {:.4f}'.format(phase, epoch_loss, epoch_acc))\n",
    "                    \n",
    "            if phase=='train' :\n",
    "                train_loss.append(epoch_loss)\n",
    "                train_acc.append(epoch_acc)\n",
    "            else :\n",
    "                val_loss.append(epoch_loss)\n",
    "                val_acc.append(epoch_acc)\n",
    "                if val_acc[-1] > best_acc :\n",
    "                    ind_limit = 0\n",
    "                    best_acc = val_acc[-1]\n",
    "                    best_model = copy.deepcopy(model.state_dict())\n",
    "                    torch.save(best_model, path_res + model_name + '.pth')\n",
    "                else:\n",
    "                    ind_limit += 1\n",
    "                    \n",
    "                if ind_limit >= limit:\n",
    "                    break\n",
    "                \n",
    "        if ind_limit >= limit:\n",
    "            epoch_limit = epoch\n",
    "            break\n",
    "            \n",
    "        print()\n",
    "    \n",
    "    end = timeit.default_timer()\n",
    "    print(f\"Total time elapsed = {end - start} seconds\")\n",
    "    epoch_limit += 1\n",
    "    \n",
    "    #----------Вывод графиков и сохранение результатов обучения--------------\n",
    "    \n",
    "    train_acc = np.asarray(list(map(lambda x: x.item(), train_acc)))\n",
    "    val_acc = np.asarray(list(map(lambda x: x.item(), val_acc)))\n",
    "    \n",
    "    np.save(path_res+'train_acc.npy', train_acc)\n",
    "    np.save(path_res+'val_acc.npy', val_acc)\n",
    "    np.save(path_res+'train_loss.npy', train_loss)\n",
    "    np.save(path_res+'val_loss.npy', val_loss)\n",
    "    \n",
    "    plt.figure()\n",
    "    plt.plot(range(1,epoch_limit), train_loss, color='blue')\n",
    "    plt.plot(range(1,epoch_limit), val_loss, color='red')\n",
    "    plt.xlabel('Epoch')\n",
    "    plt.ylabel('Loss')\n",
    "    plt.title('Loss Curve')\n",
    "    plt.legend(['Train Loss', 'Validation Loss'])\n",
    "    plt.show()\n",
    "    plt.clf()\n",
    "    plt.cla()\n",
    "    plt.close()\n",
    "    \n",
    "    plt.figure()\n",
    "    plt.plot(range(1,epoch_limit), train_acc, color='blue')\n",
    "    plt.plot(range(1,epoch_limit), val_acc, color='red')\n",
    "    plt.xlabel('Epoch')\n",
    "    plt.ylabel('Accuracy')\n",
    "    plt.title('Accuracy Curve')\n",
    "    plt.legend(['Train Accuracy', 'Validation Accuracy'])\n",
    "    plt.show()\n",
    "    \n",
    "    plt.clf()\n",
    "    plt.cla()\n",
    "    plt.close()\n",
    "    torch.cuda.empty_cache()\n",
    "    cv2.destroyAllWindows()\n",
    "    del model\n",
    "    gc.collect()\n",
    "\n",
    "    return path_res, model_name"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "93c136ee",
   "metadata": {},
   "source": [
    "### Ensemble"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "52e8d4c5",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\snytk\\miniconda3\\envs\\python311\\Lib\\site-packages\\torchvision\\models\\_utils.py:208: UserWarning: The parameter 'pretrained' is deprecated since 0.13 and may be removed in the future, please use 'weights' instead.\n",
      "  warnings.warn(\n",
      "C:\\Users\\snytk\\miniconda3\\envs\\python311\\Lib\\site-packages\\torchvision\\models\\_utils.py:223: UserWarning: Arguments other than a weight enum or `None` for 'weights' are deprecated since 0.13 and may be removed in the future. The current behavior is equivalent to passing `weights=ResNet18_Weights.IMAGENET1K_V1`. You can also use `weights=ResNet18_Weights.DEFAULT` to get the most up-to-date weights.\n",
      "  warnings.warn(msg)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch : 1\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████████| 658/658 [01:56<00:00,  5.63it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train Loss: 0.1856 Acc: 0.9362\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████████| 282/282 [00:35<00:00,  8.03it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "val Loss: 0.0901 Acc: 0.9654\n",
      "\n",
      "Epoch : 2\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████████| 658/658 [01:50<00:00,  5.95it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train Loss: 0.1103 Acc: 0.9556\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████████| 282/282 [00:36<00:00,  7.63it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "val Loss: 0.1421 Acc: 0.9211\n",
      "\n",
      "Epoch : 3\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████████| 658/658 [01:40<00:00,  6.57it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train Loss: 0.0895 Acc: 0.9636\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████████| 282/282 [00:32<00:00,  8.76it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "val Loss: 0.1153 Acc: 0.9610\n",
      "\n",
      "Epoch : 4\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████████| 658/658 [01:42<00:00,  6.45it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train Loss: 0.0745 Acc: 0.9704\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████████| 282/282 [00:36<00:00,  7.81it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "val Loss: 0.1168 Acc: 0.9610\n",
      "\n",
      "Epoch : 5\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████████| 658/658 [01:47<00:00,  6.10it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train Loss: 0.0599 Acc: 0.9776\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████████| 282/282 [00:34<00:00,  8.27it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "val Loss: 0.0316 Acc: 0.9902\n",
      "\n",
      "Epoch : 6\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████████| 658/658 [01:46<00:00,  6.16it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train Loss: 0.0383 Acc: 0.9856\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████████| 282/282 [00:35<00:00,  8.04it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "val Loss: 0.0240 Acc: 0.9929\n",
      "\n",
      "Epoch : 7\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████████| 658/658 [01:49<00:00,  6.01it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train Loss: 0.0185 Acc: 0.9932\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████████| 282/282 [00:33<00:00,  8.31it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "val Loss: 0.0139 Acc: 0.9956\n",
      "\n",
      "Epoch : 8\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████████| 658/658 [01:48<00:00,  6.09it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train Loss: 0.0272 Acc: 0.9905\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████████| 282/282 [00:36<00:00,  7.82it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "val Loss: 0.0361 Acc: 0.9876\n",
      "\n",
      "Epoch : 9\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████████| 658/658 [01:46<00:00,  6.16it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train Loss: 0.0194 Acc: 0.9947\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████████| 282/282 [00:38<00:00,  7.37it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "val Loss: 0.0092 Acc: 0.9973\n",
      "\n",
      "Epoch : 10\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████████| 658/658 [01:49<00:00,  6.01it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train Loss: 0.0156 Acc: 0.9935\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████████| 282/282 [00:34<00:00,  8.16it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "val Loss: 0.0283 Acc: 0.9894\n",
      "\n",
      "Total time elapsed = 1432.5218361000007 seconds\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "67"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#----------Инициализируем модель и параметры обучения--------------\n",
    "\n",
    "torch.cuda.empty_cache()\n",
    "cv2.destroyAllWindows()\n",
    "gc.collect()\n",
    "\n",
    "config_name = \"ensemble\"\n",
    "    \n",
    "def load_function(attr):\n",
    "    module_, func = attr.rsplit('.', maxsplit=1)\n",
    "    return getattr(import_module(module_), func)\n",
    "    \n",
    "config = mlconfig.load('config_' + config_name + '.yaml')\n",
    "\n",
    "model = models.resnet18(pretrained=True)\n",
    "\n",
    "num_classes = 2\n",
    "\n",
    "model.fc = nn.Linear(model.fc.in_features, num_classes)\n",
    "\n",
    "class Model(nn.Module):\n",
    "    def __init__(self, model):\n",
    "        super(Model, self).__init__()\n",
    "        self.model = model\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.model(x)\n",
    "        return x\n",
    "\n",
    "model = Model(model)\n",
    "\n",
    "optimizer = load_function(config.optimizer.name)(model.parameters(), lr=config.optimizer.lr)\n",
    "criterion = load_function(config.loss_function.name)()\n",
    "scheduler = load_function(config.scheduler.name)(optimizer, step_size=config.scheduler.step_size, gamma=config.scheduler.gamma)\n",
    "\n",
    "if device != 'cpu':\n",
    "    model = model.to(device)\n",
    "\n",
    "#----------Создания датасета и обучение модели--------------\n",
    "\n",
    "path_res, model_name = prepare_and_learning_detection(num_classes = num_classes, num_samples = 20000, path_dataset = \"C:/Users/snytk/Lerning_NN_for_work/datasets_jpg/915_jpg_learning/\", \n",
    "                     model_name = config_name+\"_915_jpg_\", config_name = config_name, model=model)\n",
    "\n",
    "\n",
    "torch.cuda.empty_cache()\n",
    "cv2.destroyAllWindows()\n",
    "del model\n",
    "gc.collect()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4234ee26",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ebb4d1db",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "celltoolbar": "Отсутствует",
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.11.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}