Upload 2 files
Browse files
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()
|