DonkeySmall commited on
Commit
ef7c54c
·
verified ·
1 Parent(s): eebbce4

Upload 2 files

Browse files
Files changed (2) hide show
  1. test.py +125 -0
  2. train.py +576 -0
test.py ADDED
@@ -0,0 +1,125 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ import os
2
+
3
+ os.environ["CUDA_VISIBLE_DEVICES"] = "1"
4
+
5
+ import argparse
6
+ from pathlib import Path
7
+ import onnxruntime as ort
8
+ import torch
9
+ import torchvision.transforms.functional as TF
10
+ from torchvision.utils import save_image
11
+ from PIL import Image, ImageChops, ImageFilter
12
+ import time
13
+ import random
14
+ import numpy as np
15
+ from model import UpscalerTransformer
16
+
17
+
18
+ def parse_args():
19
+ parser = argparse.ArgumentParser()
20
+
21
+ parser.add_argument(
22
+ "--image",
23
+ type=str,
24
+ required=True,
25
+ help="Путь к входному изображению.",
26
+ )
27
+
28
+ parser.add_argument(
29
+ "--weights",
30
+ type=str,
31
+ required=True,
32
+ help="Путь к чекпоинту best.pth или last.pth.",
33
+ )
34
+
35
+ parser.add_argument(
36
+ "--output",
37
+ type=str,
38
+ default="sr_output.png",
39
+ help="Куда сохранить результат.",
40
+ )
41
+
42
+ # Если чекпоинт без config, можно задать вручную.
43
+ parser.add_argument("--lr_size", type=int, default=128)
44
+ parser.add_argument("--dim", type=int, default=256)
45
+ parser.add_argument("--depth", type=int, default=8)
46
+ parser.add_argument("--heads", type=int, default=8)
47
+ parser.add_argument("--window", type=int, default=8)
48
+ parser.add_argument("--resize_type", type=int, default=Image.Resampling.BICUBIC)
49
+ return parser.parse_args()
50
+
51
+ def main():
52
+ args = parse_args()
53
+
54
+ device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
55
+ print(f"Device: {device}")
56
+
57
+ ckpt = torch.load(args.weights, map_location="cpu")
58
+
59
+ if isinstance(ckpt, dict):
60
+ config = ckpt.get("config", {})
61
+ state_dict = ckpt.get("model", ckpt)
62
+ else:
63
+ config = {}
64
+ state_dict = ckpt
65
+
66
+ model = UpscalerTransformer(
67
+ dim=config.get("dim", args.dim),
68
+ depth=config.get("depth", args.depth),
69
+ num_heads=config.get("heads", args.heads),
70
+ window_size=config.get("window", args.window),
71
+ )
72
+
73
+ model.load_state_dict(state_dict)
74
+ model.to(device)
75
+ model.eval()
76
+
77
+ """dummy_input = torch.randn(1, 3, 128, 128)
78
+
79
+ torch.onnx.export(
80
+ model,
81
+ dummy_input,
82
+ "last.onnx",
83
+ export_params=True,
84
+ opset_version=17, # >= 16 для поддержки bicubic
85
+ do_constant_folding=True, # Оптимизация констант
86
+ input_names=['input'],
87
+ output_names=['output'],
88
+ )"""
89
+
90
+ lr_size = config.get("lr_size", args.lr_size)
91
+
92
+ image = Image.open(args.image).convert("RGB")
93
+
94
+ image = image.resize((lr_size, lr_size), Image.Resampling.BICUBIC)
95
+
96
+ image_hr = image.resize((lr_size * 2, lr_size * 2), args.resize_type)
97
+
98
+ x = TF.to_tensor(image).unsqueeze(0).to(device)
99
+
100
+ with torch.no_grad():
101
+ if device.type == "cuda":
102
+ with torch.cuda.amp.autocast():
103
+ sr = model(x)
104
+ else:
105
+ sr = model(x)
106
+
107
+ sr = torch.clamp(sr[0].float().cpu(), 0.0, 1.0)
108
+ image_result = sr.permute(1, 2, 0).numpy()
109
+ image_result = (image_result * 255.0).astype(np.uint8)
110
+ if image_result.shape[2] == 1:
111
+ image_result = image_result.squeeze(axis=2)
112
+
113
+ output_path = Path(args.output)
114
+ output_path.parent.mkdir(parents=True, exist_ok=True)
115
+
116
+ result = Image.new(image_hr.mode, (512, 256))
117
+
118
+ result.paste(image_hr, (0, 0))
119
+ result.paste(Image.fromarray(image_result), (256, 0))
120
+ result.save(output_path)
121
+
122
+ print(f"Saved: {output_path}")
123
+
124
+ if __name__ == "__main__":
125
+ main()
train.py ADDED
@@ -0,0 +1,576 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ import os
2
+
3
+ os.environ["CUDA_VISIBLE_DEVICES"] = "1"
4
+
5
+
6
+ import argparse
7
+ import random
8
+ import time
9
+ from pathlib import Path
10
+ import io
11
+ import torch
12
+ import torch.nn as nn
13
+ import torch.nn.functional as F
14
+ from torch.utils.data import Dataset, DataLoader
15
+ from tqdm import tqdm
16
+ from torchvision import transforms
17
+ import torchvision.transforms.functional as TF
18
+ from torchvision.transforms import InterpolationMode
19
+ from PIL import Image, ImageChops, ImageFilter
20
+
21
+ import torchvision.models as models
22
+
23
+ from model import UpscalerTransformer
24
+
25
+
26
+ IMG_EXTENSIONS = {
27
+ ".png",
28
+ ".jpg",
29
+ ".jpeg",
30
+ ".bmp",
31
+ ".tif",
32
+ ".tiff",
33
+ ".webp",
34
+ }
35
+
36
+
37
+ def find_images(folder):
38
+ folder = Path(folder)
39
+ if not folder.is_dir():
40
+ raise FileNotFoundError(f"Папка с датасетом не найдена: {folder}")
41
+
42
+ files = []
43
+ for p in folder.rglob("*"):
44
+ if p.suffix.lower() in IMG_EXTENSIONS:
45
+ files.append(str(p))
46
+
47
+ return sorted(files)
48
+
49
+
50
+ def split_dataset(paths, val_split, seed):
51
+ paths = sorted(paths)
52
+
53
+ if len(paths) == 0:
54
+ return [], []
55
+
56
+ if len(paths) == 1:
57
+ return paths, paths
58
+
59
+ rng = random.Random(seed)
60
+ rng.shuffle(paths)
61
+
62
+ if val_split <= 0:
63
+ return paths, paths
64
+
65
+ val_count = max(1, int(len(paths) * val_split))
66
+ val_paths = paths[:val_count]
67
+ train_paths = paths[val_count:]
68
+
69
+ return train_paths, val_paths
70
+
71
+
72
+ import torch
73
+ import torch.nn as nn
74
+
75
+ def _load_vgg16():
76
+ try:
77
+ weights = models.VGG16_Weights.IMAGENET1K_V1
78
+ return models.vgg16(weights=weights)
79
+ except Exception:
80
+ return models.vgg16(pretrained=True)
81
+
82
+
83
+ class VGGPerceptualLoss(nn.Module):
84
+ """
85
+ Perceptual loss на признаках VGG16.
86
+ Использует признаки до relu3_3.
87
+ """
88
+
89
+ def __init__(self):
90
+ super().__init__()
91
+
92
+ vgg = _load_vgg16()
93
+
94
+ # VGG16 features:
95
+ # 0 conv1_1, 1 relu, 2 conv1_2, 3 relu,
96
+ # 4 maxpool,
97
+ # 5 conv2_1, 6 relu, 7 conv2_2, 8 relu,
98
+ # 9 maxpool,
99
+ # 10 conv3_1, 11 relu, 12 conv3_2, 13 relu, 14 conv3_3, 15 relu
100
+ self.features = nn.Sequential(*list(vgg.features.children())[:16])
101
+
102
+ self.features.eval()
103
+ for p in self.features.parameters():
104
+ p.requires_grad_(False)
105
+
106
+ self.register_buffer(
107
+ "mean",
108
+ torch.tensor([0.485, 0.456, 0.406]).view(1, 3, 1, 1),
109
+ )
110
+ self.register_buffer(
111
+ "std",
112
+ torch.tensor([0.229, 0.224, 0.225]).view(1, 3, 1, 1),
113
+ )
114
+
115
+ def train(self, mode: bool = True):
116
+ # Всегда держим VGG в eval-режиме.
117
+ return super().train(False)
118
+
119
+ def forward(self, sr, hr):
120
+ sr = (sr - self.mean) / self.std
121
+ hr = (hr - self.mean) / self.std
122
+
123
+ sr_features = self.features(sr)
124
+ hr_features = self.features(hr)
125
+
126
+ return F.l1_loss(sr_features, hr_features)
127
+
128
+
129
+ class FFTLoss(nn.Module):
130
+ """
131
+ FFT loss помогает восстанавливать высокие частоты:
132
+ резкость, мелкие детали, текстуру.
133
+ """
134
+
135
+ def forward(self, sr, hr):
136
+ sr_fft = torch.fft.rfft2(sr, norm="ortho")
137
+ hr_fft = torch.fft.rfft2(hr, norm="ortho")
138
+
139
+ sr_mag = torch.log1p(torch.abs(sr_fft))
140
+ hr_mag = torch.log1p(torch.abs(hr_fft))
141
+
142
+ return F.l1_loss(sr_mag, hr_mag)
143
+
144
+
145
+ class SRDataset(Dataset):
146
+ def __init__(
147
+ self,
148
+ image_paths,
149
+ hr_size=256,
150
+ lr_size=128,
151
+ train=True,
152
+ ):
153
+ self.image_paths = image_paths
154
+ self.hr_size = hr_size
155
+ self.lr_size = lr_size
156
+ self.train = train
157
+
158
+ def __len__(self):
159
+ return len(self.image_paths)
160
+
161
+ def __getitem__(self, idx):
162
+ img_hr = Image.open(self.image_paths[idx]).convert("RGB")
163
+
164
+ if self.train:
165
+
166
+ rnd = random.randint(0, 192)
167
+ area = (rnd, rnd, 1024 - rnd, 1024 - rnd)
168
+ img_hr = img_hr.crop(area)
169
+ img_hr = img_hr.resize((self.hr_size, self.hr_size), Image.Resampling.LANCZOS)
170
+
171
+ if random.randint(0, 1) == 0:
172
+ img_hr = img_hr.transpose(Image.FLIP_LEFT_RIGHT)
173
+
174
+ if random.randint(0, 1) == 0:
175
+ random_choice = random.randint(0, 2)
176
+ if random_choice == 0:
177
+ img_hr = img_hr.transpose(Image.Transpose.ROTATE_90)
178
+ elif random_choice == 1:
179
+ img_hr = img_hr.transpose(Image.Transpose.ROTATE_180)
180
+ elif random_choice == 2:
181
+ img_hr = img_hr.transpose(Image.Transpose.ROTATE_270)
182
+
183
+ if random.randint(0, 1) == 0:
184
+ rnd_x = random.randint(-self.hr_size // 3, self.hr_size // 3)
185
+ rnd_y = random.randint(-self.hr_size // 3, self.hr_size // 3)
186
+ img_hr = ImageChops.offset(img_hr, xoffset=rnd_x, yoffset=rnd_y)
187
+
188
+
189
+ degradation_type = random.randint(0, 1)
190
+ resampling_mode = random.randint(0, 5)
191
+
192
+ if degradation_type == 0:
193
+ intermediate_size = random.randint(self.lr_size // 4, self.lr_size)
194
+ img_lr = img_hr.resize((intermediate_size, intermediate_size), resampling_mode)
195
+ img_lr = img_lr.resize((self.lr_size, self.lr_size), Image.Resampling.LANCZOS)
196
+ elif degradation_type == 1:
197
+ img_lr = img_hr.resize((self.lr_size, self.lr_size), resampling_mode)
198
+
199
+ if random.randint(0, 1) == 0:
200
+ buffer = io.BytesIO()
201
+ img_lr.save(buffer, format="JPEG", quality=random.randint(20, 80), optimize=True)
202
+ buffer.seek(0)
203
+ img_lr = Image.open(buffer)
204
+ img_lr.load()
205
+
206
+ else:
207
+ img_hr = img_hr.resize((self.hr_size, self.hr_size), Image.Resampling.LANCZOS)
208
+ img_lr = img_hr.resize((self.lr_size, self.lr_size), Image.Resampling.LANCZOS)
209
+
210
+ hr = TF.to_tensor(img_hr)
211
+ lr = TF.to_tensor(img_lr)
212
+
213
+ return lr, hr
214
+
215
+ def train_one_epoch(
216
+ model,
217
+ loader,
218
+ optimizer,
219
+ scaler,
220
+ device,
221
+ use_amp,
222
+ args,
223
+ perceptual_loss,
224
+ fft_loss,
225
+ ):
226
+ model.train()
227
+
228
+ total_loss = 0.0
229
+ num_samples = 0
230
+
231
+ pbar = tqdm(loader, desc="Training", leave=False)
232
+
233
+ for lr, hr in pbar:
234
+ lr = lr.to(device, non_blocking=True)
235
+ hr = hr.to(device, non_blocking=True)
236
+
237
+ optimizer.zero_grad(set_to_none=True)
238
+
239
+ if use_amp:
240
+ with torch.cuda.amp.autocast():
241
+ sr = model(lr)
242
+ loss = args.w_l1 * F.l1_loss(sr.float(), hr)
243
+ else:
244
+ sr = model(lr)
245
+ loss = args.w_l1 * F.l1_loss(sr, hr)
246
+
247
+ sr_f = sr.float()
248
+
249
+ if perceptual_loss is not None:
250
+ loss = loss + args.w_perceptual * perceptual_loss(sr_f, hr)
251
+
252
+ if fft_loss is not None:
253
+ loss = loss + args.w_fft * fft_loss(sr_f, hr)
254
+
255
+ if use_amp:
256
+ scaler.scale(loss).backward()
257
+ scaler.unscale_(optimizer)
258
+ torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
259
+ scaler.step(optimizer)
260
+ scaler.update()
261
+ else:
262
+ loss.backward()
263
+ torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
264
+ optimizer.step()
265
+
266
+ total_loss += loss.item() * lr.size(0)
267
+ num_samples += lr.size(0)
268
+
269
+ avg_loss = total_loss / max(1, num_samples)
270
+ pbar.set_postfix(loss=f"{avg_loss:.4f}")
271
+
272
+ return total_loss / max(1, num_samples)
273
+
274
+
275
+ @torch.no_grad()
276
+ def evaluate(model, loader, device):
277
+ model.eval()
278
+
279
+ total_psnr = 0.0
280
+ count = 0
281
+
282
+ pbar = tqdm(loader, desc="Evaluating", leave=False)
283
+
284
+ for lr, hr in pbar:
285
+ lr = lr.to(device, non_blocking=True)
286
+ hr = hr.to(device, non_blocking=True)
287
+
288
+ sr = model(lr)
289
+ sr = torch.clamp(sr.float(), 0.0, 1.0)
290
+
291
+ mse = torch.mean((sr - hr) ** 2, dim=(1, 2, 3))
292
+ psnr = 10.0 * torch.log10(1.0 / mse.clamp_min(1e-12))
293
+
294
+ total_psnr += psnr.sum().item()
295
+ count += lr.size(0)
296
+
297
+ # Обновляем прогресс-бар текущим средним PSNR
298
+ avg_psnr = total_psnr / max(1, count)
299
+ pbar.set_postfix(psnr=f"{avg_psnr:.2f} dB")
300
+
301
+ return total_psnr / max(1, count)
302
+
303
+
304
+ def parse_args():
305
+ parser = argparse.ArgumentParser()
306
+
307
+ parser.add_argument(
308
+ "--data_dir",
309
+ type=str,
310
+ required=True,
311
+ help="Папка с HR-изображениями.",
312
+ )
313
+
314
+ parser.add_argument(
315
+ "--output_dir",
316
+ type=str,
317
+ default="runs_quality",
318
+ help="Куда сохранять чекпоинты.",
319
+ )
320
+
321
+ parser.add_argument(
322
+ "--resume",
323
+ type=str,
324
+ default="",
325
+ help="Путь к last.pth или best.pth для возобновления обучения.",
326
+ )
327
+
328
+ parser.add_argument(
329
+ "--reset_scheduler",
330
+ action="store_true",
331
+ help="Пересчитать scheduler под новый --epochs при возобновлении.",
332
+ )
333
+
334
+ parser.add_argument("--epochs", type=int, default=300)
335
+ parser.add_argument("--batch_size", type=int, default=4)
336
+ parser.add_argument("--lr", type=float, default=0.0001)
337
+ parser.add_argument("--weight_decay", type=float, default=0.00001)
338
+
339
+ # Параметры модели.
340
+ # Для качества лучше больше, чем для скорости.
341
+ parser.add_argument("--dim", type=int, default=512)
342
+ parser.add_argument("--depth", type=int, default=8)
343
+ parser.add_argument("--heads", type=int, default=8)
344
+ parser.add_argument("--window", type=int, default=16)
345
+
346
+ # Датасет.
347
+ parser.add_argument("--hr_size", type=int, default=256)
348
+ parser.add_argument("--lr_size", type=int, default=128)
349
+ parser.add_argument("--val_split", type=float, default=0.05)
350
+
351
+ parser.add_argument("--num_workers", type=int, default=4)
352
+ parser.add_argument("--seed", type=int, default=42)
353
+
354
+ # Loss weights.
355
+ parser.add_argument("--w_l1", type=float, default=1.0)
356
+
357
+ parser.add_argument("--w_perceptual", type=float, default=0.1)
358
+ parser.add_argument("--w_fft", type=float, default=0.1)
359
+
360
+ # Если нужно отключить тяжёлые лоссы.
361
+ parser.add_argument(
362
+ "--no_perceptual",
363
+ action="store_true",
364
+ help="Отключить VGG perceptual loss.",
365
+ )
366
+ parser.add_argument(
367
+ "--no_fft",
368
+ action="store_true",
369
+ help="Отключить FFT loss.",
370
+ )
371
+
372
+ return parser.parse_args()
373
+
374
+
375
+ def main():
376
+ args = parse_args()
377
+
378
+ out_dir = Path(args.output_dir)
379
+ out_dir.mkdir(parents=True, exist_ok=True)
380
+
381
+ device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
382
+ print(f"Device: {device}")
383
+
384
+ torch.backends.cudnn.benchmark = True
385
+
386
+ paths = find_images(args.data_dir)
387
+ print(f"Найдено изображений: {len(paths)}")
388
+
389
+ train_paths, val_paths = split_dataset(paths, args.val_split, args.seed)
390
+ print(f"Train: {len(train_paths)}, Val: {len(val_paths)}")
391
+
392
+ train_dataset = SRDataset(
393
+ image_paths=train_paths,
394
+ hr_size=args.hr_size,
395
+ lr_size=args.lr_size,
396
+ train=True,
397
+ )
398
+
399
+ val_dataset = SRDataset(
400
+ image_paths=val_paths,
401
+ hr_size=args.hr_size,
402
+ lr_size=args.lr_size,
403
+ train=False,
404
+ )
405
+
406
+ pin_memory = device.type == "cuda"
407
+ persistent_workers = args.num_workers > 0
408
+
409
+ train_loader = DataLoader(
410
+ train_dataset,
411
+ batch_size=args.batch_size,
412
+ shuffle=True,
413
+ num_workers=args.num_workers,
414
+ pin_memory=pin_memory,
415
+ persistent_workers=persistent_workers,
416
+ )
417
+
418
+ val_loader = DataLoader(
419
+ val_dataset,
420
+ batch_size=args.batch_size,
421
+ shuffle=False,
422
+ num_workers=args.num_workers,
423
+ pin_memory=pin_memory,
424
+ persistent_workers=persistent_workers,
425
+ )
426
+
427
+ model = UpscalerTransformer(
428
+ dim=args.dim,
429
+ depth=args.depth,
430
+ num_heads=args.heads,
431
+ window_size=args.window,
432
+ ).to(device)
433
+
434
+ optimizer = torch.optim.AdamW(
435
+ model.parameters(),
436
+ lr=args.lr,
437
+ weight_decay=args.weight_decay,
438
+ )
439
+
440
+ scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(
441
+ optimizer,
442
+ T_max=args.epochs,
443
+ eta_min=1e-6,
444
+ )
445
+
446
+ use_amp = device.type == "cuda"
447
+ scaler = torch.cuda.amp.GradScaler(enabled=use_amp)
448
+
449
+ perceptual_loss = None
450
+ if not args.no_perceptual:
451
+ try:
452
+ print("Загрузка VGG perceptual loss...")
453
+ perceptual_loss = VGGPerceptualLoss().to(device).eval()
454
+ print("VGG perceptual loss включён.")
455
+ except Exception as e:
456
+ print(f"Не удалось загрузить VGG perceptual loss: {e}")
457
+ print("Продолжаю без perceptual loss.")
458
+ perceptual_loss = None
459
+
460
+ fft_loss = None
461
+ if not args.no_fft:
462
+ fft_loss = FFTLoss().to(device)
463
+ print("FFT loss включён.")
464
+
465
+ start_epoch = 1
466
+ best_psnr = -float("inf")
467
+
468
+ if args.resume:
469
+ resume_path = Path(args.resume)
470
+
471
+ if not resume_path.exists():
472
+ raise FileNotFoundError(f"Чекпоинт для возобновления не найден: {resume_path}")
473
+
474
+ print(f"Возобновление обучения из: {resume_path}")
475
+
476
+ ckpt = torch.load(resume_path, map_location=device)
477
+
478
+ if isinstance(ckpt, dict):
479
+ # Веса модели
480
+ model.load_state_dict(ckpt.get("model", ckpt))
481
+
482
+ # Оптимизатор
483
+ if "optimizer" in ckpt:
484
+ optimizer.load_state_dict(ckpt["optimizer"])
485
+
486
+ # Scheduler
487
+ if (
488
+ not args.reset_scheduler
489
+ and "scheduler" in ckpt
490
+ and ckpt["scheduler"] is not None
491
+ ):
492
+ scheduler.load_state_dict(ckpt["scheduler"])
493
+ elif "epoch" in ckpt:
494
+ # Если scheduler не был сохранён или сброшен,
495
+ # восстанавливаем его позицию вручную.
496
+ for _ in range(ckpt["epoch"]):
497
+ scheduler.step()
498
+
499
+ # AMP scaler
500
+ if use_amp and "scaler" in ckpt and ckpt["scaler"] is not None:
501
+ scaler.load_state_dict(ckpt["scaler"])
502
+
503
+ start_epoch = ckpt.get("epoch", 0) + 1
504
+ best_psnr = ckpt.get("best_psnr", ckpt.get("val_psnr", -float("inf")))
505
+
506
+ else:
507
+ # Если это просто state_dict модели
508
+ model.load_state_dict(ckpt)
509
+
510
+ print(f"Продолжаю с эпохи: {start_epoch}")
511
+ print(f"Лучший PSNR на данный момент: {best_psnr:.3f} dB")
512
+
513
+ config = {
514
+ "dim": args.dim,
515
+ "depth": args.depth,
516
+ "heads": args.heads,
517
+ "window": args.window,
518
+ "hr_size": args.hr_size,
519
+ "lr_size": args.lr_size,
520
+ }
521
+
522
+ if start_epoch > args.epochs:
523
+ print("Обучение уже завершено для указанного --epochs.")
524
+ print("Увеличь --epochs, если хочешь дообучить модель.")
525
+ return
526
+
527
+ for epoch in range(start_epoch, args.epochs + 1):
528
+ t0 = time.time()
529
+
530
+ train_loss = train_one_epoch(
531
+ model=model,
532
+ loader=train_loader,
533
+ optimizer=optimizer,
534
+ scaler=scaler,
535
+ device=device,
536
+ use_amp=use_amp,
537
+ args=args,
538
+ perceptual_loss=perceptual_loss,
539
+ fft_loss=fft_loss,
540
+ )
541
+
542
+ val_psnr = evaluate(model, val_loader, device)
543
+
544
+ scheduler.step()
545
+
546
+ state = {
547
+ "epoch": epoch,
548
+ "model": model.state_dict(),
549
+ "optimizer": optimizer.state_dict(),
550
+ "scheduler": scheduler.state_dict(),
551
+ "scaler": scaler.state_dict() if use_amp else None,
552
+ "train_loss": train_loss,
553
+ "val_psnr": val_psnr,
554
+ "best_psnr": max(best_psnr, val_psnr),
555
+ "config": config,
556
+ }
557
+
558
+ torch.save(state, out_dir / "last.pth")
559
+
560
+ if val_psnr > best_psnr:
561
+ best_psnr = val_psnr
562
+ torch.save(state, out_dir / "best.pth")
563
+
564
+ dt = time.time() - t0
565
+
566
+ print(
567
+ f"Epoch {epoch:03d} | "
568
+ f"loss: {train_loss:.6f} | "
569
+ f"val PSNR: {val_psnr:.3f} dB | "
570
+ f"best PSNR: {best_psnr:.3f} dB | "
571
+ f"time: {dt:.2f}s"
572
+ )
573
+
574
+
575
+ if __name__ == "__main__":
576
+ main()