You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
647 lines
81 KiB
Plaintext
647 lines
81 KiB
Plaintext
{
|
|
"cells": [
|
|
{
|
|
"cell_type": "code",
|
|
"execution_count": 1,
|
|
"id": "e1db882b",
|
|
"metadata": {},
|
|
"outputs": [
|
|
{
|
|
"name": "stderr",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"/home/sibscience-4/from_ssh/DroneDetector/.venv-train/lib/python3.12/site-packages/matplotlib/projections/__init__.py:63: UserWarning: Unable to import Axes3D. This may be due to multiple versions of Matplotlib being installed (e.g. as a system package and as a pip package). As a result, the 3D projection is not available.\n",
|
|
" warnings.warn(\"Unable to import Axes3D. This may be due to multiple versions of \"\n"
|
|
]
|
|
},
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"cuda\n"
|
|
]
|
|
},
|
|
{
|
|
"data": {
|
|
"text/plain": [
|
|
"191"
|
|
]
|
|
},
|
|
"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": "code",
|
|
"execution_count": 2,
|
|
"id": "8e009995",
|
|
"metadata": {},
|
|
"outputs": [],
|
|
"source": [
|
|
"def prepare_and_learning_detection(num_classes, num_samples, path_dataset, model_name, config_name, model,selected_freq):\n",
|
|
" num_samples_per_class = num_samples // num_classes\n",
|
|
"\n",
|
|
" #----------Создаём папку для сохранения результатов обучения--------------\n",
|
|
" os.makedirs(\"models\", exist_ok=True)\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",
|
|
" \n",
|
|
" for subdir in subdirs:\n",
|
|
" freq_dir = os.path.join(path_dataset, subdir, str(selected_freq)+\"_jpg\")\n",
|
|
" if not os.path.isdir(freq_dir):\n",
|
|
" print(\"Error1\")\n",
|
|
" continue\n",
|
|
" \n",
|
|
" files_k=[f for f in os.listdir(freq_dir)]\n",
|
|
" print(len(files_k))\n",
|
|
" \n",
|
|
" files = [\n",
|
|
" f for f in os.listdir(freq_dir)\n",
|
|
" if os.path.isfile(os.path.join(freq_dir, f)) and f.endswith('imag.png')\n",
|
|
" ]\n",
|
|
" num_samples_per_class = min(num_samples_per_class, len(files))\n",
|
|
" print(f\"num_samples per class {subdir} is {num_samples_per_class}\")\n",
|
|
"\n",
|
|
" for subdir in subdirs:\n",
|
|
" freq_dir = os.path.join(path_dataset, subdir, str(selected_freq)+\"_jpg\")\n",
|
|
" if not os.path.isdir(freq_dir):\n",
|
|
" print(\"Error1\")\n",
|
|
" continue\n",
|
|
"\n",
|
|
" files = [\n",
|
|
" f for f in os.listdir(freq_dir)\n",
|
|
" if os.path.isfile(os.path.join(freq_dir, f)) and f.endswith('imag.png')\n",
|
|
" ]\n",
|
|
" random.shuffle(files)\n",
|
|
" files_to_process = files[:num_samples_per_class]\n",
|
|
"\n",
|
|
" for file in files_to_process:\n",
|
|
" row = pd.DataFrame({\n",
|
|
" pd_columns[0]: [str(os.path.join(freq_dir, file))]\n",
|
|
" })\n",
|
|
" df = pd.concat([df, row], ignore_index=True)\n",
|
|
"\n",
|
|
" dataset_csv_path = os.path.join(path_res, 'dataset.csv')\n",
|
|
" df.to_csv(dataset_csv_path, index=False)\n",
|
|
"\n",
|
|
" if not os.path.exists(dataset_csv_path):\n",
|
|
" raise RuntimeError(f'dataset.csv was not created: {dataset_csv_path}')\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(os.path.join(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",
|
|
" base = os.path.splitext(self.sig_filenames[idx])[0]\n",
|
|
" if base[-4:]==\"real\":\n",
|
|
" image_real = np.asarray(cv2.split(cv2.imread(base + '.png')), dtype=np.float32)\n",
|
|
" image_imag = np.asarray(cv2.split(cv2.imread(base[:-4] + 'imag.png')), dtype=np.float32)\n",
|
|
" if base[-4:]==\"imag\":\n",
|
|
" image_real = np.asarray(cv2.split(cv2.imread(base[:-4] + 'real.png')), dtype=np.float32)\n",
|
|
" image_imag = np.asarray(cv2.split(cv2.imread(base + '.png')), dtype=np.float32)\n",
|
|
" \n",
|
|
" \n",
|
|
" \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, 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=False, drop_last=False)\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",
|
|
" min_delta = 1e-4\n",
|
|
" \n",
|
|
" best_val_loss = float('inf')\n",
|
|
" best_model = copy.deepcopy(model.state_dict())\n",
|
|
" limit = config.limit\n",
|
|
" ind_limit = 0\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",
|
|
" \n",
|
|
" for phase in ['train', 'val']:\n",
|
|
" if phase == 'train':\n",
|
|
" model.train()\n",
|
|
" else:\n",
|
|
" model.eval()\n",
|
|
"\n",
|
|
" running_loss = 0.0\n",
|
|
" running_corrects = 0\n",
|
|
" \n",
|
|
" for (img1, img2, label) in tqdm(dataloaders[phase]):\n",
|
|
" img1, img2, label = img1.to(device), img2.to(device), label.to(device)\n",
|
|
" optimizer.zero_grad()\n",
|
|
" \n",
|
|
" with torch.set_grad_enabled(phase == 'train'):\n",
|
|
" output = model([img1, img2])\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() * 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",
|
|
" scheduler.step(epoch_loss)\n",
|
|
"\n",
|
|
" current_lr = optimizer.param_groups[0]['lr']\n",
|
|
" print(f'val lr: {current_lr:.8f}')\n",
|
|
"\n",
|
|
" if epoch_loss < (best_val_loss - min_delta):\n",
|
|
" ind_limit = 0\n",
|
|
" best_val_loss = epoch_loss\n",
|
|
" best_model = copy.deepcopy(model.state_dict())\n",
|
|
" torch.save(best_model, path_res + model_name + '.pth')\n",
|
|
" print(f'saved best model with val_loss={best_val_loss:.4f}')\n",
|
|
" else:\n",
|
|
" ind_limit += 1\n",
|
|
" print(f'early stopping patience: {ind_limit}/{limit}')\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",
|
|
" \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": "code",
|
|
"execution_count": 4,
|
|
"id": "53717d63",
|
|
"metadata": {},
|
|
"outputs": [
|
|
{
|
|
"name": "stderr",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"/home/sibscience-4/from_ssh/DroneDetector/.venv-train/lib/python3.12/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",
|
|
"/home/sibscience-4/from_ssh/DroneDetector/.venv-train/lib/python3.12/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": [
|
|
"9520\n",
|
|
"num_samples per class noise is 2380\n",
|
|
"5060\n",
|
|
"num_samples per class drone is 1265\n",
|
|
"Epoch : 1\n",
|
|
"\n"
|
|
]
|
|
},
|
|
{
|
|
"name": "stderr",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"100%|███████████████████████████████████████████████████████| 442/442 [01:44<00:00, 4.23it/s]\n"
|
|
]
|
|
},
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"train Loss: 0.1155 Acc: 0.9870\n"
|
|
]
|
|
},
|
|
{
|
|
"name": "stderr",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"100%|███████████████████████████████████████████████████████| 189/189 [00:21<00:00, 8.83it/s]\n"
|
|
]
|
|
},
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"val Loss: 0.0067 Acc: 0.9960\n",
|
|
"\n",
|
|
"Epoch : 2\n",
|
|
"\n"
|
|
]
|
|
},
|
|
{
|
|
"name": "stderr",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"100%|███████████████████████████████████████████████████████| 442/442 [01:45<00:00, 4.17it/s]\n"
|
|
]
|
|
},
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"train Loss: 0.0032 Acc: 0.9983\n"
|
|
]
|
|
},
|
|
{
|
|
"name": "stderr",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"100%|███████████████████████████████████████████████████████| 189/189 [00:22<00:00, 8.26it/s]\n"
|
|
]
|
|
},
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"val Loss: 0.0027 Acc: 0.9960\n",
|
|
"\n",
|
|
"Epoch : 3\n",
|
|
"\n"
|
|
]
|
|
},
|
|
{
|
|
"name": "stderr",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"100%|███████████████████████████████████████████████████████| 442/442 [01:45<00:00, 4.18it/s]\n"
|
|
]
|
|
},
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"train Loss: 0.0014 Acc: 0.9983\n"
|
|
]
|
|
},
|
|
{
|
|
"name": "stderr",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"100%|███████████████████████████████████████████████████████| 189/189 [00:22<00:00, 8.24it/s]\n"
|
|
]
|
|
},
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"val Loss: 0.0007 Acc: 0.9960\n",
|
|
"\n",
|
|
"Epoch : 4\n",
|
|
"\n"
|
|
]
|
|
},
|
|
{
|
|
"name": "stderr",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"100%|███████████████████████████████████████████████████████| 442/442 [01:46<00:00, 4.17it/s]\n"
|
|
]
|
|
},
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"train Loss: 0.0009 Acc: 0.9983\n"
|
|
]
|
|
},
|
|
{
|
|
"name": "stderr",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"100%|███████████████████████████████████████████████████████| 189/189 [00:22<00:00, 8.28it/s]\n"
|
|
]
|
|
},
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"val Loss: 0.0007 Acc: 0.9960\n",
|
|
"\n",
|
|
"Epoch : 5\n",
|
|
"\n"
|
|
]
|
|
},
|
|
{
|
|
"name": "stderr",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"100%|███████████████████████████████████████████████████████| 442/442 [01:46<00:00, 4.15it/s]\n"
|
|
]
|
|
},
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"train Loss: 0.0005 Acc: 0.9983\n"
|
|
]
|
|
},
|
|
{
|
|
"name": "stderr",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 189/189 [00:21<00:00, 8.62it/s]\n"
|
|
]
|
|
},
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"val Loss: 0.0005 Acc: 0.9960\n",
|
|
"\n",
|
|
"Epoch : 6\n",
|
|
"\n"
|
|
]
|
|
},
|
|
{
|
|
"name": "stderr",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 442/442 [01:46<00:00, 4.17it/s]\n"
|
|
]
|
|
},
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"train Loss: 0.0004 Acc: 0.9983\n"
|
|
]
|
|
},
|
|
{
|
|
"name": "stderr",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 189/189 [00:22<00:00, 8.48it/s]\n"
|
|
]
|
|
},
|
|
{
|
|
"name": "stdout",
|
|
"output_type": "stream",
|
|
"text": [
|
|
"val Loss: 0.0003 Acc: 0.9960\n",
|
|
"Total time elapsed = 769.277186642983 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",
|
|
"model1 = models.resnet18(pretrained=True)\n",
|
|
"model2 = models.resnet50(pretrained=True)\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",
|
|
"\n",
|
|
"class Ensemble(nn.Module):\n",
|
|
" def __init__(self, model1, model2):\n",
|
|
" super(Ensemble, self).__init__()\n",
|
|
" self.model1 = model1\n",
|
|
" self.model2 = model2\n",
|
|
" self.fc = nn.Linear(2 * num_classes, num_classes)\n",
|
|
"\n",
|
|
" def forward(self, x):\n",
|
|
" x1 = self.model1(x[0])\n",
|
|
" x2 = self.model2(x[1])\n",
|
|
" x = torch.cat((x1, x2), dim=1)\n",
|
|
" x = self.fc(x)\n",
|
|
" return x\n",
|
|
"model = Ensemble(model1, model2)\n",
|
|
"\n",
|
|
"optimizer = load_function(config.optimizer.name)(model.parameters(), lr=config.optimizer.lr)\n",
|
|
"criterion = load_function(config.loss_function.name)()\n",
|
|
"scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='min', factor=0.5, patience=2, min_lr=1e-6)\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 = 10000, path_dataset = \"/mnt/data/Dataset_img\", \n",
|
|
" selected_freq=2400,model_name = config_name+\"2400_\", config_name = config_name, model=model)\n",
|
|
"\n",
|
|
"\n",
|
|
"torch.cuda.empty_cache()\n",
|
|
"cv2.destroyAllWindows()\n",
|
|
"del model\n",
|
|
"gc.collect()"
|
|
]
|
|
}
|
|
],
|
|
"metadata": {
|
|
"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.12.3"
|
|
}
|
|
},
|
|
"nbformat": 4,
|
|
"nbformat_minor": 5
|
|
} |