From 4349f5af41af68bdf7bd2df2d451605d62c41795 Mon Sep 17 00:00:00 2001 From: Andras Schmelczer Date: Sat, 13 Apr 2024 15:54:34 +0100 Subject: [PATCH] fix training --- editor/training/__init__.py | 2 + editor/training/histogram_dataset.py | 7 +- editor/training/progressive_pooling_loss.py | 25 +- train.ipynb | 206263 +++++++---------- 4 files changed, 86227 insertions(+), 120070 deletions(-) diff --git a/editor/training/__init__.py b/editor/training/__init__.py index 2054ca4..272d7a2 100644 --- a/editor/training/__init__.py +++ b/editor/training/__init__.py @@ -1 +1,3 @@ from .histogram_dataset import HistogramDataset +from .random_edit import random_edit +from .progressive_pooling_loss import ProgressivePoolingLoss diff --git a/editor/training/histogram_dataset.py b/editor/training/histogram_dataset.py index 7d44e4e..64c2503 100644 --- a/editor/training/histogram_dataset.py +++ b/editor/training/histogram_dataset.py @@ -61,13 +61,14 @@ class HistogramDataset(Dataset): edited = random_edit(original, seed=idx) - original_histogram = compute_histogram( - original, bins=self._bin_count, normalize=True - ) edited_histogram = compute_histogram( edited, bins=self._bin_count, normalize=True ) + original_histogram = compute_histogram( + original, bins=self._bin_count, normalize=True + ) + result = ( torch.tensor(edited_histogram, dtype=torch.float).unsqueeze(0), torch.tensor(original_histogram, dtype=torch.float).unsqueeze(0), diff --git a/editor/training/progressive_pooling_loss.py b/editor/training/progressive_pooling_loss.py index 3e4cdc5..c579216 100644 --- a/editor/training/progressive_pooling_loss.py +++ b/editor/training/progressive_pooling_loss.py @@ -1,31 +1,38 @@ +from typing import List import torch import torch.nn as nn import torch.nn.functional as F class ProgressivePoolingLoss(nn.Module): - def __init__(self, initial_pool_size: int = 2, damping=1.8): + def __init__(self, target_sizes: List[int], damping: float): super(ProgressivePoolingLoss, self).__init__() - self._initial_pool_size = initial_pool_size + self._target_sizes = target_sizes self._damping = damping def forward(self, tensor_a, tensor_b): assert ( tensor_a.size() == tensor_b.size() - ), "Input tensors must have the same size." + ), f"Input tensors must have the same size, got {tensor_a.size()} and {tensor_b.size()}" - max_pool_size = min(tensor_a.size(1), tensor_a.size(2), tensor_a.size(3)) + assert ( + len(tensor_a.size()) == 5 + ), f"Input tensors must have 5 dimensions, got {tensor_a.size()}" + + _minibatch_size, _channels, depth, height, width = tensor_a.size() + assert depth == height == width, "Input tensors must be cubes." loss = 0.0 - damping = 1 + weight = 1 - for pool_size in range(self._initial_pool_size, max_pool_size): + for target_size in self._target_sizes: + pool_size = depth // target_size pooled_a = F.avg_pool3d(tensor_a, pool_size) * (pool_size**3) pooled_b = F.avg_pool3d(tensor_b, pool_size) * (pool_size**3) - diff = torch.square(pooled_a - pooled_b) + diff = torch.abs(pooled_a - pooled_b) - loss += diff.mean() / damping - damping *= self._damping + loss += diff.mean() * weight + weight *= self._damping return loss diff --git a/train.ipynb b/train.ipynb index ddfbc48..2249ea7 100644 --- a/train.ipynb +++ b/train.ipynb @@ -4,79 +4,77 @@ "cell_type": "code", "execution_count": 1, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "'Using device `cuda:0`'" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ + "import torch\n", "from pathlib import Path\n", "\n", - "DATA_PATH = Path('/mnt/wsl/PHYSICALDRIVE1/data/unsplash/edited')\n", - "DATA = sorted(DATA_PATH.glob('*'))\n", + "DATA = Path('/mnt/wsl/PHYSICALDRIVE1/data/unsplash').glob('*.jpg')\n", + "CACHE_PATH = Path('/mnt/wsl/PHYSICALDRIVE1/data/cache2')\n", + "CACHE_PATH.mkdir(exist_ok=True, parents=True)\n", "BINS = 32\n", "NUM_EPOCHS = 10\n", "BATCH_SIZE = 32\n", - "LEARNING_RATE = 0.00001" + "LEARNING_RATE = 0.005\n", + "SCHEDULER_GAMMA = 0.2\n", + "EDIT_COUNT = 25\n", + "LOSS_DAMPING = 2\n", + "MODELS_PATH = Path('models')\n", + "MODELS_PATH.mkdir(exist_ok=True, parents=True)\n", + "\n", + "device = torch.device(\"cuda:0\") if torch.cuda.is_available() else torch.device(\"cpu\")\n", + "f'Using device `{device}`'" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "'Loaded 561982 training images and 62443 test images'" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "import torch\n", - "device = torch.device(\"cuda:0\")" + "from torch.utils.data import DataLoader, random_split\n", + "from editor.training import HistogramDataset\n", + "\n", + "dataset = HistogramDataset(DATA, edit_count=EDIT_COUNT, bin_count=BINS, delete_corrupt_images=False, cache_path=CACHE_PATH)\n", + "total_size = len(dataset)\n", + "train_size = int(0.9 * total_size)\n", + "test_size = total_size - train_size\n", + "train_dataset, test_dataset = random_split(dataset, [train_size, test_size], generator=torch.Generator().manual_seed(42))\n", + "\n", + "train_dataloader = DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True, num_workers=32)\n", + "test_dataloader = DataLoader(test_dataset, batch_size=1, shuffle=False, num_workers=32)\n", + "\n", + "f'Loaded {len(train_dataset)} training images and {len(test_dataset)} test images'" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 5%|▍ | 1232/24997 [00:00<00:05, 4044.85it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Failed to open /mnt/wsl/PHYSICALDRIVE1/data/unsplash/edited/0LnXtS8DUZI/3.jpg\n", - "Failed to open /mnt/wsl/PHYSICALDRIVE1/data/unsplash/edited/0OqCRbwWu6g/1.jpg\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 24997/24997 [00:06<00:00, 3991.28it/s]\n" - ] - } - ], - "source": [ - "\n", - "from torch.utils.data import DataLoader, random_split\n", - "from editor.training import HistogramDataset\n", - "\n", - "dataset = HistogramDataset(DATA, expected_edit_count=10, bin_count=BINS)\n", - "total_size = len(dataset)\n", - "train_size = int(0.8 * total_size)\n", - "test_size = total_size - train_size\n", - "generator = torch.Generator().manual_seed(42)\n", - "train_dataset, test_dataset = random_split(dataset, [train_size, test_size], generator=generator)\n", - "\n", - "train_dataloader = DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True, num_workers=32)\n", - "test_dataloader = DataLoader(test_dataset, batch_size=1, shuffle=False, num_workers=32)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, "outputs": [], "source": [ - "import torch\n", "import torch.nn as nn\n", "import torch.nn.functional as F\n", "\n", @@ -106,8 +104,18 @@ " self.fc1 = nn.Linear(64 * 4 * 4 * 4, 512)\n", " self.fc_bn1 = nn.BatchNorm1d(512)\n", " self.fc2 = nn.Linear(512, 32 * 32 * 32)\n", + " self.apply(HistogramRestorationNet._init_weights_he)\n", + "\n", + " @staticmethod\n", + " def _init_weights_he(m):\n", + " if isinstance(m, nn.Linear) or isinstance(m, nn.Conv3d):\n", + " torch.nn.init.kaiming_uniform_(m.weight, nonlinearity='relu')\n", + " if m.bias is not None:\n", + " torch.nn.init.zeros_(m.bias)\n", "\n", " def forward(self, x):\n", + " # Input dimensions: (batch_size, channels(1), 32, 32, 32)\n", + "\n", " x = F.relu(self.bn1(self.conv1(x)))\n", " x = F.max_pool3d(x, 2)\n", "\n", @@ -131,8 +139,51 @@ "\n", " # Reshape back to the histogram shape\n", " x = x.view(-1, 32, 32, 32)\n", + " x /= torch.sum(x, (1, 2, 3)).view(x.size()[0], 1, 1, 1)\n", "\n", - " return x\n" + " return x\n", + " \n", + "edited, og = next(iter(train_dataloader))" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "\n", + "def plot_histograms(original_histogram, edited_histogram, predicted_histogram):\n", + " fig = plt.figure(figsize=(15, 5))\n", + " tensors = [original_histogram.numpy().squeeze(), edited_histogram.numpy().squeeze(), predicted_histogram.numpy().squeeze()]\n", + "\n", + " for i, tensor in enumerate(tensors, 1):\n", + " ax = fig.add_subplot(1, 3, i, projection='3d')\n", + "\n", + " x, y, z = np.indices(tensor.shape)\n", + " x = x.flatten()\n", + " y = y.flatten()\n", + " z = z.flatten()\n", + " values = tensor.flatten()\n", + "\n", + " sizes = values * 5000 \n", + "\n", + " colors = np.vstack((x, y, z)).T / 31\n", + "\n", + " sc = ax.scatter(x, y, z, c=colors, s=sizes, marker='o', alpha=0.5)\n", + "\n", + " ax.set_xlim([0, 31])\n", + " ax.set_ylim([0, 31])\n", + " ax.set_zlim([0, 31])\n", + "\n", + " ax.set_title(f'Tensor {i}')\n", + " return fig\n", + "\n", + "\n", + "# plot_histograms(original_histogram, edited_histogram, edited_histogram)" ] }, { @@ -142,9 +193,13 @@ "outputs": [ { "data": { - "image/png": "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", + "application/vnd.jupyter.widget-view+json": { + "model_id": "b1a1b0d47c494d52af3f9a6a8eda7127", + "version_major": 2, + "version_minor": 0 + }, "text/plain": [ - "
" + "Epoch 0: 0%| | 0/17562 [00:00 37\u001b[0m total_loss \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[43mloss\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mitem\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 38\u001b[0m losses\u001b[38;5;241m.\u001b[39mappend(loss\u001b[38;5;241m.\u001b[39mitem())\n\u001b[1;32m 39\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(losses) \u001b[38;5;241m%\u001b[39m \u001b[38;5;241m200\u001b[39m \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m0\u001b[39m:\n", - "\u001b[0;31mKeyboardInterrupt\u001b[0m: " - ] + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "006686e41c8f4144abe4fbf0be7221ae", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Epoch 1: 0%| | 0/17562 [00:00
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "# 32 / 16 -> 2\n", + "# 32 / 8 -> 4\n", + "# 4 -> 8\n", + "\n", + "a = F.avg_pool3d(original_histogram, 4)\n", + "a /= torch.sum(a)\n", + "plot_histograms([\n", + " original_histogram.cpu().numpy().squeeze(),\n", + " a.cpu().numpy().squeeze(),\n", + "])" + ] } ], "metadata": {