From fdd3641310e70421c10404101487d2878b07a88b Mon Sep 17 00:00:00 2001 From: "Dove. J. Kim" Date: Mon, 23 Oct 2023 13:53:40 +0900 Subject: [PATCH 1/8] ['23.10.23][FIX] fix tensor size error --- vivq.py | 36 +++++++++++++++++++++++++++--------- 1 file changed, 27 insertions(+), 9 deletions(-) mode change 100644 => 100755 vivq.py diff --git a/vivq.py b/vivq.py old mode 100644 new mode 100755 index c9e6fe9..2d01548 --- a/vivq.py +++ b/vivq.py @@ -188,6 +188,8 @@ def forward(self, x, dim=-1): # self.vquantizer.codebook.weight.data = kmeans.centroids.detach() qe, (_, commit_loss), indices = self.vquantizer(x, dim=dim) else: + self.q_step_counter = torch.tensor(1001).to(torch.device('cuda')) + if self.q_step_counter < self.q_init: qe, commit_loss, indices = x, x.new_tensor(0), None else: @@ -197,8 +199,9 @@ def forward(self, x, dim=-1): class VIVQ(nn.Module): - def __init__(self, base_channels=3, c_hidden=512, c_codebook=16, codebook_size=1024): + def __init__(self, model = 'vivq', base_channels=3, c_hidden=512, c_codebook=16, codebook_size=1024): super().__init__() + self.model = model self.encoder = Encoder(base_channels, c_hidden=c_hidden) self.cod_mapper = nn.Sequential( nn.Conv3d(c_hidden, c_codebook, kernel_size=1), @@ -215,16 +218,34 @@ def __init__(self, base_channels=3, c_hidden=512, c_codebook=16, codebook_size=1 ) def encode(self, image, video): + x = self.encoder(image, video) # B x T x (H x W) x C + x = self.cod_mapper(x) shape = x.shape + x = x.view(*x.shape[:3], x.shape[3]*x.shape[4]).permute(0, 2, 3, 1) qe, commit_loss, indices = self.vqmodule(x, dim=-1) - # indices = indices.view(image.shape[0], -1) - if video is not None: - indices = indices.view(image.shape[0], *BASE_SHAPE) + + if self.training: + + if video is not None: + indices = indices.view(image.shape[0], *BASE_SHAPE) + else: + indices = indices.view(image.shape[0], *BASE_SHAPE[1:]).unsqueeze(1) + else: - indices = indices.view(image.shape[0], *BASE_SHAPE[1:]).unsqueeze(1) + + + if self.model == 'vivq': + indices = indices.view(image.shape[0], -1) + + else: + if video is not None: + indices = indices.view(image.shape[0], *BASE_SHAPE) + else: + indices = indices.view(image.shape[0], *BASE_SHAPE[1:]).unsqueeze(1) + return (x, qe), commit_loss, indices, shape def decode(self, x, shape=None): @@ -240,11 +261,9 @@ def decode_indices(self, x, shape=None): return self.decode(self.vqmodule.vquantizer.idx2vq(x, dim=-1).permute(0, 4, 1, 2, 3)) def forward(self, image, video=None): - # print(image.shape, video.shape) (_, qe), commit_loss, _, shape = self.encode(image, video) - # print(qe.shape) decoded = self.decode(qe, shape) - # print(decoded.shape) + return decoded, commit_loss @@ -256,7 +275,6 @@ def forward(self, image, video=None): # e = Encoder(c_in=3).to(device) # d = Decoder(c_out=3).to(device) vq = VIVQ(c_hidden=512).to(device) - print(sum([p.numel() for p in vq.parameters()])) # rb = ResBlockvq(3, 100).to(device) # print(rb(x).shape) # r = e(image, video) From ad97ead35693d826dacf653873fd514e861d7c88 Mon Sep 17 00:00:00 2001 From: "Dove. J. Kim" Date: Mon, 23 Oct 2023 13:54:27 +0900 Subject: [PATCH 2/8] ['23.10.23][CHORE] add to .gitignore --- .gitignore | 1 + 1 file changed, 1 insertion(+) create mode 100755 .gitignore diff --git a/.gitignore b/.gitignore new file mode 100755 index 0000000..4178f89 --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +**/.ipynb_checkpoints \ No newline at end of file From 3e170872c13dcebbae95e92f02138c9ef5239109 Mon Sep 17 00:00:00 2001 From: "Dove. J. Kim" Date: Mon, 23 Oct 2023 13:55:23 +0900 Subject: [PATCH 3/8] ['23.10.23][TEST] add to .ipynb format test codes --- ipynb/log_writer.ipynb | 168 ++++++++++++++ ipynb/partial_maskgit_test.ipynb | 382 +++++++++++++++++++++++++++++++ ipynb/test_vivq.ipynb | 243 ++++++++++++++++++++ 3 files changed, 793 insertions(+) create mode 100755 ipynb/log_writer.ipynb create mode 100755 ipynb/partial_maskgit_test.ipynb create mode 100755 ipynb/test_vivq.ipynb diff --git a/ipynb/log_writer.ipynb b/ipynb/log_writer.ipynb new file mode 100755 index 0000000..c59e414 --- /dev/null +++ b/ipynb/log_writer.ipynb @@ -0,0 +1,168 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "8915f31f-c47c-4508-a8ec-090ead0429ab", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "\n", + "from matplotlib import patches as patches\n", + "from easydict import EasyDict as edict\n", + "from matplotlib import pyplot as plt\n", + "import torch" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "979650dd-e16d-4f9c-b57e-b2d40b021f31", + "metadata": {}, + "outputs": [], + "source": [ + "SEP = os.path.sep\n", + "ROOT_PATH = SEP.join(os.getcwd().split(SEP)[:-3])\n", + "LOG_PATH = f'{ROOT_PATH}/phenaki/phenaki/results/Paella_Test/log.pt'" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "eaa1460d-d819-4fa9-88b6-dc5606a40858", + "metadata": {}, + "outputs": [], + "source": [ + "def texting_min_max(ax, list_, gmax, gmin, type_ = 'loss'):\n", + "\n", + " for idx in range(0, 10_000 * (steps // 10_000 + 1), 10_000):\n", + " ax.axvline(x = idx, color = 'r', linestyle = ':')\n", + "\n", + " interval = [list_[idx * 5 : (idx + 1) * 5] \n", + " for idx in range(len(list_)//5)]\n", + " interval_min = [min(loss) for loss in interval]\n", + " interval_min_idx = [list_.index(loss) for loss in interval_min] \n", + " \n", + " interval_max = [max(loss) for loss in interval]\n", + " interval_max_idx = [list_.index(loss) for loss in interval_max] \n", + " \n", + " for min_idx, max_idx, min_, max_ in zip(interval_min_idx, interval_max_idx, interval_min, interval_max):\n", + "\n", + " if min_ == gmin:\n", + " ax.add_patch(patches.Ellipse((min_idx *2000, min_), height = 0.5 if type_ == 'loss' else 0.03, \n", + " width = 1000, edgecolor = 'black', fill = True, color = 'yellow'))\n", + "\n", + " if max_ == gmax:\n", + " ax.add_patch(patches.Ellipse((max_idx *2000, max_), height = 0.5 if type_ == 'loss' else 0.03, \n", + " width = 1000, edgecolor = 'black', fill = True, color = 'yellow'))\n", + " \n", + " ax.text(min_idx * 2000, min_, f'{min_:.3f}', ha = 'center')\n", + " ax.text(max_idx * 2000, max_, f'{max_:.3f}', ha = 'center')" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "b68b83d2-9da9-47c4-8be7-322be5612529", + "metadata": {}, + "outputs": [], + "source": [ + "logs = edict(torch.load(LOG_PATH))\n", + "steps = logs.step\n", + "\n", + "curr_losses = logs.curr_losses\n", + "losses = logs.losses\n", + "\n", + "curr_accuracy = logs.curr_accuracies\n", + "accuracy = logs.accuracies\n", + "\n", + "max_curr_loss = max(curr_losses)\n", + "max_curr_loss_idx = curr_losses.index(max_curr_loss)\n", + "\n", + "min_curr_loss = min(curr_losses)\n", + "min_curr_loss_idx = curr_losses.index(min_curr_loss)\n", + "\n", + "max_curr_acc = max(curr_accuracy)\n", + "max_curr_acc_idx = curr_accuracy.index(max_curr_acc)\n", + "\n", + "min_curr_acc = min(curr_accuracy)\n", + "min_curr_acc_idx = curr_accuracy.index(min_curr_acc)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "7f5d0b6b-5ab2-4538-9c22-03611fd9efc3", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_3398204/955198278.py:17: UserWarning: Setting the 'color' property will override the edgecolor or facecolor properties.\n", + " ax.add_patch(patches.Ellipse((min_idx *2000, min_), height = 0.5 if type_ == 'loss' else 0.03,\n", + "/tmp/ipykernel_3398204/955198278.py:21: UserWarning: Setting the 'color' property will override the edgecolor or facecolor properties.\n", + " ax.add_patch(patches.Ellipse((max_idx *2000, max_), height = 0.5 if type_ == 'loss' else 0.03,\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "steps_ = [step for step in range(0, steps + 1, 2000)]\n", + "_, axes = plt.subplots(1, 2, figsize = (17, 5))\n", + "\n", + "axes[0].plot(steps_, losses, label = 'total')\n", + "axes[0].plot(steps_, curr_losses, label = 'current')\n", + "axes[0].set_title(f'loss (gmin : {min_curr_loss:.3f}, gmax : {max_curr_loss:.3f})')\n", + "axes[0].legend(loc = 'upper left')\n", + "texting_min_max(axes[0], curr_losses, max_curr_loss, min_curr_loss)\n", + "\n", + "\n", + "axes[1].plot(steps_, accuracy, label = 'total')\n", + "axes[1].plot(steps_, curr_accuracy, label = 'current')\n", + "axes[1].set_title(f'accuracy (gmin : {min_curr_acc:.3f}, gmax : {max_curr_acc:.3f})')\n", + "axes[1].legend(loc = 'upper left')\n", + "texting_min_max(axes[1], curr_accuracy, max_curr_acc, min_curr_acc, 'accu')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "44b6607b-a144-47ff-ad21-e0c224dc5338", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "torch_1.x", + "language": "python", + "name": "torch_1.x" + }, + "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.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/ipynb/partial_maskgit_test.ipynb b/ipynb/partial_maskgit_test.ipynb new file mode 100755 index 0000000..ea464b8 --- /dev/null +++ b/ipynb/partial_maskgit_test.ipynb @@ -0,0 +1,382 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "470f8139-b421-4f48-8200-f23b562ab73c", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/root/anaconda3/envs/torch_1.x/lib/python3.10/site-packages/torchvision/io/image.py:13: UserWarning: Failed to load image Python extension: libtorch_cuda_cu.so: cannot open shared object file: No such file or directory\n", + " warn(f\"Failed to load image Python extension: {e}\")\n", + "/root/anaconda3/envs/torch_1.x/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + } + ], + "source": [ + "import random\n", + "import math\n", + "import gc\n", + "import os\n", + "\n", + "from torch.utils.data import Dataset, DataLoader, IterableDataset\n", + "from webdataset.handlers import warn_and_continue\n", + "from easydict import EasyDict as edict\n", + "from matplotlib import pyplot as plt\n", + "from open_clip import tokenizer\n", + "from einops import rearrange\n", + "import webdataset as wds\n", + "import numpy as np\n", + "import torchvision\n", + "import open_clip\n", + "import torch\n", + "import cv2\n", + "\n", + "from distributed import init_distributed_device, is_primary\n", + "from vivq import VIVQ, BASE_SHAPE\n", + "from utils import sample_paella\n", + "from paella import DenoiseUNet" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "2e5743c5-35ae-4d20-9d37-d1deb7634895", + "metadata": {}, + "outputs": [], + "source": [ + "gc.collect()\n", + "torch.cuda.empty_cache()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "3f43a5f9-9136-4aba-8dc7-893953d1bf26", + "metadata": {}, + "outputs": [], + "source": [ + "SEP = os.path.sep\n", + "ROOT_PATH = SEP.join(os.getcwd().split(SEP)[:-4])" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "f3a355cb-b491-481f-9068-836a0ae0d227", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Launching with args: {'run_name': 'Paella_Test', 'model': 'maskgit', 'dataset': 'first_stage', 'urls': {'videos': '/home/projects/DataSets/webvid/dataset/00000.tar', 'images': '/home/projects/DataSets/Coyo/coyo-700m-webdataset/{00000..03506}.tar'}, 'total_steps': 300000, 'batch_size': 4, 'num_workers': 1, 'log_period': 2000, 'extra_ckpt': 10000, 'accum_grad': 2, 'vq_path': 'models/vivq_8192_drop_video/model_250000.pt', 'du_path': 'models/Paella_Test_/model_90000.pt', 'dim': 1224, 'num_tokens': 8192, 'max_seq_len': 1536, 'depth': 22, 'dim_context': 1024, 'heads': 22, 'clip_len': 10, 'skip_frames': 5, 'n_nodes': 1, 'dist_url': 'env://', 'dist_backend': 'nccl', 'no_set_device_rank': False}\n" + ] + } + ], + "source": [ + "args = edict({})\n", + "args.run_name = \"Paella_Test\"\n", + "args.model = \"maskgit\"\n", + "args.dataset = \"first_stage\"\n", + "args.urls = {\n", + "\n", + " \"videos\": \"/home/projects/DataSets/webvid/dataset/00000.tar\",\n", + " \"images\": \"/home/projects/DataSets/Coyo/coyo-700m-webdataset/{00000..03506}.tar\"\n", + "}\n", + "\n", + "args.total_steps = 300_000\n", + "args.batch_size = 4\n", + "args.num_workers = 1\n", + "args.log_period = 2000\n", + "args.extra_ckpt = 10_000\n", + "args.accum_grad = 2\n", + "\n", + "args.vq_path = 'models/vivq_8192_drop_video/model_250000.pt' \n", + "args.du_path = 'models/Paella_Test_/model_90000.pt'\n", + "args.dim = 1224 # 1224\n", + "args.num_tokens = 8192\n", + "args.max_seq_len = 6 * 16 * 16\n", + "args.depth = 22 # 22\n", + "args.dim_context = 1024 # for clip, 512 for T5\n", + "args.heads = 22 # 22\n", + "\n", + "args.clip_len = 10\n", + "args.skip_frames = 5\n", + "\n", + "args.n_nodes = 1\n", + "args.dist_url = \"env://\"\n", + "args.dist_backend = \"nccl\"\n", + "args.no_set_device_rank = False\n", + "\n", + "print(\"Launching with args: \", args)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "dc057466-129f-4faa-aba0-2b70ccb1ef0d", + "metadata": {}, + "outputs": [], + "source": [ + "class MixImageVideoDataset(IterableDataset):\n", + " def __init__(self, args):\n", + " super().__init__()\n", + " self.batch_size = args.batch_size # TODO: split this into image bs and video bs\n", + " self.video_dataset, self.image_dataset = self.init_dataloaders(args)\n", + "\n", + " def init_dataloaders(self, args):\n", + " video_dataset = wds.WebDataset(args.urls[\"videos\"], resampled=True, handler=warn_and_continue).decode(wds.torch_video,\n", + " handler=warn_and_continue).map(ProcessVideos(clip_len=args.clip_len, skip_frames=args.skip_frames),\n", + " handler=warn_and_continue).to_tuple(\"image\", \"video\", \"txt\", handler=warn_and_continue).shuffle(690, handler=warn_and_continue)\n", + " image_dataset = wds.WebDataset(args.urls[\"images\"], resampled=True, handler=warn_and_continue).decode(\"rgb\").map(\n", + " ProcessImages(), handler=warn_and_continue).to_tuple(\"jpg\", \"txt\", handler=warn_and_continue).shuffle(6969, initial=10000)\n", + " return video_dataset, image_dataset\n", + "\n", + " def __iter__(self):\n", + " sources = [iter(self.image_dataset), iter(self.video_dataset)]\n", + " # sources = [iter(self.video_dataset), iter(self.image_dataset)]\n", + " # sources = [iter(self.video_dataset)]\n", + " while True:\n", + " for source in sources:\n", + " for _ in range(self.batch_size):\n", + " try:\n", + " yield next(source)\n", + " except StopIteration:\n", + " return\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "9287e3a2-6fcc-4885-833a-dfca0ed419ac", + "metadata": {}, + "outputs": [], + "source": [ + "def collate_first_stage(batch):\n", + " images = torch.stack([i[0] for i in batch], dim=0)\n", + " videos = torch.stack([i[1] for i in batch], dim=0)\n", + " return [images, videos]\n", + "\n", + "\n", + "def collate_second_stage(batch):\n", + "\n", + " if len(batch[0]) == 2:\n", + " images = torch.stack([i[0] for i in batch], dim=0)\n", + " videos = None\n", + " captions = [i[1] for i in batch]\n", + " else:\n", + " images = torch.stack([i[0] for i in batch], dim=0)\n", + " videos = torch.stack([i[1] for i in batch], dim=0)\n", + " captions = [i[2] for i in batch]\n", + " \n", + " return [images, videos, captions]\n", + "\n", + "\n", + "class ProcessVideos:\n", + " def __init__(self, clip_len=10, skip_frames=4):\n", + " self.video_transform = torchvision.transforms.Compose([\n", + " torchvision.transforms.Resize(128),\n", + " torchvision.transforms.RandomCrop(128)\n", + " ])\n", + " self.clip_len = clip_len\n", + " self.skip_frames = skip_frames\n", + " print(f\"Using clip length of {clip_len} and {skip_frames} skip frames.\")\n", + "\n", + " def __call__(self, data):\n", + " video = data[\"mp4\"][0]\n", + " max_seek = video.shape[0] - (self.clip_len * self.skip_frames)\n", + " if max_seek < 0:\n", + " raise Exception(f\"Video too short ({video.shape[0]} frames), skipping.\")\n", + " start = math.floor(random.uniform(0., max_seek))\n", + " video = video[start:start+(self.clip_len*self.skip_frames)+1:self.skip_frames]\n", + " video = video.permute(0, 3, 1, 2) / 255.\n", + " if self.video_transform:\n", + " video = self.video_transform(video)\n", + " image, video = video[0], video[1:]\n", + " data[\"image\"] = image\n", + " data[\"video\"] = video\n", + " if video.shape[0] != 10:\n", + " raise Exception(\"Not 10 frames. But I should find the real cause lol for this happening.\")\n", + " return data\n", + "\n", + "\n", + "class ProcessImages:\n", + " def __init__(self,):\n", + " self.transforms = torchvision.transforms.Compose([\n", + " torchvision.transforms.ToTensor(),\n", + " torchvision.transforms.Resize(128),\n", + " torchvision.transforms.RandomCrop(128),\n", + " ])\n", + "\n", + " def __call__(self, data):\n", + " data[\"jpg\"] = self.transforms(data[\"jpg\"])\n", + " return data\n", + "\n", + "\n", + "def get_dataloader(args):\n", + " if args.dataset == \"first_stage\":\n", + " dataset = wds.WebDataset(args.dataset_path, resampled=True, handler=warn_and_continue).decode(wds.torch_video,\n", + " handler=warn_and_continue).map(ProcessVideos(clip_len=args.clip_len, skip_frames=args.skip_frames),\n", + " handler=warn_and_continue).to_tuple(\"image\", \"video\", handler=warn_and_continue).shuffle(690, handler=warn_and_continue)\n", + " \n", + " dataloader = DataLoader(dataset, batch_size=args.batch_size, num_workers=args.num_workers, collate_fn=collate_first_stage) # TODO: num_workers=args.num_workers\n", + "\n", + " elif args.dataset == \"second_stage\":\n", + " dataset = MixImageVideoDataset(args)\n", + " dataloader = DataLoader(dataset, batch_size=args.batch_size, collate_fn=collate_second_stage, num_workers=args.num_workers) # TODO: num_workers=args.num_workers\n", + "\n", + " else:\n", + " dataset = VideoDataset(video_transform=transforms)\n", + " dataloader = DataLoader(dataset, batch_size=args.batch_size, num_workers=args.num_workers) # TODO: add num_workers=args.num_workers\n", + " return dataloader" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "009d46c6-e1d8-4e4c-8c6c-7b9c9dad5f86", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "모델 로딩 완.\n" + ] + } + ], + "source": [ + "device = init_distributed_device(args)\n", + "\n", + "vqmodel = VIVQ(codebook_size=args.num_tokens, model = 'maskgit').to(device)\n", + "vqmodel.load_state_dict(torch.load(args.vq_path, map_location=device))\n", + "vqmodel.vqmodule.q_step_counter += int(1e9)\n", + "vqmodel.eval().requires_grad_(False)\n", + "\n", + "model = DenoiseUNet(num_labels = args.num_tokens, down_levels = [4, 6, 8],\n", + " up_levels = [8, 6, 4], c_clip = args.dim_context).to(device)\n", + "\n", + "# model.load_state_dict(torch.load(args.du_path, map_location = device))\n", + "\n", + "clip_model, _, _ = open_clip.create_model_and_transforms('ViT-H-14', pretrained = 'laion2b_s32b_b79k',\n", + " cache_dir = '/fsx/max/.cache')\n", + "\n", + "del clip_model.visual\n", + "model.eval()\n", + "clip_model = clip_model.to(device).eval().requires_grad_(False)\n", + "\n", + "print('모델 로딩 완.')" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "3fab0607-8715-4fe1-b8f3-deee13a789cd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using clip length of 10 and 5 skip frames.\n" + ] + } + ], + "source": [ + "dataset = wds.WebDataset(args.urls[\"videos\"], resampled=True, handler=warn_and_continue).decode(wds.torch_video,\n", + " handler=warn_and_continue).map(ProcessVideos(clip_len=args.clip_len, skip_frames=args.skip_frames),\n", + " handler=warn_and_continue).to_tuple(\"image\", \"video\", \"txt\", handler=warn_and_continue).shuffle(690, handler=warn_and_continue)\n", + "dataloader = DataLoader(dataset, batch_size=args.batch_size, num_workers=args.num_workers, collate_fn=collate_first_stage)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "db18e543-b071-4f5e-ada9-56294ee5a46c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(torch.Size([4, 3, 128, 128]), torch.Size([4, 10, 3, 128, 128]))" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sample = next(iter(dataloader))\n", + "image, video = sample\n", + "image.size(), video.size()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "8dcd4ba1-142c-46d7-8dbd-8f384ec50f8f", + "metadata": {}, + "outputs": [], + "source": [ + "cool_captions_text = open('cool_captions.txt').read().splitlines()\n", + "text_tokens = tokenizer.tokenize(cool_captions_text).to(device)\n", + "text_tokens_embeddings = clip_model.encode_text(text_tokens).float() " + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "f1212368-7642-4fe2-9a8b-3162fba55813", + "metadata": {}, + "outputs": [], + "source": [ + "cool_captions_sampled = []\n", + "for caption_embedding in text_tokens_embeddings.chunk(10):\n", + "\n", + " caption_embedding = caption_embedding[0].float().to(device)\n", + " caption_embedding = caption_embedding.unsqueeze(0)\n", + " \n", + " sampled_text = sample_paella(model, caption_embedding)\n", + " sampled_text = vqmodel.decode_indices(sampled_text)\n", + "\n", + " for s in sampled_text:\n", + " cool_captions_sampled.append(s.cpu())" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2f7dfe17-6941-4e9e-b44b-505d158b6112", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "torch_1.x", + "language": "python", + "name": "torch_1.x" + }, + "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.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/ipynb/test_vivq.ipynb b/ipynb/test_vivq.ipynb new file mode 100755 index 0000000..a2621e0 --- /dev/null +++ b/ipynb/test_vivq.ipynb @@ -0,0 +1,243 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 8, + "id": "3ff8c9ed-9f54-4f62-8ca0-71a692c1ba66", + "metadata": {}, + "outputs": [], + "source": [ + "import random\n", + "import math\n", + "import gc\n", + "import os\n", + "\n", + "from torch.utils.data import DataLoader\n", + "from matplotlib import pyplot as plt\n", + "from imutils.paths import list_files\n", + "import torchvision.utils as vutils\n", + "import torchvision.io\n", + "import numpy as np\n", + "import torch\n", + "import cv2\n", + "\n", + "from utils import calculate_psnr, calculate_ssim\n", + "from utils import transforms, VideoDataset\n", + "from vivq import VIVQ" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "e7058d07-6e78-4cf1-b1ef-d7ea7d8389f1", + "metadata": {}, + "outputs": [], + "source": [ + "gc.collect()\n", + "torch.cuda.empty_cache()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "77a0fe4f-2b06-40cd-88a7-eeafe6b1fb1c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "('/home/projects', '/home/projects/DataSets')" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "SEP = os.path.sep\n", + "ROOT_PATH = SEP.join(os.getcwd().split(SEP)[:-3])\n", + "\n", + "DATA_PATH = f'{ROOT_PATH}/DataSets'\n", + "ROOT_PATH, DATA_PATH" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "49d06b20-68ec-4c59-847f-d78acf42a776", + "metadata": {}, + "outputs": [], + "source": [ + "def load_video(path, clip_len = 10, skip_frames = 3):\n", + "\n", + " video_transform = torchvision.transforms.Compose([\n", + " torchvision.transforms.Resize(128),\n", + " torchvision.transforms.CenterCrop(128)\n", + " ])\n", + "\n", + " video, _, _ = torchvision.io.read_video(path)\n", + " video = video.permute(0, 3, 1, 2) / 255.\n", + " max_seek = video.shape[0] - (clip_len * skip_frames)\n", + "\n", + " start = math.floor(random.uniform(0., max_seek))\n", + " # video = video[:30]\n", + "\n", + " if video_transform:\n", + " video = video_transform(video)\n", + "\n", + " image, video = video[0], video[1: ]\n", + " return image.unsqueeze(0), video.unsqueeze(0)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "712b9658-4a2e-4194-b4c0-a9a093eba46a", + "metadata": {}, + "outputs": [], + "source": [ + "sample_vid = '/home/projects/DataSets/kinetic400/tossing_coin/TMzJ-y3Ne5k.mp4'\n", + "# sample_vid = '/home/projects/DataSets/Moments_in_Time_Raw/validation/drenching/yt-jU0lcu7Bjrk_871.mp4'\n", + "# sample_vid = '/home/projects/DataSets/webvid/validation/00834012.mp4'" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "363d973e-0649-4a5c-9e53-b864f3b9470f", + "metadata": {}, + "outputs": [], + "source": [ + "name = 'vivq_2'\n", + "device = 'cuda'\n", + "num_frames = 50\n", + "skip_frames = 5\n", + "hidden_C = 512" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "67975d9a-2738-4029-b4bb-f703554ccda0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[270000]\n", + "모델 로딩 완\n", + "PSNR : 23.552, SSIM : 0.427\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "\n" + ] + } + ], + "source": [ + "for epoch in [270_000]:\n", + "\n", + " print(f'[{epoch}]')\n", + " MODEL_PATH = f'{ROOT_PATH}/video_generation/phenaki/phenaki/models/vivq_8192_drop_video_k400/model_{epoch}.pt'\n", + " model = VIVQ(c_hidden = hidden_C, codebook_size = 8192).to(device)\n", + " state_dict = torch.load(MODEL_PATH)\n", + " \n", + " model.load_state_dict(state_dict)\n", + " model.eval().requires_grad_(False)\n", + " \n", + " print('모델 로딩 완')\n", + " \n", + " image, video = load_video(sample_vid, clip_len = num_frames, skip_frames = skip_frames)\n", + " image, video = image.to(device), video.to(device)\n", + "\n", + " recon, _ = model(image, video)\n", + " folder_name = sample_vid.split(SEP)[-2]\n", + " file_name = os.path.splitext(sample_vid.split(SEP)[-1])[0]\n", + " \n", + " os.makedirs(f'results/valid/{folder_name}', exist_ok = True)\n", + " \n", + " orig = torch.cat([image.unsqueeze(1), video], dim = 1)\n", + " orig = orig[0]\n", + " recon = recon[0]\n", + "\n", + " save_path = f'results/valid/{folder_name}/{file_name}_{str(epoch).zfill(6)}_{num_frames}'\n", + " comp = vutils.make_grid(torch.cat([orig, recon]), nrow = len(orig)).detach().cpu()\n", + " vutils.save_image(comp, f'{save_path}.jpg')\n", + " \n", + " origs_ = orig.detach().cpu()\n", + " recons_ = recon.detach().cpu()\n", + "\n", + " fourcc = cv2.VideoWriter_fourcc('m', 'p', '4', 'v')\n", + " output = cv2.VideoWriter(f'{save_path}.mp4', fourcc, 30.0, (128, 128))\n", + " PSNR_, SSIM_ = [], []\n", + " for ori, rec in zip(origs_, recons_):\n", + "\n", + "\n", + " rec_ = np.transpose(rec.detach().cpu().numpy(), (1, 2, 0)) * 255\n", + " rec_ = cv2.cvtColor(rec_, cv2.COLOR_BGR2RGB)\n", + " output.write(rec_.astype(np.uint8))\n", + "\n", + " \n", + " ori = np.transpose(ori.detach().cpu().numpy(), (1, 2, 0))\n", + " rec = np.transpose(rec.detach().cpu().numpy(), (1, 2, 0))\n", + " \n", + " PSNR_.append(calculate_psnr(ori,rec))\n", + " SSIM_.append(calculate_ssim(ori, rec))\n", + "\n", + " output.release()\n", + " \n", + " print(f'PSNR : {np.mean(PSNR_):.3f}, SSIM : {np.mean(SSIM_):.3f}')\n", + " plt.imshow(comp.permute(1, 2, 0))\n", + " plt.axis(False)\n", + " plt.show()\n", + " print('\\n\\n')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e73770f6-d3ac-4450-bab0-aa8761d1901f", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "torch_1.x", + "language": "python", + "name": "torch_1.x" + }, + "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.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 1663f4e2491aa79ac3b7942209c3b86a9baf926c Mon Sep 17 00:00:00 2001 From: "Dove. J. Kim" Date: Mon, 23 Oct 2023 13:55:55 +0900 Subject: [PATCH 4/8] ['23.10.23][FEAT] add .ipynb format train codes --- ipynb/train_MiT.ipynb | 278 +++++++++++ ipynb/train_kinetic400.ipynb | 942 +++++++++++++++++++++++++++++++++++ ipynb/train_maskgit.ipynb | 265 ++++++++++ 3 files changed, 1485 insertions(+) create mode 100755 ipynb/train_MiT.ipynb create mode 100755 ipynb/train_kinetic400.ipynb create mode 100755 ipynb/train_maskgit.ipynb diff --git a/ipynb/train_MiT.ipynb b/ipynb/train_MiT.ipynb new file mode 100755 index 0000000..87c93da --- /dev/null +++ b/ipynb/train_MiT.ipynb @@ -0,0 +1,278 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "d699d4f8-ad4a-4c8d-98c3-a73270160f9f", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/root/anaconda3/envs/torch_1.x/lib/python3.10/site-packages/torchvision/io/image.py:13: UserWarning: Failed to load image Python extension: libtorch_cuda_cu.so: cannot open shared object file: No such file or directory\n", + " warn(f\"Failed to load image Python extension: {e}\")\n" + ] + } + ], + "source": [ + "import gc\n", + "\n", + "from easydict import EasyDict as edict\n", + "import torch\n", + "\n", + "import train_vivq" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "a54dd3d1-ac81-469d-ab5b-d157fcb2b286", + "metadata": {}, + "outputs": [], + "source": [ + "gc.collect()\n", + "torch.cuda.empty_cache()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "9699a6e7-38ff-4f50-9585-fec15a465858", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Launching with args: {'run_name': 'vivq_8192_drop_video', 'model': 'vivq', 'dataset': 'first_stage', 'dataset_path': '/home/projects/DataSets/Moments_in_Time_Raw/tars/{0..333}.tar', 'total_steps': 5000000, 'batch_size': 10, 'num_workers': 10, 'log_period': 100, 'extra_ckpt': 1000, 'accum_grad': 1, 'codebook_size': 8192, 'clip_len': 10, 'skip_frames': 5, 'n_nodes': 1, 'node_id': 0, 'devices': [1]}\n" + ] + } + ], + "source": [ + "args = edict({})\n", + "args.run_name = \"vivq_8192_drop_video\"\n", + "args.model = \"vivq\"\n", + "args.dataset = \"first_stage\"\n", + "args.dataset_path = \"/home/projects/DataSets/Moments_in_Time_Raw/tars/{0..333}.tar\"\n", + "args.total_steps = 5_000_000\n", + "args.batch_size = 10\n", + "args.num_workers = 10\n", + "args.log_period = 100\n", + "args.extra_ckpt = 1_000\n", + "args.accum_grad = 1\n", + "\n", + "args.codebook_size = 8192\n", + "args.clip_len = 10\n", + "args.skip_frames = 5\n", + "\n", + "args.n_nodes = 1\n", + "args.node_id = 0\n", + "args.devices = [1]\n", + "\n", + "print(\"Launching with args: \", args)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c1b79e10-b597-447f-9b15-a3ca7467949b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Starting run 'vivq_8192_drop_video'....\n", + "Batch Size check: 10\n", + "Number of Parameters: 43389316\n", + "Setting up [LPIPS] perceptual loss: trunk [vgg], v[0.1], spatial [off]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/root/anaconda3/envs/torch_1.x/lib/python3.10/site-packages/torchvision/models/_utils.py:208: UserWarning: The parameter 'pretrained' is deprecated since 0.13 and will be removed in 0.15, please use 'weights' instead.\n", + " warnings.warn(\n", + "/root/anaconda3/envs/torch_1.x/lib/python3.10/site-packages/torchvision/models/_utils.py:223: UserWarning: Arguments other than a weight enum or `None` for 'weights' are deprecated since 0.13 and will be removed in 0.15. The current behavior is equivalent to passing `weights=VGG16_Weights.IMAGENET1K_V1`. You can also use `weights=VGG16_Weights.DEFAULT` to get the most up-to-date weights.\n", + " warnings.warn(msg)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loading model from: /root/anaconda3/envs/torch_1.x/lib/python3.10/site-packages/lpips/weights/v0.1/vgg.pth\n", + "Using clip length of 10 and 5 skip frames.\n", + "\n", + "\n", + "-1\n", + "\n", + "\n", + "Loading last checkpoint....\n", + "Loaded model....\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/root/anaconda3/envs/torch_1.x/lib/python3.10/site-packages/torch/optim/lr_scheduler.py:139: UserWarning: Detected call of `lr_scheduler.step()` before `optimizer.step()`. In PyTorch 1.1.0 and later, you should call them in the opposite order: `optimizer.step()` before `lr_scheduler.step()`. Failure to do this will result in PyTorch skipping the first value of the learning rate schedule. See more details at https://pytorch.org/docs/stable/optim.html#how-to-adjust-learning-rate\n", + " warnings.warn(\"Detected call of `lr_scheduler.step()` before `optimizer.step()`. \"\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Initialized scheduler\n", + "Sanity check => Last-LR: 0.00025369065938131874 == Current-LR: 0.00025369065938131874 -> True\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 8%|▊ | 419601/5000000 [00:00 Last-LR: 0.0005840012800042667 == Current-LR: 0.0005840012800042667 -> True\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 2%|▏ | 54011/3000000 [01:17<1243:04:19, 1.52s/it, loss=6.4, curr_loss=5.34, acc=0.359, curr_acc=0.466, ppx=209, lr=0.000584, gn=1.4] " + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "error:image file is truncated (4 bytes not processed)\n", + "\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 2%|▏ | 56001/3000000 [16:07<921:21:44, 1.13s/it, loss=6.39, curr_loss=7.3, acc=0.36, curr_acc=0.227, ppx=1.48e+3, lr=0.0006, gn=1.59] " + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Took 2.3101646900177 seconds to sample 44 captions.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 2%|▏ | 58001/3000000 [26:26<549:18:22, 1.49it/s, loss=6.42, curr_loss=8.81, acc=0.36, curr_acc=0.192, ppx=6.67e+3, lr=0.000616, gn=22.8] " + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Took 1.5478556156158447 seconds to sample 44 captions.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 2%|▏ | 60000/3000000 [34:51<350:44:13, 2.33it/s, loss=6.41, curr_loss=7.3, acc=0.36, curr_acc=0.25, ppx=1.49e+3, lr=0.000632, gn=2.44] " + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Took 1.5461187362670898 seconds to sample 44 captions.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 2%|▏ | 62001/3000000 [43:18<628:02:02, 1.30it/s, loss=6.41, curr_loss=8.95, acc=0.361, curr_acc=0.173, ppx=7.7e+3, lr=0.000648, gn=12.7] " + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Took 1.546952486038208 seconds to sample 44 captions.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 2%|▏ | 62560/3000000 [45:31<817:51:36, 1.00s/it, loss=6.44, curr_loss=8.16, acc=0.36, curr_acc=0.306, ppx=3.51e+3, lr=0.000652, gn=14.6] " + ] + } + ], + "source": [ + "train_maskgit.train(args)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8d8386ea-1cd7-444c-a271-4257cc06bf38", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d45975a3-b8ef-4ce3-afa0-9e5c2bea3512", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "torch_1.x", + "language": "python", + "name": "torch_1.x" + }, + "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.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 17d4c7621da70c73698b483103d3342cae436fc7 Mon Sep 17 00:00:00 2001 From: "Dove. J. Kim" Date: Mon, 23 Oct 2023 13:57:55 +0900 Subject: [PATCH 5/8] ['23.10.23][FIX] fix embedding dimension error --- train_maskgit.py | 136 +++++++++++++++++++++-------------------------- 1 file changed, 60 insertions(+), 76 deletions(-) mode change 100644 => 100755 train_maskgit.py diff --git a/train_maskgit.py b/train_maskgit.py old mode 100644 new mode 100755 index 658d169..b0d26b0 --- a/train_maskgit.py +++ b/train_maskgit.py @@ -1,19 +1,21 @@ -import os import time -import numpy as np -import torch -import wandb +import os + +from distributed import init_distributed_device, is_primary +from torch.nn.parallel import DistributedDataParallel +# from transformers import T5Tokenizer, T5Model +from open_clip import tokenizer from torch import optim from tqdm import tqdm -from torch.nn.parallel import DistributedDataParallel +import numpy as np +import open_clip +import torch + +from utils import get_dataloader, sample_paella, sample_maskgit +from utils import image_write, video_write from vivq import VIVQ, BASE_SHAPE -from maskgit import MaskGit from paella import DenoiseUNet -from utils import get_dataloader, sample_paella, sample_maskgit -from distributed import init_distributed_device, is_primary -# from transformers import T5Tokenizer, T5Model -import open_clip -from open_clip import tokenizer +from maskgit import MaskGit def train(args): @@ -28,7 +30,7 @@ def train(args): device = init_distributed_device(args) - vqmodel = VIVQ(codebook_size=args.num_tokens).to(device) + vqmodel = VIVQ(codebook_size=args.num_tokens, model = 'maskgit').to(device) vqmodel.load_state_dict(torch.load(args.vq_path, map_location=device)) vqmodel.vqmodule.q_step_counter += int(1e9) vqmodel.eval().requires_grad_(False) @@ -52,7 +54,7 @@ def train(args): print(f"Batch Size check: {args.world_size * args.batch_size * args.accum_grad}") print(f"Number of Parameters: {sum([p.numel() for p in model.parameters()])}") - lr = 3e-4 + lr = 5e-3 dataset = get_dataloader(args) optimizer = optim.AdamW(model.parameters(), lr=lr) grad_scaler = torch.cuda.amp.GradScaler() @@ -64,10 +66,9 @@ def train(args): if resume: logs = torch.load(f"results/{args.run_name}/log.pt") - run_id = logs["wandb_run_id"] start_step = logs["step"] + 1 - losses = logs["losses"] - accuracies = logs["accuracies"] + losses, curr_losses = logs["losses"] , logs['curr_losses'] + accuracies, curr_accuracies = logs["accuracies"], logs['curr_accuracies'] total_loss, total_acc = losses[-1] * start_step, accuracies[-1] * start_step model.load_state_dict(torch.load(f"models/{args.run_name}/model.pt", map_location=device)) opt_state = torch.load(f"models/{args.run_name}/optim.pt", map_location=device) @@ -82,16 +83,16 @@ def train(args): optimizer.load_state_dict(opt_state) del opt_state else: - run_id = wandb.util.generate_id() - losses = [] - accuracies = [] + # run_id = wandb.util.generate_id() + losses , curr_losses = [], [] + accuracies, curr_accuracies = [], [] start_step, total_loss, total_acc = 0, 0, 0 if is_primary(args): - wandb.init(project="DenoiseGIT", name=args.run_name, entity="wand-tech", config=vars(args), id=run_id, resume="allow") + # wandb.init(project="DenoiseGIT", name=args.run_name, entity="wand-tech", config=vars(args), id=run_id, resume="allow") os.makedirs(f"results/{args.run_name}", exist_ok=True) os.makedirs(f"models/{args.run_name}", exist_ok=True) - wandb.watch(model) + # wandb.watch(model) if args.distributed: model = DistributedDataParallel(model, device_ids=[device], output_device=device) @@ -104,8 +105,7 @@ def train(args): pbar = enumerate(dataset, start=start_step) # pbar = tqdm(range(1000000)) for step, (images, videos, captions) in pbar: - # for step in pbar: - # images = torch.randn(1, 3, 128, 128) + # videos = None # videos = torch.randn(1, 10, 3, 128, 128) images = images.to(device) @@ -113,9 +113,11 @@ def train(args): videos = videos.to(device) with torch.no_grad(): + video_indices = vqmodel.encode(images, videos)[2] # TODO: make this cleaner r = torch.rand(images.size(0), device=device) - noised_indices, mask = model.module.add_noise(video_indices, r) # add module back + + noised_indices, mask = model.add_noise(video_indices, r) # add module back if np.random.rand() < 0.1: # 10% of the times... # text_embeddings = images.new_zeros(images.size(0), 1, args.dim_context) @@ -133,7 +135,8 @@ def train(args): with torch.cuda.amp.autocast(): pred = model(noised_indices, text_embeddings, r) - loss, acc = model.module.loss(pred, video_indices) + + loss, acc = model.loss(pred, video_indices) loss_adjusted = loss / grad_accum_steps total_loss += loss.item() @@ -162,17 +165,20 @@ def train(args): 'gn': grad_norm } pbar.set_postfix(log) - wandb.log(log) + # wandb.log(log) if is_primary(args) and step % args.log_period == 0: losses.append(total_loss / (step + 1)) accuracies.append(total_acc / (step + 1)) + curr_losses.append(loss.item()) + curr_accuracies.append(acc.item()) + model.eval() with torch.no_grad(): captions = captions[:6] text_embeddings = text_embeddings[:6] - sampled = sample_paella(model.module, text_embeddings) + sampled = sample_paella(model, text_embeddings) sampled = vqmodel.decode_indices(sampled) # text_tokens = t5_tokenizer(cool_captions_text, return_tensors="pt", padding=True, truncation=True).input_ids @@ -180,6 +186,7 @@ def train(args): # cool_captions_embeddings = t5_model.encoder(input_ids=text_tokens).last_hidden_state cool_captions_text = open("cool_captions.txt").read().splitlines() + text_tokens = tokenizer.tokenize(cool_captions_text).to(device) cool_captions_embeddings = clip_model.encode_text(text_tokens).float() @@ -187,7 +194,9 @@ def train(args): st = time.time() for caption_embedding in cool_captions_embeddings.chunk(10): caption_embedding = caption_embedding[0].float().to(device) - sampled_text = sample_paella(model.module, caption_embedding) + caption_embedding = caption_embedding.unsqueeze(0) + + sampled_text = sample_paella(model, caption_embedding) sampled_text = vqmodel.decode_indices(sampled_text) for s in sampled_text: cool_captions_sampled.append(s.cpu()) @@ -197,47 +206,41 @@ def train(args): images = images[:6] video_indices = video_indices[:6] + + step_ = str(step).zfill(7) if videos is not None: videos = videos[:6] videos = torch.cat([images.unsqueeze(1), videos], dim=1) recon_video = vqmodel.decode_indices(video_indices, BASE_SHAPE) - log_data = [ - [captions[i]] + - [wandb.Video(sampled[i].cpu().mul(255).add_(0.5).clamp_(0, 255).numpy())] + - [wandb.Video(videos[i].cpu().mul(255).add_(0.5).clamp_(0, 255).numpy())] + - [wandb.Video(recon_video[i].cpu().mul(255).add_(0.5).clamp_(0, 255).numpy())] - for i in range(len(captions)) - ] + video_write(sampled , f'results/{args.run_name}/sampled/sampled_{step_}') + video_write(videos , f'results/{args.run_name}/videos/videos_{step_}') + video_write(recon_video, f'results/{args.run_name}/recon/recon_{step_}') + else: videos = images.unsqueeze(1) recon_video = vqmodel.decode_indices(video_indices, (1, 16, 16)) - log_data = [ - [captions[i]] + - [wandb.Video(sampled[i].cpu().mul(255).add_(0.5).clamp_(0, 255).numpy())] + - [wandb.Image(videos[i])] + - [wandb.Image(recon_video[i])] - for i in range(len(captions)) - ] - - log_table = wandb.Table(data=log_data, columns=["Caption", "Video", "Orig", "Recon"]) - wandb.log({"Log": log_table}) - - log_data_cool = [[cool_captions_text[i]] + [wandb.Video(cool_captions_sampled[i].cpu().mul(255).add_(0.5).clamp_(0, 255).numpy())] for i in range(len(cool_captions_text))] - log_table_cool = wandb.Table(data=log_data_cool, columns=["Caption", "Video"]) - wandb.log({"Log Cool": log_table_cool}) - - del videos, video_indices, images, r, text_embeddings, sampled, log_data, sampled_text, log_data_cool + + video_write(sampled , f'results/{args.run_name}/sampled_{step_}') + image_write(videos , f'results/{args.run_name}/videos_{step_}') + image_write(recon_video, f'results/{args.run_name}/recon_{step_}') + + video_write(cool_captions_sampled, f'results/{args.run_name}/cool_sampled/{step_}') + + del videos, video_indices, images, r, text_embeddings, sampled, sampled_text del noised_indices, mask, pred, loss, loss_adjusted, acc if step % args.extra_ckpt == 0: - torch.save(model.module.state_dict(), f"models/{args.run_name}/model_{step}.pt") + torch.save(model.state_dict(), f"models/{args.run_name}/model.pt") + torch.save(optimizer.state_dict(), f"models/{args.run_name}/optim.pt") + torch.save(grad_scaler.state_dict(), f"models/{args.run_name}/scaler.pt") + + torch.save(model.state_dict(), f"models/{args.run_name}/model_{step}.pt") torch.save(optimizer.state_dict(), f"models/{args.run_name}/model_{step}_optim.pt") torch.save(grad_scaler.state_dict(), f"models/{args.run_name}/model_{step}_scaler.pt") - torch.save(model.module.state_dict(), f"models/{args.run_name}/model.pt") - torch.save(optimizer.state_dict(), f"models/{args.run_name}/optim.pt") - torch.save(grad_scaler.state_dict(), f"models/{args.run_name}/scaler.pt") - torch.save({'step': step, 'losses': losses, 'accuracies': accuracies, 'wandb_run_id': run_id}, f"results/{args.run_name}/log.pt") + torch.save({'step': step, 'curr_losses' : curr_losses, 'losses': losses, + 'curr_accuracies' : curr_accuracies,'accuracies': accuracies}, + f"results/{args.run_name}/log.pt") if __name__ == '__main__': @@ -248,11 +251,7 @@ def train(args): args.model = "paella" args.dataset = "second_stage" args.urls = { - # "videos": "file:C:/Users/d6582/Documents/ml/phenaki/data/webvid/tar_files/0.tar", - # "videos": "/fsx/mas/phenaki/data/webvid/tar_files/{0..249}.tar", "videos": "/fsx/phenaki/data/videos/tar_files/{0..1243}.tar", - # "images": "file:C:/Users/d6582/Documents/ml/paella/evaluations/laion-30k/000069.tar" - # "images": "pipe:aws s3 cp s3://s-laion/improved-aesthetics-laion-2B-en-subsets/aesthetics_tars/{000000..060207}.tar -" "images": "/fsx/phenaki/coyo-700m/coyo-data-2/{00000..20892}.tar" } args.total_steps = 300_000 @@ -262,8 +261,7 @@ def train(args): args.extra_ckpt = 10_000 args.accum_grad = 2 - args.vq_path = "/fsx/phenaki/src/models/model_120000.pt" # ./models/server/vivq_8192_5_skipframes/model_100000.pt - # args.vq_path = "./models/server/vivq_8192_5_skipframes/model_100000.pt" + args.vq_path = "/fsx/phenaki/src/models/model_120000.pt" args.dim = 1224 # 1224 args.num_tokens = 8192 args.max_seq_len = 6 * 16 * 16 @@ -281,17 +279,3 @@ def train(args): print("Launching with args: ", args) train(args) - - # device = "cuda" - # model = MaskGit(dim=args.dim, num_tokens=args.num_tokens, max_seq_len=args.max_seq_len, depth=args.depth, - # dim_context=args.dim_context).to(device) - # t5_tokenizer = T5Tokenizer.from_pretrained("t5-small") # change with "t5-b3" for the 10GB model LoL - # t5_model = T5Model.from_pretrained("t5-small").to(device).requires_grad_(False) - # caption = "the weather is so beautiful today" - # text_tokens = t5_tokenizer(caption, return_tensors="pt", padding=True, truncation=True).input_ids - # text_tokens = text_tokens.to(device) - # text_embeddings = t5_model.encoder(input_ids=text_tokens).last_hidden_state - # print(text_embeddings.shape) - # text_embeddings = torch.randn(1, 10, 512).to(device) - # - # print(sample(model, text_embeddings).shape) From 41fadbbd059d52fcf4d6dbcd7ee96e1c9483a4a3 Mon Sep 17 00:00:00 2001 From: "Dove. J. Kim" Date: Mon, 23 Oct 2023 13:58:41 +0900 Subject: [PATCH 6/8] ['23.10.23][TEST] adjust train hyper parameters --- train_vivq.py | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) mode change 100644 => 100755 train_vivq.py diff --git a/train_vivq.py b/train_vivq.py old mode 100644 new mode 100755 index 15d8077..c0ebaab --- a/train_vivq.py +++ b/train_vivq.py @@ -53,7 +53,7 @@ def train(proc_id, args): lr = 3e-4 dataset = get_dataloader(args) optimizer = optim.AdamW(model.parameters(), lr=lr) - optimizer_discriminator = optim.AdamW(criterion.discriminator.parameters(), lr=lr*1e-2) + optimizer_discriminator = optim.AdamW(criterion.discriminator.parameters(), lr=lr*1e-1) if parallel: model = DistributedDataParallel(model, device_ids=[device], output_device=device, find_unused_parameters=True) @@ -140,7 +140,7 @@ def train(proc_id, args): vutils.save_image(comp, f"results/{args.run_name}/{step}.jpg") if step % args.extra_ckpt == 0: - torch.save(model.module.state_dict(), f"models/{args.run_name}/model_{step}.pt") + torch.save(model.state_dict(), f"models/{args.run_name}/model_{step}.pt") torch.save(optimizer.state_dict(), f"models/{args.run_name}/model_{step}_optim.pt") torch.save(model.state_dict(), f"models/{args.run_name}/model.pt") torch.save(optimizer.state_dict(), f"models/{args.run_name}/optim.pt") @@ -165,7 +165,7 @@ def launch(args): args.model = "vivq" args.dataset = "first_stage" # args.dataset_path = "file:./data/6.tar" - args.dataset_path = "/fsx/mas/phenaki/data/raw_data/Moments_in_Time_Raw/tar_files/{0..363}.tar" + args.dataset_path = "/config/workspace/projects/DataSets/Moments_in_Time_Raw/training" args.total_steps = 5_000_000 args.batch_size = 10 args.num_workers = 10 @@ -178,9 +178,9 @@ def launch(args): args.skip_frames = 5 args.n_nodes = 1 - args.node_id = int(os.environ["SLURM_PROCID"]) - # args.node_id = 0 - args.devices = [0, 1, 2, 3, 4, 5, 6, 7] + # args.node_id = int(os.environ["SLURM_PROCID"]) + args.node_id = 0 + args.devices = [1] # args.devices = [0] print("Launching with args: ", args) From 987197850198c510e8d8733734ffe3ae78356537 Mon Sep 17 00:00:00 2001 From: "Dove. J. Kim" Date: Mon, 23 Oct 2023 13:59:36 +0900 Subject: [PATCH 7/8] ['23.10.23][FEAT] add metrics codes & save results --- utils.py | 141 +++++++++++++++++++++++++++++++++++++++++++++++++++---- 1 file changed, 131 insertions(+), 10 deletions(-) mode change 100644 => 100755 utils.py diff --git a/utils.py b/utils.py old mode 100644 new mode 100755 index e58123b..765644b --- a/utils.py +++ b/utils.py @@ -1,13 +1,21 @@ -import math -import torch +from typing import Union import random -import numpy as np -import torchvision +import math +import os + from torch.utils.data import Dataset, DataLoader, IterableDataset -import webdataset as wds from webdataset.handlers import warn_and_continue -from maskgit import gumbel_sample from einops import rearrange +import webdataset as wds +import torchvision +import numpy as np +import torch +import cv2 + +from maskgit import gumbel_sample + + +SEP = os.path.sep @torch.no_grad() @@ -140,6 +148,7 @@ def collate_first_stage(batch): def collate_second_stage(batch): + if len(batch[0]) == 2: images = torch.stack([i[0] for i in batch], dim=0) videos = None @@ -224,15 +233,16 @@ def init_dataloaders(self, args): return video_dataset, image_dataset def __iter__(self): - sources = [iter(self.image_dataset), iter(self.video_dataset)] - # sources = [iter(self.video_dataset), iter(self.image_dataset)] + # sources = [iter(self.image_dataset), iter(self.video_dataset)] + sources = [iter(self.video_dataset), iter(self.image_dataset)] # sources = [iter(self.video_dataset)] while True: for source in sources: for _ in range(self.batch_size): try: yield next(source) - except StopIteration: + except Exception as e: + print(f'\n\nerror:{e}\n\n') return # video_path = "./videos/test.mp4" @@ -241,6 +251,117 @@ def __iter__(self): # video = transforms(video) +## MaskGIT, Paella 모델 학습시 결과물 저장을 위한 함수 (영상 저장용.) +def video_write(videos: Union[torch.tensor, list], save_path: str): + + ## save_path 인자값을 경로 구분자로 분할 후 폴더 생성. + ## e.g.) /home/workspace/dove/sparrow -> /home/workspace/dove + #! 경로 구분자로 분할한 리스트의 마지막 요소는 파일이름으로 사용할 예정이라 폴더 생성할 때에는 제외함. + path = SEP.join(save_path.split(SEP)[:-1]) + os.makedirs(path, exist_ok = True) + + ## 저장할 영상이 여러개 있는 경우 반복문 돌며 저장. + for idx, video in enumerate(videos): + + ## 영상 데이터 전처리 해주는 부분. + video = video.cpu().mul(255).add_(0.5).clamp_(0, 255).numpy() + fourcc = cv2.VideoWriter_fourcc('m', 'p', '4', 'v') + + ## mp4 포맷에 fps 30, 128 x 128 사이즈로 저장. + output = cv2.VideoWriter(f'{save_path}_{idx}.mp4', fourcc, 30.0, (128, 128)) + + for frame in video: + + ## 영상 데이터가 가지고 있는 프레임(이미지) 전처리하는 부분. + frame = np.transpose(frame, (1, 2, 0)) + frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) + + ## 전처리 된 이미지를 영상파일에 추가하는 부분. + output.write(frame.astype(np.uint8)) + + output.release() + + +## MaskGIT, Paella 모델 학습시 결과물 저장을 위한 함수 (이미지 저장용.) +def image_write(images: Union[torch.tensor, list], save_path: str): + ## save_path 인자값을 경로 구분자로 분할 후 폴더 생성. + ## e.g.) /home/workspace/dove/sparrow -> /home/workspace/dove + #! 경로 구분자로 분할한 리스트의 마지막 요소는 파일이름으로 사용할 예정이라 폴더 생성할 때에는 제외함. + path = SEP.join(save_path.split(SEP)[:-1]) + os.makedirs(path, exist_ok = True) + + ## 저장할 이미지 데이터가 여러개인 경우 반복문을 돌며 저장 + for idx, image in enumerate(images): + + ## 이미지 전처리 하는 부분. + image = image.cpu().mul(255).add_(0.5).clamp_(0, 255).squeeze(0).numpy() + image = np.transpose(image, (1, 2, 0)) + image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) + + ## 이미지 저장하는 부분. + cv2.imwrite(f'{save_path}_{idx}.jpg', image) + + +def calculate_psnr(img1: np.array, img2: np.array) -> float: + # img1 and img2 have range [0, 255] + + img1 *= 255 + img2 *= 255 + + img1 = img1.astype(np.float64) + img2 = img2.astype(np.float64) + mse = np.mean((img1 - img2)**2) + if mse == 0: + return float('inf') + return 20 * math.log10(255.0 / math.sqrt(mse)) + + +def ssim(img1:np.array, img2:np.array) -> float: + img1 *= 255 + img2 *= 255 + + C1 = (0.01 * 255)**2 + C2 = (0.03 * 255)**2 + + img1 = img1.astype(np.float64) + img2 = img2.astype(np.float64) + kernel = cv2.getGaussianKernel(11, 1.5) + window = np.outer(kernel, kernel.transpose()) + + mu1 = cv2.filter2D(img1, -1, window)[5:-5, 5:-5] # valid + mu2 = cv2.filter2D(img2, -1, window)[5:-5, 5:-5] + mu1_sq = mu1**2 + mu2_sq = mu2**2 + mu1_mu2 = mu1 * mu2 + sigma1_sq = cv2.filter2D(img1**2, -1, window)[5:-5, 5:-5] - mu1_sq + sigma2_sq = cv2.filter2D(img2**2, -1, window)[5:-5, 5:-5] - mu2_sq + sigma12 = cv2.filter2D(img1 * img2, -1, window)[5:-5, 5:-5] - mu1_mu2 + + ssim_map = ((2 * mu1_mu2 + C1) * (2 * sigma12 + C2)) / ((mu1_sq + mu2_sq + C1) * + (sigma1_sq + sigma2_sq + C2)) + return ssim_map.mean() + + +def calculate_ssim(img1 : np.array, img2 : np.array) -> Union[float, None]: + '''calculate SSIM + the same outputs as MATLAB's + img1, img2: [0, 255] + ''' + if not img1.shape == img2.shape: + raise ValueError('Input images must have the same dimensions.') + if img1.ndim == 2: + return ssim(img1, img2) + elif img1.ndim == 3: + if img1.shape[2] == 3: + ssims = [] + for _ in range(3): + ssims.append(ssim(img1, img2)) + return np.array(ssims).mean() + elif img1.shape[2] == 1: + return ssim(np.squeeze(img1), np.squeeze(img2)) + else: + raise ValueError('Wrong input image dimensions.') + if __name__ == '__main__': import argparse parser = argparse.ArgumentParser() @@ -278,4 +399,4 @@ def __iter__(self): for sample in dataloader: break - print(sample) + print(sample) \ No newline at end of file From d17cd6ed2042c3d1e2d1e5305067e4485e20f9d1 Mon Sep 17 00:00:00 2001 From: "Dove. J. Kim" Date: Mon, 23 Oct 2023 14:00:05 +0900 Subject: [PATCH 8/8] ['23.10.23][TEST] adjust train hyper parameters --- cvivit.py | 0 distributed.py | 2 +- loss/discriminator.py | 0 loss/loss.py | 0 maskgit.py | 0 paella.py | 0 test_reconstructions.py | 0 7 files changed, 1 insertion(+), 1 deletion(-) mode change 100644 => 100755 cvivit.py mode change 100644 => 100755 distributed.py mode change 100644 => 100755 loss/discriminator.py mode change 100644 => 100755 loss/loss.py mode change 100644 => 100755 maskgit.py mode change 100644 => 100755 paella.py mode change 100644 => 100755 test_reconstructions.py diff --git a/cvivit.py b/cvivit.py old mode 100644 new mode 100755 diff --git a/distributed.py b/distributed.py old mode 100644 new mode 100755 index 28da6d8..eb6461f --- a/distributed.py +++ b/distributed.py @@ -79,7 +79,7 @@ def init_distributed_device(args): if args.distributed and not args.no_set_device_rank: device = 'cuda:%d' % args.local_rank else: - device = 'cuda:0' + device = 'cuda:1' torch.cuda.set_device(device) else: device = 'cpu' diff --git a/loss/discriminator.py b/loss/discriminator.py old mode 100644 new mode 100755 diff --git a/loss/loss.py b/loss/loss.py old mode 100644 new mode 100755 diff --git a/maskgit.py b/maskgit.py old mode 100644 new mode 100755 diff --git a/paella.py b/paella.py old mode 100644 new mode 100755 diff --git a/test_reconstructions.py b/test_reconstructions.py old mode 100644 new mode 100755