DroneDetector/train_scripts/Training_models_2.4-Copy2.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",
    "            image_imag = np.asarray(cv2.split(cv2.imread(self.sig_filenames[idx][:-8]+'imag.jpg')), dtype=np.float32)\n",
    "            image_spec = np.asarray(cv2.split(cv2.imread(self.sig_filenames[idx][:-8]+'spec.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, image_imag, image_spec, 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 (img1, img2, img3, label) in tqdm(dataloaders[phase]):\n",
    "                img1, img2, img3, label = img1.to(device), img2.to(device), img3.to(device), label.to(device)\n",
    "                optimizer.zero_grad()\n",
    "    \n",
    "                with torch.set_grad_enabled(phase == 'train'):\n",
    "                    output = model([img1, img2, img3])\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() * 3 * img1.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=None`.\n",
      "  warnings.warn(msg)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch : 1\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████████████████████████| 3500/3500 [33:47<00:00,  1.73it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train Loss: 0.3107 Acc: 0.9612\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████████████████████████| 1500/1500 [05:45<00:00,  4.34it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "val Loss: 0.0993 Acc: 0.9893\n",
      "\n",
      "Epoch : 2\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████████████████████████| 3500/3500 [25:20<00:00,  2.30it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train Loss: 0.0911 Acc: 0.9896\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████████████████████████| 1500/1500 [04:40<00:00,  5.34it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "val Loss: 0.0354 Acc: 0.9980\n",
      "\n",
      "Epoch : 3\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████████████████████████| 3500/3500 [24:52<00:00,  2.34it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train Loss: 0.0519 Acc: 0.9938\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████████████████████████| 1500/1500 [04:13<00:00,  5.92it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "val Loss: 0.0525 Acc: 0.9942\n",
      "\n",
      "Epoch : 4\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████████████████████████| 3500/3500 [25:23<00:00,  2.30it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train Loss: 0.0347 Acc: 0.9961\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████████████████████████| 1500/1500 [04:44<00:00,  5.27it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "val Loss: 0.0190 Acc: 0.9975\n",
      "\n",
      "Epoch : 5\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████████████████████████| 3500/3500 [24:50<00:00,  2.35it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train Loss: 0.0302 Acc: 0.9965\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████████████████████████| 1500/1500 [04:22<00:00,  5.72it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "val Loss: 0.0338 Acc: 0.9958\n",
      "\n",
      "Epoch : 6\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████████████████████████| 3500/3500 [24:44<00:00,  2.36it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train Loss: 0.0223 Acc: 0.9970\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████████████████████████| 1500/1500 [04:20<00:00,  5.77it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "val Loss: 0.0111 Acc: 0.9992\n",
      "\n",
      "Epoch : 7\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████████████████████████| 3500/3500 [24:40<00:00,  2.36it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train Loss: 0.0215 Acc: 0.9979\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████████████████████████| 1500/1500 [04:22<00:00,  5.71it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "val Loss: 0.0133 Acc: 0.9982\n",
      "\n",
      "Epoch : 8\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████████████████████████| 3500/3500 [24:42<00:00,  2.36it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train Loss: 0.0184 Acc: 0.9979\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████████████████████████| 1500/1500 [04:17<00:00,  5.83it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "val Loss: 0.0343 Acc: 0.9962\n",
      "\n",
      "Epoch : 9\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████████████████████████| 3500/3500 [24:35<00:00,  2.37it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train Loss: 0.0090 Acc: 0.9990\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████████████████████████| 1500/1500 [04:15<00:00,  5.86it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "val Loss: 0.0175 Acc: 0.9978\n",
      "\n",
      "Epoch : 10\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████████████████████████| 3500/3500 [25:01<00:00,  2.33it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train Loss: 0.0189 Acc: 0.9982\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████████████████████████| 1500/1500 [04:47<00:00,  5.21it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "val Loss: 0.0349 Acc: 0.9960\n",
      "\n",
      "Total time elapsed = 18231.4253906 seconds\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\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",
    "num_classes = 3\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",
    "model1 = models.resnet18(pretrained=False)\n",
    "model2 = models.resnet50(pretrained=False)\n",
    "model3 = models.resnet101(pretrained=False)\n",
    "\n",
    "num_classes = 2\n",
    "\n",
    "model1.fc = nn.Linear(model1.fc.in_features, num_classes)\n",
    "model2.fc = nn.Linear(model2.fc.in_features, num_classes)\n",
    "model3.fc = nn.Linear(model3.fc.in_features, num_classes)\n",
    "\n",
    "class Ensemble(nn.Module):\n",
    "    def __init__(self, model1, model2, model3):\n",
    "        super(Ensemble, self).__init__()\n",
    "        self.model1 = model1\n",
    "        self.model2 = model2\n",
    "        self.model3 = model3\n",
    "        self.fc = nn.Linear(3 * num_classes, num_classes)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x1 = self.model1(x[0])\n",
    "        x2 = self.model2(x[1])\n",
    "        x3 = self.model3(x[2])\n",
    "        x = torch.cat((x1, x2, x3), dim=1)\n",
    "        x = self.fc(x)\n",
    "        return x\n",
    "\n",
    "model = Ensemble(model1, model2, model3)\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/2.4_jpg_learning/\", \n",
    "                     model_name = config_name+\"_2.4_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": "57d18676",
   "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
}