diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..aceb1df --- /dev/null +++ b/.gitignore @@ -0,0 +1,29 @@ +__pycache__/ +venv* +workspace/ +out* +saved_out* +all_outputs* +shap_e_model_cache/* +slurm_logs/ +debug/ +notinclude/ +scripts/snap/yamls + +# */validataion +*csv +build/ +*.egg-info/ +*.so +.vscode/ + +tmp* +data/ +trial*/ +.vs/ + +TOKEN +*.ckpt +*.pt +densegridencoder +tets/256_tets.npz diff --git a/LICENSE b/LICENSE index 171269a..261eeb9 100644 --- a/LICENSE +++ b/LICENSE @@ -1,21 +1,201 @@ -MIT License + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ -Copyright (c) 2023 Gordon Guocheng Qian 钱国成 + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: + 1. Definitions. -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/activation.py b/activation.py new file mode 100644 index 0000000..e6cba6a --- /dev/null +++ b/activation.py @@ -0,0 +1,21 @@ +import torch +from torch.autograd import Function +from torch.cuda.amp import custom_bwd, custom_fwd + +class _trunc_exp(Function): + @staticmethod + @custom_fwd(cast_inputs=torch.float) + def forward(ctx, x): + ctx.save_for_backward(x) + return torch.exp(x) + + @staticmethod + @custom_bwd + def backward(ctx, g): + x = ctx.saved_tensors[0] + return g * torch.exp(x.clamp(max=15)) + +trunc_exp = _trunc_exp.apply + +def biased_softplus(x, bias=0): + return torch.nn.functional.softplus(x - bias) \ No newline at end of file diff --git a/all_metrics/metric_utils.py b/all_metrics/metric_utils.py new file mode 100755 index 0000000..a5f134a --- /dev/null +++ b/all_metrics/metric_utils.py @@ -0,0 +1,459 @@ +# * evaluate use laion/CLIP-ViT-H-14-laion2B-s32B-b79K +# best open source clip so far: laion/CLIP-ViT-bigG-14-laion2B-39B-b160k +# code adapted from NeuralLift-360 + +import torch +import torch.nn as nn +import os +import torchvision.transforms as T +import torchvision.transforms.functional as TF +import matplotlib.pyplot as plt +# import clip +from transformers import CLIPFeatureExtractor, CLIPModel, CLIPTokenizer, CLIPProcessor +from torchvision import transforms +import numpy as np +import torch.nn.functional as F +from tqdm import tqdm +import cv2 +from PIL import Image +# import torchvision.transforms as transforms +import glob +from skimage.metrics import peak_signal_noise_ratio as compare_psnr +import lpips +from os.path import join as osp +import argparse +import pandas as pd + +class CLIP(nn.Module): + + def __init__(self, + device, + clip_name='laion/CLIP-ViT-bigG-14-laion2B-39B-b160k', + size=224): #'laion/CLIP-ViT-B-32-laion2B-s34B-b79K'): + super().__init__() + self.size = size + self.device = f"cuda:{device}" + + clip_name = clip_name + + self.feature_extractor = CLIPFeatureExtractor.from_pretrained( + clip_name) + self.clip_model = CLIPModel.from_pretrained(clip_name).to(self.device) + self.tokenizer = CLIPTokenizer.from_pretrained( + 'openai/clip-vit-base-patch32') + + self.normalize = transforms.Normalize( + mean=self.feature_extractor.image_mean, + std=self.feature_extractor.image_std) + + self.resize = transforms.Resize(224) + self.to_tensor = transforms.ToTensor() + + # image augmentation + self.aug = T.Compose([ + T.Resize((224, 224)), + T.Normalize((0.48145466, 0.4578275, 0.40821073), + (0.26862954, 0.26130258, 0.27577711)), + ]) + + # * recommend to use this function for evaluation + @torch.no_grad() + def score_gt(self, ref_img_path, novel_views): + # assert len(novel_views) == 100 + clip_scores = [] + for novel in novel_views: + clip_scores.append(self.score_from_path(ref_img_path, [novel])) + return np.mean(clip_scores) + + # * recommend to use this function for evaluation + # def score_gt(self, ref_paths, novel_paths): + # clip_scores = [] + # for img1_path, img2_path in zip(ref_paths, novel_paths): + # clip_scores.append(self.score_from_path(img1_path, img2_path)) + + # return np.mean(clip_scores) + + def similarity(self, image1_features: torch.Tensor, + image2_features: torch.Tensor) -> float: + with torch.no_grad(), torch.cuda.amp.autocast(): + y = image1_features.T.view(image1_features.T.shape[1], + image1_features.T.shape[0]) + similarity = torch.matmul(y, image2_features.T) + # print(similarity) + return similarity[0][0].item() + + def get_img_embeds(self, img): + if img.shape[0] == 4: + img = img[:3, :, :] + + img = self.aug(img).to(self.device) + img = img.unsqueeze(0) # b,c,h,w + + # plt.imshow(img.cpu().squeeze(0).permute(1, 2, 0).numpy()) + # plt.show() + # print(img) + + image_z = self.clip_model.get_image_features(img) + image_z = image_z / image_z.norm(dim=-1, + keepdim=True) # normalize features + return image_z + + def score_from_feature(self, img1, img2): + img1_feature, img2_feature = self.get_img_embeds( + img1), self.get_img_embeds(img2) + # for debug + return self.similarity(img1_feature, img2_feature) + + def read_img_list(self, img_list): + size = self.size + images = [] + # white_background = np.ones((size, size, 3), dtype=np.uint8) * 255 + + for img_path in img_list: + img = cv2.imread(img_path, cv2.IMREAD_UNCHANGED) + # print(img_path) + if img.shape[2] == 4: # Handle BGRA images + alpha = img[:, :, 3] # Extract alpha channel + img = cv2.cvtColor(img,cv2.COLOR_BGRA2RGB) # Convert BGRA to BGR + img[np.where(alpha == 0)] = [ + 255, 255, 255 + ] # Set transparent pixels to white + else: # Handle other image formats like JPG and PNG + img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) + + img = cv2.resize(img, (size, size), interpolation=cv2.INTER_AREA) + + # plt.imshow(img) + # plt.show() + + images.append(img) + + images = np.stack(images, axis=0) + # images[np.where(images == 0)] = 255 # Set black pixels to white + # images = np.where(images == 0, white_background, images) # Set transparent pixels to white + # images = images.astype(np.float32) + + return images + + def score_from_path(self, img1_path, img2_path): + img1, img2 = self.read_img_list(img1_path), self.read_img_list(img2_path) + img1 = np.squeeze(img1) + img2 = np.squeeze(img2) + # plt.imshow(img1) + # plt.show() + # plt.imshow(img2) + # plt.show() + + img1, img2 = self.to_tensor(img1), self.to_tensor(img2) + # print("img1 to tensor ",img1) + return self.score_from_feature(img1, img2) + + +def numpy_to_torch(images): + images = images * 2.0 - 1.0 + images = torch.from_numpy(images.transpose((0, 3, 1, 2))).float() + return images.cuda() + + +class LPIPSMeter: + + def __init__(self, + net='alex', + device=None, + size=224): # or we can use 'alex', 'vgg' as network + self.size = size + self.net = net + self.results = [] + self.device = device if device is not None else torch.device( + 'cuda' if torch.cuda.is_available() else 'cpu') + self.fn = lpips.LPIPS(net=net).eval().to(self.device) + + def measure(self): + return np.mean(self.results) + + def report(self): + return f'LPIPS ({self.net}) = {self.measure():.6f}' + + def read_img_list(self, img_list): + size = self.size + images = [] + white_background = np.ones((size, size, 3), dtype=np.uint8) * 255 + + for img_path in img_list: + img = cv2.imread(img_path, cv2.IMREAD_UNCHANGED) + + if img.shape[2] == 4: # Handle BGRA images + alpha = img[:, :, 3] # Extract alpha channel + img = cv2.cvtColor(img, + cv2.COLOR_BGRA2BGR) # Convert BGRA to BGR + + img = cv2.cvtColor(img, + cv2.COLOR_BGR2RGB) # Convert BGR to RGB + img[np.where(alpha == 0)] = [ + 255, 255, 255 + ] # Set transparent pixels to white + else: # Handle other image formats like JPG and PNG + img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) + + img = cv2.resize(img, (size, size), interpolation=cv2.INTER_AREA) + images.append(img) + + images = np.stack(images, axis=0) + # images[np.where(images == 0)] = 255 # Set black pixels to white + # images = np.where(images == 0, white_background, images) # Set transparent pixels to white + images = images.astype(np.float32) / 255.0 + + return images + + # * recommend to use this function for evaluation + @torch.no_grad() + def score_gt(self, ref_paths, novel_paths): + self.results = [] + for path0, path1 in zip(ref_paths, novel_paths): + # Load images + # img0 = lpips.im2tensor(lpips.load_image(path0)).cuda() # RGB image from [-1,1] + # img1 = lpips.im2tensor(lpips.load_image(path1)).cuda() + img0, img1 = self.read_img_list([path0]), self.read_img_list( + [path1]) + img0, img1 = numpy_to_torch(img0), numpy_to_torch(img1) + # print(img0.shape,img1.shape) + img0 = F.interpolate(img0, + size=(self.size, self.size), + mode='area') + img1 = F.interpolate(img1, + size=(self.size, self.size), + mode='area') + + # for debug vis + # plt.imshow(img0.cpu().squeeze(0).permute(1, 2, 0).numpy()) + # plt.show() + # plt.imshow(img1.cpu().squeeze(0).permute(1, 2, 0).numpy()) + # plt.show() + # equivalent to cv2.resize(rgba, (w, h), interpolation=cv2.INTER_AREA + + # print(img0.shape,img1.shape) + + self.results.append(self.fn.forward(img0, img1).cpu().numpy()) + + return self.measure() + + +class PSNRMeter: + + def __init__(self, size=800): + self.results = [] + self.size = size + + def read_img_list(self, img_list): + size = self.size + images = [] + white_background = np.ones((size, size, 3), dtype=np.uint8) * 255 + for img_path in img_list: + img = cv2.imread(img_path, cv2.IMREAD_UNCHANGED) + + if img.shape[2] == 4: # Handle BGRA images + alpha = img[:, :, 3] # Extract alpha channel + img = cv2.cvtColor(img, + cv2.COLOR_BGRA2BGR) # Convert BGRA to BGR + + img = cv2.cvtColor(img, + cv2.COLOR_BGR2RGB) # Convert BGR to RGB + img[np.where(alpha == 0)] = [ + 255, 255, 255 + ] # Set transparent pixels to white + else: # Handle other image formats like JPG and PNG + img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) + + img = cv2.resize(img, (size, size), interpolation=cv2.INTER_AREA) + images.append(img) + + images = np.stack(images, axis=0) + # images[np.where(images == 0)] = 255 # Set black pixels to white + # images = np.where(images == 0, white_background, images) # Set transparent pixels to white + images = images.astype(np.float32) / 255.0 + # print(images.shape) + return images + + def update(self, preds, truths): + # print(preds.shape) + + psnr_values = [] + # For each pair of images in the batches + for img1, img2 in zip(preds, truths): + # Compute the PSNR and add it to the list + # print(img1.shape,img2.shape) + + # for debug + # plt.imshow(img1) + # plt.show() + # plt.imshow(img2) + # plt.show() + + psnr = compare_psnr( + img1, img2, + data_range=1.0) # assuming your images are scaled to [0,1] + # print(f"temp psnr {psnr}") + psnr_values.append(psnr) + + # Convert the list of PSNR values to a numpy array + self.results = psnr_values + + def measure(self): + return np.mean(self.results) + + def report(self): + return f'PSNR = {self.measure():.6f}' + + # * recommend to use this function for evaluation + def score_gt(self, ref_paths, novel_paths): + self.results = [] + # [B, N, 3] or [B, H, W, 3], range[0, 1] + preds = self.read_img_list(ref_paths) + truths = self.read_img_list(novel_paths) + self.update(preds, truths) + return self.measure() + +all_inputs = 'data' +nerf_dataset = os.listdir(osp(all_inputs, 'nerf4')) +realfusion_dataset = os.listdir(osp(all_inputs, 'realfusion15')) +meta_examples = { + 'nerf4': nerf_dataset, + 'realfusion15': realfusion_dataset, +} +all_datasets = meta_examples.keys() + +# organization 1 +def deprecated_score_from_method_for_dataset(my_scorer, + method, + dataset, + input, + output, + score_type='clip', + ): # psnr, lpips + # print("\n\n\n") + # print(f"______{method}___{dataset}___{score_type}_________") + scores = {} + final_res = 0 + examples = meta_examples[dataset] + for i in range(len(examples)): + + # compare entire folder for clip + if score_type == 'clip': + novel_view = osp(pred_path, examples[i], 'colors') + # compare first image for other metrics + else: + if method == '3d_fuse': method = '3d_fuse_0' + novel_view = list( + glob.glob( + osp(pred_path, examples[i], 'colors', + 'step_0000*')))[0] + + score_i = my_scorer.score_gt( + [], [novel_view]) + scores[examples[i]] = score_i + final_res += score_i + # print(scores, " Avg : ", final_res / len(examples)) + # print("``````````````````````") + return scores + +# results organization 2 +def score_from_method_for_dataset(my_scorer, + input_path, + pred_path, + score_type='clip', + rgb_name='lambertian', + result_folder='results/images', + first_str='*0000*' + ): # psnr, lpips + scores = {} + final_res = 0 + examples = os.listdir(input_path) + for i in range(len(examples)): + # ref path + ref_path = osp(input_path, examples[i], 'rgba.png') + # compare entire folder for clip + if score_type == 'clip': + novel_view = glob.glob(osp(pred_path,'*'+examples[i]+'*', result_folder, f'*{rgb_name}*')) + print(f'[INOF] {score_type} loss for example {examples[i]} between 1 GT and {len(novel_view)} predictions') + # compare first image for other metrics + else: + novel_view = glob.glob(osp(pred_path, '*'+examples[i]+'*/', result_folder, f'{first_str}{rgb_name}*')) + print(f'[INOF] {score_type} loss for example {examples[i]} between {ref_path} and {novel_view}') + # breakpoint() + score_i = my_scorer.score_gt([ref_path], novel_view) + scores[examples[i]] = score_i + final_res += score_i + avg_score = final_res / len(examples) + scores['average'] = avg_score + return scores + + +if __name__ == "__main__": + parser = argparse.ArgumentParser( + description="Script to accept three string arguments") + parser.add_argument("--input_path", + default=all_inputs, + help="Specify the input path") + parser.add_argument("--pred_pattern", + default="out/magic123*", + help="Specify the pattern of predition paths") + parser.add_argument("--results_folder", + default="results/images", + help="where are the results under each pred_path") + parser.add_argument("--rgb_name", + default="lambertian", + help="the postfix of the image") + parser.add_argument("--first_str", + default="*0000*", + help="the str to indicate the first view") + parser.add_argument("--datasets", + default=all_datasets, + nargs='*', + help="Specify the output path") + parser.add_argument("--device", + type=int, + default=0, + help="Specify the GPU device to be used") + parser.add_argument("--save_dir", type=str, default='all_metrics/results') + args = parser.parse_args() + + clip_scorer = CLIP(args.device) + lpips_scorer = LPIPSMeter() + psnr_scorer = PSNRMeter() + + os.makedirs(args.save_dir, exist_ok=True) + + for dataset in args.datasets: + input_path = osp(args.input_path, dataset) + + # assume the pred_path is organized as: pred_path/methods/dataset + pred_pattern = osp(args.pred_pattern, dataset) + pred_paths = glob.glob(pred_pattern) + print(f"[INFO] Following the pattern {pred_pattern}, find {len(pred_paths)} pred_paths: \n", pred_paths) + if len(pred_paths) == 0: + raise IOError + for pred_path in pred_paths: + if not os.path.exists(pred_path): + print(f'[WARN] prediction does not exit for {pred_path}') + else: + print(f'[INFO] evaluate {pred_path}') + results_dict = {} + results_dict['clip'] = score_from_method_for_dataset( + clip_scorer, input_path, pred_path, 'clip', + result_folder=args.results_folder, rgb_name=args.rgb_name, first_str=args.first_str) + + results_dict['psnr'] = score_from_method_for_dataset( + psnr_scorer, input_path, pred_path, 'psnr', + result_folder=args.results_folder, rgb_name=args.rgb_name, first_str=args.first_str) + + results_dict['lpips'] = score_from_method_for_dataset( + lpips_scorer, input_path, pred_path, 'lpips', + result_folder=args.results_folder, rgb_name=args.rgb_name, first_str=args.first_str) + + df = pd.DataFrame(results_dict) + method = pred_path.split('/')[-2] + print(osp(pred_path, args.results_folder)) + results_str = '_'.join(args.results_folder.split('/')) + print(method+'-'+results_str) + print(df) + df.to_csv(f"{args.save_dir}/{method}-{results_str}-{dataset}.csv") \ No newline at end of file diff --git a/all_metrics/test.sh b/all_metrics/test.sh new file mode 100755 index 0000000..01dcadf --- /dev/null +++ b/all_metrics/test.sh @@ -0,0 +1,13 @@ +# python all_metrics/metric_utils.py --datasets nerf4 realfusion15 --pred_pattern "all_outputs/magic123/magic123-2d1-3d30-dmtet" --results_folder "results/images" + +# 2d only +python all_metrics/metric_utils.py --datasets nerf4 realfusion15 --pred_pattern "all_outputs/magic123-2d/magic123-2d1*" --results_folder "results/images" + +# 3d only +python all_metrics/metric_utils.py --datasets nerf4 realfusion15 --pred_pattern "all_outputs/magic123-3d/zero123-z40*" --results_folder "results/images" + +# python all_metrics/metric_utils.py --datasets nerf4 realfusion15 --pred_pattern "all_outputs/3d_fuse" --results_folder "color" --rgb_name "" --first_str "*_0_*" +# python all_metrics/metric_utils.py --datasets nerf4 realfusion15 --pred_pattern "all_outputs/neural_lift" --results_folder "albedo" --rgb_name "albedo" --first_str "*0000*" +# python all_metrics/metric_utils.py --datasets nerf4 realfusion15 --pred_pattern "all_outputs/real_fusion" --results_folder "colors" --rgb_name "" +# python all_metrics/metric_utils.py --datasets nerf4 realfusion15 --pred_pattern "all_outputs/shape" --results_folder "" --rgb_name "" --first_str "0." +# python all_metrics/metric_utils.py --datasets realfusion15 --pred_pattern "all_outputs/pointe-r100" --results_folder "" --rgb_name "" --first_str "0." \ No newline at end of file diff --git a/assets/advanced.md b/assets/advanced.md new file mode 100644 index 0000000..2f9baca --- /dev/null +++ b/assets/advanced.md @@ -0,0 +1,71 @@ + +# Code organization & Advanced tips + +This is a simple description of the most important implementation details. +If you are interested in improving this repo, this might be a starting point. +Any contribution would be greatly appreciated! + +* The SDS loss is located at `./guidance/sd_utils.py > StableDiffusion > train_step`: +```python +## 1. we need to interpolate the NeRF rendering to 512x512, to feed it to SD's VAE. +pred_rgb_512 = F.interpolate(pred_rgb, (512, 512), mode='bilinear', align_corners=False) +## 2. image (512x512) --- VAE --> latents (64x64), this is SD's difference from Imagen. +latents = self.encode_imgs(pred_rgb_512) +... # timestep sampling, noise adding and UNet noise predicting +## 3. the SDS loss +w = (1 - self.alphas[t]) +grad = w * (noise_pred - noise) +# since UNet part is ignored and cannot simply audodiff, we have two ways to set the grad: +# 3.1. call backward and set the grad now (need to retain graph since we will call a second backward for the other losses later) +latents.backward(gradient=grad, retain_graph=True) +return 0 # dummy loss +# 3.2. use a custom function to set a hook in backward, so we only call backward once (credits to @elliottzheng) +class SpecifyGradient(torch.autograd.Function): + @staticmethod + @custom_fwd + def forward(ctx, input_tensor, gt_grad): + ctx.save_for_backward(gt_grad) + # we return a dummy value 1, which will be scaled by amp's scaler so we get the scale in backward. + return torch.ones([1], device=input_tensor.device, dtype=input_tensor.dtype) + + @staticmethod + @custom_bwd + def backward(ctx, grad_scale): + gt_grad, = ctx.saved_tensors + gt_grad = gt_grad * grad_scale + return gt_grad, None + +loss = SpecifyGradient.apply(latents, grad) +return loss # functional loss +``` +* Other regularizations are in `./nerf/utils.py > Trainer > train_step`. + * The generation seems quite sensitive to regularizations on weights_sum (alphas for each ray). The original opacity loss tends to make NeRF disappear (zero density everywhere), so we use an entropy loss to replace it for now (encourages alpha to be either 0 or 1). +* NeRF Rendering core function: `./nerf/renderer.py > NeRFRenderer > run & run_cuda`. +* Shading & normal evaluation: `./nerf/network*.py > NeRFNetwork > forward`. + * light direction: current implementation use a plane light source, instead of a point light source. +* View-dependent prompting: `./nerf/provider.py > get_view_direction`. + * use `--angle_overhead, --angle_front` to set the border. +* Network backbone (`./nerf/network*.py`) can be chosen by the `--backbone` option. +* Spatial density bias (density blob): `./nerf/network*.py > NeRFNetwork > density_blob`. + + +# Debugging + +`debugpy-run` is a convenient way to remotely debug this project. Simply replace a command like this one: + +```bash +python main.py --text "a hamburger" --workspace trial -O --vram_O +``` + +... with: + +```bash +debugpy-run main.py -- --text "a hamburger" --workspace trial -O --vram_O +``` + +For more details: https://github.com/bulletmark/debugpy-run + +# Axes and directions of polar, azimuth, etc. in NeRF and Zero123 + +NeRF_Zero123 + diff --git a/assets/update_logs.md b/assets/update_logs.md new file mode 100644 index 0000000..b1c2e2c --- /dev/null +++ b/assets/update_logs.md @@ -0,0 +1,39 @@ +### 2023.4.19 +* Fix depth supervision, migrate depth estimation model to omnidata. +* Add normal supervision (also by omnidata). + +https://user-images.githubusercontent.com/25863658/232403294-b77409bf-ddc7-4bb8-af32-ee0cc123825a.mp4 + +### 2023.4.7 +Improvement on mesh quality & DMTet finetuning support. + +https://user-images.githubusercontent.com/25863658/230535363-298c960e-bf9c-4906-8b96-cd60edcb24dd.mp4 + +### 2023.3.30 +* adopt ideas from [Fantasia3D](https://fantasia3d.github.io/) to concatenate normal and mask as the latent code in a warm up stage, which shows faster convergence of shape. + +https://user-images.githubusercontent.com/25863658/230535373-6ee28f16-bb21-4ec4-bc86-d46597361a04.mp4 + +### 2023.1.30 +* Use an MLP to predict the surface normals as in Magic3D to avoid finite difference / second order gradient, generation quality is greatly improved. +* More efficient two-pass raymarching in training inspired by nerfacc. + +https://user-images.githubusercontent.com/25863658/215996308-9fd959f5-b5c7-4a8e-a241-0fe63ec86a4a.mp4 + +### 2022.12.3 +* Support Stable-diffusion 2.0 base. + +### 2022.11.15 +* Add the vanilla backbone that is pure-pytorch. + +### 2022.10.9 +* The shading (partially) starts to work, at least it won't make scene empty. For some prompts, it shows better results (less severe Janus problem). The textureless rendering mode is still disabled. +* Enable shading by default (--latent_iter_ratio 1000). + +### 2022.10.5 +* Basic reproduction finished. +* Non --cuda_ray, --tcnn are not working, need to fix. +* Shading is not working, disabled in utils.py for now. Surface normals are bad. +* Use an entropy loss to regularize weights_sum (alpha), the original L2 reg always leads to degenerated geometry... + +https://user-images.githubusercontent.com/25863658/194241493-f3e68f78-aefe-479e-a4a8-001424a61b37.mp4 diff --git a/dnnultis/REAMD.me b/dnnultis/REAMD.me new file mode 100644 index 0000000..b86c794 --- /dev/null +++ b/dnnultis/REAMD.me @@ -0,0 +1,16 @@ +# dnnutils +dnnutils is a simple library for the commonly used utils for DNN research including: +1. log (log/experiment directory, logging, tensorboard, wandb) +2. + + + +dnnutils is designed to be compitabe for timm. + + +# Install + + + +# TODO +configs \ No newline at end of file diff --git a/dnnultis/__init__.py b/dnnultis/__init__.py new file mode 100644 index 0000000..98fed2c --- /dev/null +++ b/dnnultis/__init__.py @@ -0,0 +1 @@ +from .log import * \ No newline at end of file diff --git a/dnnultis/log/__init__.py b/dnnultis/log/__init__.py new file mode 100644 index 0000000..298fa1c --- /dev/null +++ b/dnnultis/log/__init__.py @@ -0,0 +1,2 @@ +from .logger import * +from .wandb import * \ No newline at end of file diff --git a/dnnultis/log/logger.py b/dnnultis/log/logger.py new file mode 100644 index 0000000..34c07c3 --- /dev/null +++ b/dnnultis/log/logger.py @@ -0,0 +1,86 @@ +import functools +import logging +import os, sys +from termcolor import colored + + +class _ColorfulFormatter(logging.Formatter): + def __init__(self, *args, **kwargs): + self._root_name = kwargs.pop("root_name") + "." + self._abbrev_name = kwargs.pop("abbrev_name", "") + if len(self._abbrev_name): + self._abbrev_name = self._abbrev_name + "." + super(_ColorfulFormatter, self).__init__(*args, **kwargs) + + def formatMessage(self, record): + record.name = record.name.replace(self._root_name, self._abbrev_name) + log = super(_ColorfulFormatter, self).formatMessage(record) + if record.levelno == logging.WARNING: + prefix = colored("WARNING", "red", attrs=["blink"]) + elif record.levelno == logging.ERROR or record.levelno == logging.CRITICAL: + prefix = colored("ERROR", "red", attrs=["blink", "underline"]) + else: + return log + return prefix + " " + log + + +# so that calling setup_logging.root multiple times won't add many handlers +@functools.lru_cache() +def setup_logging(output=None, + distributed_rank=0, + default_level=logging.INFO, + *, + color=True, + name=__name__): + """ + Initialize the detectron2 logging.root and set its verbosity level to "INFO". + Args: + output (str): a file name or a directory to save log. If None, will not save log file. + If ends with ".txt" or ".log", assumed to be a file name. + Otherwise, logs will be saved to `output/log.txt`. + name (str): the root module name of this logging.root + Returns: + logging.logging.root: a logging.root + """ + logging.root.setLevel(default_level) + logging.root.propagate = False + + plain_formatter = logging.Formatter( + "[%(asctime)s] %(name)s %(levelname)s: %(message)s", + datefmt="%y/%m/%d %H:%M:%S") + # stdout logging: master only + if distributed_rank == 0: + ch = logging.StreamHandler(stream=sys.stdout) + ch.setLevel(default_level) + if color: + formatter = _ColorfulFormatter( + colored("[%(asctime)s %(name)s]: ", "green") + "%(message)s", + datefmt="%y/%m/%d %H:%M:%S", + root_name=name, + ) + else: + formatter = plain_formatter + ch.setFormatter(formatter) + logging.root.addHandler(ch) + + # file logging: all workers + if output is not None: + if output.endswith(".txt") or output.endswith(".log"): + filename = output + else: + filename = os.path.join(output, "log.txt") + if distributed_rank > 0: + filename = filename + f".rank{distributed_rank}" + os.makedirs(os.path.dirname(filename), exist_ok=True) + + fh = logging.StreamHandler(_cached_log_stream(filename)) + fh.setLevel(default_level) + fh.setFormatter(plain_formatter) + logging.root.addHandler(fh) + + +# cache the opened file object, so that different calls to `setup_logging.root` +# with the same file name can safely write to the same file. +@functools.lru_cache(maxsize=None) +def _cached_log_stream(filename): + return open(filename, "a") \ No newline at end of file diff --git a/dnnultis/log/wandb.py b/dnnultis/log/wandb.py new file mode 100644 index 0000000..c0ee1a0 --- /dev/null +++ b/dnnultis/log/wandb.py @@ -0,0 +1,84 @@ +import shutil +import os +import subprocess +import wandb + + +class WandbUrls: + def __init__(self, url): + + hash = url.split("/")[-2] + project = url.split("/")[-3] + entity = url.split("/")[-4] + + self.weight_url = url + self.log_url = "https://app.wandb.ai/{}/{}/runs/{}/logs".format(entity, project, hash) + self.chart_url = "https://app.wandb.ai/{}/{}/runs/{}".format(entity, project, hash) + self.overview_url = "https://app.wandb.ai/{}/{}/runs/{}/overview".format(entity, project, hash) + self.config_url = "https://app.wandb.ai/{}/{}/runs/{}/files/hydra-config.yaml".format( + entity, project, hash + ) + self.overrides_url = "https://app.wandb.ai/{}/{}/runs/{}/files/overrides.yaml".format(entity, project, hash) + + def __repr__(self): + msg = "=================================================== WANDB URLS ===================================================================\n" + for k, v in self.__dict__.items(): + msg += "{}: {}\n".format(k.upper(), v) + msg += "=================================================================================================================================\n" + return msg + + +class Wandb: + IS_ACTIVE = False + + @staticmethod + def set_urls_to_model(model, url): + wandb_urls = WandbUrls(url) + model.wandb = wandb_urls + + @staticmethod + def _set_to_wandb_args(wandb_args, cfg, name): + var = getattr(cfg.wandb, name, None) + if var: + wandb_args[name] = var + + @staticmethod + def launch(cfg, launch: bool): + if launch: + + Wandb.IS_ACTIVE = True + + wandb_args = {} + wandb_args["resume"] = "allow" + Wandb._set_to_wandb_args(wandb_args, cfg, "tags") + Wandb._set_to_wandb_args(wandb_args, cfg, "project") + Wandb._set_to_wandb_args(wandb_args, cfg, "name") + Wandb._set_to_wandb_args(wandb_args, cfg, "entity") + Wandb._set_to_wandb_args(wandb_args, cfg, "notes") + Wandb._set_to_wandb_args(wandb_args, cfg, "config") + Wandb._set_to_wandb_args(wandb_args, cfg, "id") + + try: + commit_sha = subprocess.check_output(["git", "rev-parse", "HEAD"]).decode("ascii").strip() + gitdiff = subprocess.check_output(["git", "diff", "--", "':!notebooks'"]).decode() + except: + commit_sha = "n/a" + gitdiff = "" + + config = wandb_args.get("config", {}) + wandb_args["config"] = { + **config, + "run_path": os.getcwd(), + "commit": commit_sha, + "gitdiff": gitdiff + } + wandb.init(**wandb_args, sync_tensorboard=True) + wandb.save(os.path.join(os.getcwd(), cfg.cfg_path)) + + @staticmethod + def add_file(file_path: str): + if not Wandb.IS_ACTIVE: + raise RuntimeError("wandb is inactive, please launch first.") + + filename = os.path.basename(file_path) + shutil.copyfile(file_path, os.path.join(wandb.run.dir, filename)) diff --git a/docker/Dockerfile b/docker/Dockerfile new file mode 100644 index 0000000..47fd296 --- /dev/null +++ b/docker/Dockerfile @@ -0,0 +1,53 @@ +FROM nvidia/cuda:11.6.2-cudnn8-devel-ubuntu20.04 + +# Remove any third-party apt sources to avoid issues with expiring keys. +RUN rm -f /etc/apt/sources.list.d/*.list + +RUN apt-get update + +RUN DEBIAN_FRONTEND=noninteractive TZ=Europe/MADRID apt-get install -y tzdata + +# Install some basic utilities +RUN apt-get install -y \ + curl \ + ca-certificates \ + sudo \ + git \ + bzip2 \ + libx11-6 \ + python3 \ + python3-pip \ + libglfw3-dev \ + libgles2-mesa-dev \ + libglib2.0-0 \ + && rm -rf /var/lib/apt/lists/* + + +# Create a working directory +RUN mkdir /app +WORKDIR /app + +RUN cd /app +RUN git clone https://github.com/ashawkey/stable-dreamfusion.git + + +RUN pip3 install torch torchvision torchaudio --extra-index-url https://download.pytorch.org/whl/cu116 + +WORKDIR /app/stable-dreamfusion + +RUN pip3 install -r requirements.txt +RUN pip3 install git+https://github.com/NVlabs/nvdiffrast/ + +# Needs nvidia runtime, if you have "No CUDA runtime is found" error: https://stackoverflow.com/questions/59691207/docker-build-with-nvidia-runtime, first answer +RUN pip3 install git+https://github.com/NVlabs/tiny-cuda-nn/#subdirectory=bindings/torch + +RUN pip3 install git+https://github.com/openai/CLIP.git +RUN bash scripts/install_ext.sh + + + + + +# Set the default command to python3 +#CMD ["python3"] + diff --git a/docker/README.md b/docker/README.md new file mode 100644 index 0000000..2fe00e4 --- /dev/null +++ b/docker/README.md @@ -0,0 +1,80 @@ +### Docker installation + +## Build image +To build the docker image on your own machine, which may take 15-30 mins: +``` +docker build -t stable-dreamfusion:latest . +``` + +If you have the error **No CUDA runtime is found** when building the wheels for tiny-cuda-nn you need to setup the nvidia-runtime for docker. +``` +sudo apt-get install nvidia-container-runtime +``` +Then edit `/etc/docker/daemon.json` and add the default-runtime: +``` +{ + "runtimes": { + "nvidia": { + "path": "nvidia-container-runtime", + "runtimeArgs": [] + } + }, + "default-runtime": "nvidia" +} +``` +And restart docker: +``` +sudo systemctl restart docker +``` +Now you can build tiny-cuda-nn inside docker. + +## Download image +To download the image (~6GB) instead: +``` +docker pull supercabb/stable-dreamfusion:3080_0.0.1 +docker tag supercabb/stable-dreamfusion:3080_0.0.1 stable-dreamfusion +``` + +## Use image + +You can launch an interactive shell inside the container: + +``` +docker run --gpus all -it --rm -v $(cd ~ && pwd):/mnt stable-dreamfusion /bin/bash +``` +From this shell, all the code in the repo should work. + +To run any single command `` inside the docker container: +``` +docker run --gpus all -it --rm -v $(cd ~ && pwd):/mnt stable-dreamfusion /bin/bash -c "" +``` +To train: +``` +export TOKEN="#HUGGING FACE ACCESS TOKEN#" +docker run --gpus all -it --rm -v $(cd ~ && pwd):/mnt stable-dreamfusion /bin/bash -c "echo ${TOKEN} > TOKEN \ +&& python3 main.py --text \"a hamburger\" --workspace trial -O" + +``` +Run test without gui: +``` +export PATH_TO_WORKSPACE="#PATH_TO_WORKSPACE#" +docker run --gpus all -it --rm -e DISPLAY=$DISPLAY -v /tmp/.X11-unix:/tmp/.X11-unix:ro -v $(cd ~ && pwd):/mnt \ +-v $(cd ${PATH_TO_WORKSPACE} && pwd):/app/stable-dreamfusion/trial stable-dreamfusion /bin/bash -c "python3 \ +main.py --workspace trial -O --test" +``` +Run test with gui: +``` +export PATH_TO_WORKSPACE="#PATH_TO_WORKSPACE#" +xhost + +docker run --gpus all -it --rm -e DISPLAY=$DISPLAY -v /tmp/.X11-unix:/tmp/.X11-unix:ro -v $(cd ~ && pwd):/mnt \ +-v $(cd ${PATH_TO_WORKSPACE} && pwd):/app/stable-dreamfusion/trial stable-dreamfusion /bin/bash -c "python3 \ +main.py --workspace trial -O --test --gui" +xhost - +``` + + + + + + + diff --git a/docs/static/ironman-val-magic123.gif b/docs/static/ironman-val-magic123.gif new file mode 100644 index 0000000..ac8de84 Binary files /dev/null and b/docs/static/ironman-val-magic123.gif differ diff --git a/docs/static/magic123-results.mp4 b/docs/static/magic123-results.mp4 new file mode 100644 index 0000000..1ec7011 Binary files /dev/null and b/docs/static/magic123-results.mp4 differ diff --git a/docs/static/magic123.gif b/docs/static/magic123.gif new file mode 100644 index 0000000..5616b1e Binary files /dev/null and b/docs/static/magic123.gif differ diff --git a/dpt.py b/dpt.py new file mode 100644 index 0000000..8cc0479 --- /dev/null +++ b/dpt.py @@ -0,0 +1,924 @@ +import math +import types + +import torch +import torch.nn as nn +import torch.nn.functional as F + +import timm + +class BaseModel(torch.nn.Module): + def load(self, path): + """Load model from file. + Args: + path (str): file path + """ + parameters = torch.load(path, map_location=torch.device('cpu')) + + if "optimizer" in parameters: + parameters = parameters["model"] + + self.load_state_dict(parameters) + + +def unflatten_with_named_tensor(input, dim, sizes): + """Workaround for unflattening with named tensor.""" + # tracer acts up with unflatten. See https://github.com/pytorch/pytorch/issues/49538 + new_shape = list(input.shape)[:dim] + list(sizes) + list(input.shape)[dim+1:] + return input.view(*new_shape) + +class Slice(nn.Module): + def __init__(self, start_index=1): + super(Slice, self).__init__() + self.start_index = start_index + + def forward(self, x): + return x[:, self.start_index :] + + +class AddReadout(nn.Module): + def __init__(self, start_index=1): + super(AddReadout, self).__init__() + self.start_index = start_index + + def forward(self, x): + if self.start_index == 2: + readout = (x[:, 0] + x[:, 1]) / 2 + else: + readout = x[:, 0] + return x[:, self.start_index :] + readout.unsqueeze(1) + + +class ProjectReadout(nn.Module): + def __init__(self, in_features, start_index=1): + super(ProjectReadout, self).__init__() + self.start_index = start_index + + self.project = nn.Sequential(nn.Linear(2 * in_features, in_features), nn.GELU()) + + def forward(self, x): + readout = x[:, 0].unsqueeze(1).expand_as(x[:, self.start_index :]) + features = torch.cat((x[:, self.start_index :], readout), -1) + + return self.project(features) + + +class Transpose(nn.Module): + def __init__(self, dim0, dim1): + super(Transpose, self).__init__() + self.dim0 = dim0 + self.dim1 = dim1 + + def forward(self, x): + x = x.transpose(self.dim0, self.dim1) + return x + + +def forward_vit(pretrained, x): + b, c, h, w = x.shape + + glob = pretrained.model.forward_flex(x) + + layer_1 = pretrained.activations["1"] + layer_2 = pretrained.activations["2"] + layer_3 = pretrained.activations["3"] + layer_4 = pretrained.activations["4"] + + layer_1 = pretrained.act_postprocess1[0:2](layer_1) + layer_2 = pretrained.act_postprocess2[0:2](layer_2) + layer_3 = pretrained.act_postprocess3[0:2](layer_3) + layer_4 = pretrained.act_postprocess4[0:2](layer_4) + + + unflattened_dim = 2 + unflattened_size = ( + int(torch.div(h, pretrained.model.patch_size[1], rounding_mode='floor')), + int(torch.div(w, pretrained.model.patch_size[0], rounding_mode='floor')), + ) + unflatten = nn.Sequential(nn.Unflatten(unflattened_dim, unflattened_size)) + + + if layer_1.ndim == 3: + layer_1 = unflatten(layer_1) + if layer_2.ndim == 3: + layer_2 = unflatten(layer_2) + if layer_3.ndim == 3: + layer_3 = unflatten_with_named_tensor(layer_3, unflattened_dim, unflattened_size) + if layer_4.ndim == 3: + layer_4 = unflatten_with_named_tensor(layer_4, unflattened_dim, unflattened_size) + + layer_1 = pretrained.act_postprocess1[3 : len(pretrained.act_postprocess1)](layer_1) + layer_2 = pretrained.act_postprocess2[3 : len(pretrained.act_postprocess2)](layer_2) + layer_3 = pretrained.act_postprocess3[3 : len(pretrained.act_postprocess3)](layer_3) + layer_4 = pretrained.act_postprocess4[3 : len(pretrained.act_postprocess4)](layer_4) + + return layer_1, layer_2, layer_3, layer_4 + + +def _resize_pos_embed(self, posemb, gs_h, gs_w): + posemb_tok, posemb_grid = ( + posemb[:, : self.start_index], + posemb[0, self.start_index :], + ) + + gs_old = int(math.sqrt(posemb_grid.shape[0])) + + posemb_grid = posemb_grid.reshape(1, gs_old, gs_old, -1).permute(0, 3, 1, 2) + posemb_grid = F.interpolate(posemb_grid, size=(gs_h, gs_w), mode="bilinear") + posemb_grid = posemb_grid.permute(0, 2, 3, 1).reshape(1, gs_h * gs_w, -1) + + posemb = torch.cat([posemb_tok, posemb_grid], dim=1) + + return posemb + + +def forward_flex(self, x): + b, c, h, w = x.shape + + pos_embed = self._resize_pos_embed( + self.pos_embed, torch.div(h, self.patch_size[1], rounding_mode='floor'), torch.div(w, self.patch_size[0], rounding_mode='floor') + ) + + B = x.shape[0] + + if hasattr(self.patch_embed, "backbone"): + x = self.patch_embed.backbone(x) + if isinstance(x, (list, tuple)): + x = x[-1] # last feature if backbone outputs list/tuple of features + + x = self.patch_embed.proj(x).flatten(2).transpose(1, 2) + + if getattr(self, "dist_token", None) is not None: + cls_tokens = self.cls_token.expand( + B, -1, -1 + ) # stole cls_tokens impl from Phil Wang, thanks + dist_token = self.dist_token.expand(B, -1, -1) + x = torch.cat((cls_tokens, dist_token, x), dim=1) + else: + cls_tokens = self.cls_token.expand( + B, -1, -1 + ) # stole cls_tokens impl from Phil Wang, thanks + x = torch.cat((cls_tokens, x), dim=1) + + x = x + pos_embed + x = self.pos_drop(x) + + for blk in self.blocks: + x = blk(x) + + x = self.norm(x) + + return x + + +activations = {} + + +def get_activation(name): + def hook(model, input, output): + activations[name] = output + + return hook + + +def get_readout_oper(vit_features, features, use_readout, start_index=1): + if use_readout == "ignore": + readout_oper = [Slice(start_index)] * len(features) + elif use_readout == "add": + readout_oper = [AddReadout(start_index)] * len(features) + elif use_readout == "project": + readout_oper = [ + ProjectReadout(vit_features, start_index) for out_feat in features + ] + else: + assert ( + False + ), "wrong operation for readout token, use_readout can be 'ignore', 'add', or 'project'" + + return readout_oper + + +def _make_vit_b16_backbone( + model, + features=[96, 192, 384, 768], + size=[384, 384], + hooks=[2, 5, 8, 11], + vit_features=768, + use_readout="ignore", + start_index=1, +): + pretrained = nn.Module() + + pretrained.model = model + pretrained.model.blocks[hooks[0]].register_forward_hook(get_activation("1")) + pretrained.model.blocks[hooks[1]].register_forward_hook(get_activation("2")) + pretrained.model.blocks[hooks[2]].register_forward_hook(get_activation("3")) + pretrained.model.blocks[hooks[3]].register_forward_hook(get_activation("4")) + + pretrained.activations = activations + + readout_oper = get_readout_oper(vit_features, features, use_readout, start_index) + + # 32, 48, 136, 384 + pretrained.act_postprocess1 = nn.Sequential( + readout_oper[0], + Transpose(1, 2), + nn.Unflatten(2, torch.Size([size[0] // 16, size[1] // 16])), + nn.Conv2d( + in_channels=vit_features, + out_channels=features[0], + kernel_size=1, + stride=1, + padding=0, + ), + nn.ConvTranspose2d( + in_channels=features[0], + out_channels=features[0], + kernel_size=4, + stride=4, + padding=0, + bias=True, + dilation=1, + groups=1, + ), + ) + + pretrained.act_postprocess2 = nn.Sequential( + readout_oper[1], + Transpose(1, 2), + nn.Unflatten(2, torch.Size([size[0] // 16, size[1] // 16])), + nn.Conv2d( + in_channels=vit_features, + out_channels=features[1], + kernel_size=1, + stride=1, + padding=0, + ), + nn.ConvTranspose2d( + in_channels=features[1], + out_channels=features[1], + kernel_size=2, + stride=2, + padding=0, + bias=True, + dilation=1, + groups=1, + ), + ) + + pretrained.act_postprocess3 = nn.Sequential( + readout_oper[2], + Transpose(1, 2), + nn.Unflatten(2, torch.Size([size[0] // 16, size[1] // 16])), + nn.Conv2d( + in_channels=vit_features, + out_channels=features[2], + kernel_size=1, + stride=1, + padding=0, + ), + ) + + pretrained.act_postprocess4 = nn.Sequential( + readout_oper[3], + Transpose(1, 2), + nn.Unflatten(2, torch.Size([size[0] // 16, size[1] // 16])), + nn.Conv2d( + in_channels=vit_features, + out_channels=features[3], + kernel_size=1, + stride=1, + padding=0, + ), + nn.Conv2d( + in_channels=features[3], + out_channels=features[3], + kernel_size=3, + stride=2, + padding=1, + ), + ) + + pretrained.model.start_index = start_index + pretrained.model.patch_size = [16, 16] + + # We inject this function into the VisionTransformer instances so that + # we can use it with interpolated position embeddings without modifying the library source. + pretrained.model.forward_flex = types.MethodType(forward_flex, pretrained.model) + pretrained.model._resize_pos_embed = types.MethodType( + _resize_pos_embed, pretrained.model + ) + + return pretrained + + +def _make_pretrained_vitl16_384(pretrained, use_readout="ignore", hooks=None): + model = timm.create_model("vit_large_patch16_384", pretrained=pretrained) + + hooks = [5, 11, 17, 23] if hooks == None else hooks + return _make_vit_b16_backbone( + model, + features=[256, 512, 1024, 1024], + hooks=hooks, + vit_features=1024, + use_readout=use_readout, + ) + + +def _make_pretrained_vitb16_384(pretrained, use_readout="ignore", hooks=None): + model = timm.create_model("vit_base_patch16_384", pretrained=pretrained) + + hooks = [2, 5, 8, 11] if hooks == None else hooks + return _make_vit_b16_backbone( + model, features=[96, 192, 384, 768], hooks=hooks, use_readout=use_readout + ) + + +def _make_pretrained_deitb16_384(pretrained, use_readout="ignore", hooks=None): + model = timm.create_model("vit_deit_base_patch16_384", pretrained=pretrained) + + hooks = [2, 5, 8, 11] if hooks == None else hooks + return _make_vit_b16_backbone( + model, features=[96, 192, 384, 768], hooks=hooks, use_readout=use_readout + ) + + +def _make_pretrained_deitb16_distil_384(pretrained, use_readout="ignore", hooks=None): + model = timm.create_model( + "vit_deit_base_distilled_patch16_384", pretrained=pretrained + ) + + hooks = [2, 5, 8, 11] if hooks == None else hooks + return _make_vit_b16_backbone( + model, + features=[96, 192, 384, 768], + hooks=hooks, + use_readout=use_readout, + start_index=2, + ) + + +def _make_vit_b_rn50_backbone( + model, + features=[256, 512, 768, 768], + size=[384, 384], + hooks=[0, 1, 8, 11], + vit_features=768, + use_vit_only=False, + use_readout="ignore", + start_index=1, +): + pretrained = nn.Module() + + pretrained.model = model + + if use_vit_only == True: + pretrained.model.blocks[hooks[0]].register_forward_hook(get_activation("1")) + pretrained.model.blocks[hooks[1]].register_forward_hook(get_activation("2")) + else: + pretrained.model.patch_embed.backbone.stages[0].register_forward_hook( + get_activation("1") + ) + pretrained.model.patch_embed.backbone.stages[1].register_forward_hook( + get_activation("2") + ) + + pretrained.model.blocks[hooks[2]].register_forward_hook(get_activation("3")) + pretrained.model.blocks[hooks[3]].register_forward_hook(get_activation("4")) + + pretrained.activations = activations + + readout_oper = get_readout_oper(vit_features, features, use_readout, start_index) + + if use_vit_only == True: + pretrained.act_postprocess1 = nn.Sequential( + readout_oper[0], + Transpose(1, 2), + nn.Unflatten(2, torch.Size([size[0] // 16, size[1] // 16])), + nn.Conv2d( + in_channels=vit_features, + out_channels=features[0], + kernel_size=1, + stride=1, + padding=0, + ), + nn.ConvTranspose2d( + in_channels=features[0], + out_channels=features[0], + kernel_size=4, + stride=4, + padding=0, + bias=True, + dilation=1, + groups=1, + ), + ) + + pretrained.act_postprocess2 = nn.Sequential( + readout_oper[1], + Transpose(1, 2), + nn.Unflatten(2, torch.Size([size[0] // 16, size[1] // 16])), + nn.Conv2d( + in_channels=vit_features, + out_channels=features[1], + kernel_size=1, + stride=1, + padding=0, + ), + nn.ConvTranspose2d( + in_channels=features[1], + out_channels=features[1], + kernel_size=2, + stride=2, + padding=0, + bias=True, + dilation=1, + groups=1, + ), + ) + else: + pretrained.act_postprocess1 = nn.Sequential( + nn.Identity(), nn.Identity(), nn.Identity() + ) + pretrained.act_postprocess2 = nn.Sequential( + nn.Identity(), nn.Identity(), nn.Identity() + ) + + pretrained.act_postprocess3 = nn.Sequential( + readout_oper[2], + Transpose(1, 2), + nn.Unflatten(2, torch.Size([size[0] // 16, size[1] // 16])), + nn.Conv2d( + in_channels=vit_features, + out_channels=features[2], + kernel_size=1, + stride=1, + padding=0, + ), + ) + + pretrained.act_postprocess4 = nn.Sequential( + readout_oper[3], + Transpose(1, 2), + nn.Unflatten(2, torch.Size([size[0] // 16, size[1] // 16])), + nn.Conv2d( + in_channels=vit_features, + out_channels=features[3], + kernel_size=1, + stride=1, + padding=0, + ), + nn.Conv2d( + in_channels=features[3], + out_channels=features[3], + kernel_size=3, + stride=2, + padding=1, + ), + ) + + pretrained.model.start_index = start_index + pretrained.model.patch_size = [16, 16] + + # We inject this function into the VisionTransformer instances so that + # we can use it with interpolated position embeddings without modifying the library source. + pretrained.model.forward_flex = types.MethodType(forward_flex, pretrained.model) + + # We inject this function into the VisionTransformer instances so that + # we can use it with interpolated position embeddings without modifying the library source. + pretrained.model._resize_pos_embed = types.MethodType( + _resize_pos_embed, pretrained.model + ) + + return pretrained + + +def _make_pretrained_vitb_rn50_384( + pretrained, use_readout="ignore", hooks=None, use_vit_only=False +): + model = timm.create_model("vit_base_resnet50_384", pretrained=pretrained) + + hooks = [0, 1, 8, 11] if hooks == None else hooks + return _make_vit_b_rn50_backbone( + model, + features=[256, 512, 768, 768], + size=[384, 384], + hooks=hooks, + use_vit_only=use_vit_only, + use_readout=use_readout, + ) + +def _make_encoder(backbone, features, use_pretrained, groups=1, expand=False, exportable=True, hooks=None, use_vit_only=False, use_readout="ignore",): + if backbone == "vitl16_384": + pretrained = _make_pretrained_vitl16_384( + use_pretrained, hooks=hooks, use_readout=use_readout + ) + scratch = _make_scratch( + [256, 512, 1024, 1024], features, groups=groups, expand=expand + ) # ViT-L/16 - 85.0% Top1 (backbone) + elif backbone == "vitb_rn50_384": + pretrained = _make_pretrained_vitb_rn50_384( + use_pretrained, + hooks=hooks, + use_vit_only=use_vit_only, + use_readout=use_readout, + ) + scratch = _make_scratch( + [256, 512, 768, 768], features, groups=groups, expand=expand + ) # ViT-H/16 - 85.0% Top1 (backbone) + elif backbone == "vitb16_384": + pretrained = _make_pretrained_vitb16_384( + use_pretrained, hooks=hooks, use_readout=use_readout + ) + scratch = _make_scratch( + [96, 192, 384, 768], features, groups=groups, expand=expand + ) # ViT-B/16 - 84.6% Top1 (backbone) + elif backbone == "resnext101_wsl": + pretrained = _make_pretrained_resnext101_wsl(use_pretrained) + scratch = _make_scratch([256, 512, 1024, 2048], features, groups=groups, expand=expand) # efficientnet_lite3 + elif backbone == "efficientnet_lite3": + pretrained = _make_pretrained_efficientnet_lite3(use_pretrained, exportable=exportable) + scratch = _make_scratch([32, 48, 136, 384], features, groups=groups, expand=expand) # efficientnet_lite3 + else: + print(f"Backbone '{backbone}' not implemented") + assert False + + return pretrained, scratch + + +def _make_scratch(in_shape, out_shape, groups=1, expand=False): + scratch = nn.Module() + + out_shape1 = out_shape + out_shape2 = out_shape + out_shape3 = out_shape + out_shape4 = out_shape + if expand==True: + out_shape1 = out_shape + out_shape2 = out_shape*2 + out_shape3 = out_shape*4 + out_shape4 = out_shape*8 + + scratch.layer1_rn = nn.Conv2d( + in_shape[0], out_shape1, kernel_size=3, stride=1, padding=1, bias=False, groups=groups + ) + scratch.layer2_rn = nn.Conv2d( + in_shape[1], out_shape2, kernel_size=3, stride=1, padding=1, bias=False, groups=groups + ) + scratch.layer3_rn = nn.Conv2d( + in_shape[2], out_shape3, kernel_size=3, stride=1, padding=1, bias=False, groups=groups + ) + scratch.layer4_rn = nn.Conv2d( + in_shape[3], out_shape4, kernel_size=3, stride=1, padding=1, bias=False, groups=groups + ) + + return scratch + + +def _make_pretrained_efficientnet_lite3(use_pretrained, exportable=False): + efficientnet = torch.hub.load( + "rwightman/gen-efficientnet-pytorch", + "tf_efficientnet_lite3", + pretrained=use_pretrained, + exportable=exportable + ) + return _make_efficientnet_backbone(efficientnet) + + +def _make_efficientnet_backbone(effnet): + pretrained = nn.Module() + + pretrained.layer1 = nn.Sequential( + effnet.conv_stem, effnet.bn1, effnet.act1, *effnet.blocks[0:2] + ) + pretrained.layer2 = nn.Sequential(*effnet.blocks[2:3]) + pretrained.layer3 = nn.Sequential(*effnet.blocks[3:5]) + pretrained.layer4 = nn.Sequential(*effnet.blocks[5:9]) + + return pretrained + + +def _make_resnet_backbone(resnet): + pretrained = nn.Module() + pretrained.layer1 = nn.Sequential( + resnet.conv1, resnet.bn1, resnet.relu, resnet.maxpool, resnet.layer1 + ) + + pretrained.layer2 = resnet.layer2 + pretrained.layer3 = resnet.layer3 + pretrained.layer4 = resnet.layer4 + + return pretrained + + +def _make_pretrained_resnext101_wsl(use_pretrained): + resnet = torch.hub.load("facebookresearch/WSL-Images", "resnext101_32x8d_wsl") + return _make_resnet_backbone(resnet) + + + +class Interpolate(nn.Module): + """Interpolation module. + """ + + def __init__(self, scale_factor, mode, align_corners=False): + """Init. + Args: + scale_factor (float): scaling + mode (str): interpolation mode + """ + super(Interpolate, self).__init__() + + self.interp = nn.functional.interpolate + self.scale_factor = scale_factor + self.mode = mode + self.align_corners = align_corners + + def forward(self, x): + """Forward pass. + Args: + x (tensor): input + Returns: + tensor: interpolated data + """ + + x = self.interp( + x, scale_factor=self.scale_factor, mode=self.mode, align_corners=self.align_corners + ) + + return x + + +class ResidualConvUnit(nn.Module): + """Residual convolution module. + """ + + def __init__(self, features): + """Init. + Args: + features (int): number of features + """ + super().__init__() + + self.conv1 = nn.Conv2d( + features, features, kernel_size=3, stride=1, padding=1, bias=True + ) + + self.conv2 = nn.Conv2d( + features, features, kernel_size=3, stride=1, padding=1, bias=True + ) + + self.relu = nn.ReLU(inplace=True) + + def forward(self, x): + """Forward pass. + Args: + x (tensor): input + Returns: + tensor: output + """ + out = self.relu(x) + out = self.conv1(out) + out = self.relu(out) + out = self.conv2(out) + + return out + x + + +class FeatureFusionBlock(nn.Module): + """Feature fusion block. + """ + + def __init__(self, features): + """Init. + Args: + features (int): number of features + """ + super(FeatureFusionBlock, self).__init__() + + self.resConfUnit1 = ResidualConvUnit(features) + self.resConfUnit2 = ResidualConvUnit(features) + + def forward(self, *xs): + """Forward pass. + Returns: + tensor: output + """ + output = xs[0] + + if len(xs) == 2: + output += self.resConfUnit1(xs[1]) + + output = self.resConfUnit2(output) + + output = nn.functional.interpolate( + output, scale_factor=2, mode="bilinear", align_corners=True + ) + + return output + + + + +class ResidualConvUnit_custom(nn.Module): + """Residual convolution module. + """ + + def __init__(self, features, activation, bn): + """Init. + Args: + features (int): number of features + """ + super().__init__() + + self.bn = bn + + self.groups=1 + + self.conv1 = nn.Conv2d( + features, features, kernel_size=3, stride=1, padding=1, bias=True, groups=self.groups + ) + + self.conv2 = nn.Conv2d( + features, features, kernel_size=3, stride=1, padding=1, bias=True, groups=self.groups + ) + + if self.bn==True: + self.bn1 = nn.BatchNorm2d(features) + self.bn2 = nn.BatchNorm2d(features) + + self.activation = activation + + self.skip_add = nn.quantized.FloatFunctional() + + def forward(self, x): + """Forward pass. + Args: + x (tensor): input + Returns: + tensor: output + """ + + out = self.activation(x) + out = self.conv1(out) + if self.bn==True: + out = self.bn1(out) + + out = self.activation(out) + out = self.conv2(out) + if self.bn==True: + out = self.bn2(out) + + if self.groups > 1: + out = self.conv_merge(out) + + return self.skip_add.add(out, x) + + # return out + x + + +class FeatureFusionBlock_custom(nn.Module): + """Feature fusion block. + """ + + def __init__(self, features, activation, deconv=False, bn=False, expand=False, align_corners=True): + """Init. + Args: + features (int): number of features + """ + super(FeatureFusionBlock_custom, self).__init__() + + self.deconv = deconv + self.align_corners = align_corners + + self.groups=1 + + self.expand = expand + out_features = features + if self.expand==True: + out_features = features//2 + + self.out_conv = nn.Conv2d(features, out_features, kernel_size=1, stride=1, padding=0, bias=True, groups=1) + + self.resConfUnit1 = ResidualConvUnit_custom(features, activation, bn) + self.resConfUnit2 = ResidualConvUnit_custom(features, activation, bn) + + self.skip_add = nn.quantized.FloatFunctional() + + def forward(self, *xs): + """Forward pass. + Returns: + tensor: output + """ + output = xs[0] + + if len(xs) == 2: + res = self.resConfUnit1(xs[1]) + output = self.skip_add.add(output, res) + # output += res + + output = self.resConfUnit2(output) + + output = nn.functional.interpolate( + output, scale_factor=2, mode="bilinear", align_corners=self.align_corners + ) + + output = self.out_conv(output) + + return output + + + +def _make_fusion_block(features, use_bn): + return FeatureFusionBlock_custom( + features, + nn.ReLU(False), + deconv=False, + bn=use_bn, + expand=False, + align_corners=True, + ) + + +class DPT(BaseModel): + def __init__( + self, + head, + features=256, + backbone="vitb_rn50_384", + readout="project", + channels_last=False, + use_bn=False, + ): + + super(DPT, self).__init__() + + self.channels_last = channels_last + + hooks = { + "vitb_rn50_384": [0, 1, 8, 11], + "vitb16_384": [2, 5, 8, 11], + "vitl16_384": [5, 11, 17, 23], + } + + # Instantiate backbone and reassemble blocks + self.pretrained, self.scratch = _make_encoder( + backbone, + features, + True, # Set to true of you want to train from scratch, uses ImageNet weights + groups=1, + expand=False, + exportable=False, + hooks=hooks[backbone], + use_readout=readout, + ) + + self.scratch.refinenet1 = _make_fusion_block(features, use_bn) + self.scratch.refinenet2 = _make_fusion_block(features, use_bn) + self.scratch.refinenet3 = _make_fusion_block(features, use_bn) + self.scratch.refinenet4 = _make_fusion_block(features, use_bn) + + self.scratch.output_conv = head + + + def forward(self, x): + if self.channels_last == True: + x.contiguous(memory_format=torch.channels_last) + + layer_1, layer_2, layer_3, layer_4 = forward_vit(self.pretrained, x) + + layer_1_rn = self.scratch.layer1_rn(layer_1) + layer_2_rn = self.scratch.layer2_rn(layer_2) + layer_3_rn = self.scratch.layer3_rn(layer_3) + layer_4_rn = self.scratch.layer4_rn(layer_4) + + path_4 = self.scratch.refinenet4(layer_4_rn) + path_3 = self.scratch.refinenet3(path_4, layer_3_rn) + path_2 = self.scratch.refinenet2(path_3, layer_2_rn) + path_1 = self.scratch.refinenet1(path_2, layer_1_rn) + + out = self.scratch.output_conv(path_1) + + return out + +class DPTDepthModel(DPT): + def __init__(self, path=None, non_negative=True, num_channels=1, **kwargs): + features = kwargs["features"] if "features" in kwargs else 256 + + head = nn.Sequential( + nn.Conv2d(features, features // 2, kernel_size=3, stride=1, padding=1), + Interpolate(scale_factor=2, mode="bilinear", align_corners=True), + nn.Conv2d(features // 2, 32, kernel_size=3, stride=1, padding=1), + nn.ReLU(True), + nn.Conv2d(32, num_channels, kernel_size=1, stride=1, padding=0), + nn.ReLU(True) if non_negative else nn.Identity(), + nn.Identity(), + ) + + super().__init__(head, **kwargs) + + if path is not None: + self.load(path) + + def forward(self, x): + return super().forward(x).squeeze(dim=1) \ No newline at end of file diff --git a/encoding.py b/encoding.py new file mode 100644 index 0000000..407589e --- /dev/null +++ b/encoding.py @@ -0,0 +1,89 @@ +import torch +import torch.nn as nn +import torch.nn.functional as F + +class FreqEncoder_torch(nn.Module): + def __init__(self, input_dim, max_freq_log2, N_freqs, + log_sampling=True, include_input=True, + periodic_fns=(torch.sin, torch.cos)): + + super().__init__() + + self.input_dim = input_dim + self.include_input = include_input + self.periodic_fns = periodic_fns + self.N_freqs = N_freqs + + self.output_dim = 0 + if self.include_input: + self.output_dim += self.input_dim + + self.output_dim += self.input_dim * N_freqs * len(self.periodic_fns) + + if log_sampling: + self.freq_bands = 2 ** torch.linspace(0, max_freq_log2, N_freqs) + else: + self.freq_bands = torch.linspace(2 ** 0, 2 ** max_freq_log2, N_freqs) + + self.freq_bands = self.freq_bands.numpy().tolist() + + def forward(self, input, max_level=None, **kwargs): + + if max_level is None: + max_level = self.N_freqs + else: + max_level = int(max_level * self.N_freqs) + + out = [] + if self.include_input: + out.append(input) + + for i in range(max_level): + freq = self.freq_bands[i] + for p_fn in self.periodic_fns: + out.append(p_fn(input * freq)) + + # append 0 + if self.N_freqs - max_level > 0: + out.append(torch.zeros(input.shape[0], (self.N_freqs - max_level) * 2 * input.shape[1], device=input.device, dtype=input.dtype)) + + out = torch.cat(out, dim=-1) + + return out + +def get_encoder(encoding, input_dim=3, + multires=6, + degree=4, + num_levels=16, level_dim=2, base_resolution=16, log2_hashmap_size=19, desired_resolution=2048, align_corners=False, interpolation='linear', + **kwargs): + + if encoding == 'None': + return lambda x, **kwargs: x, input_dim + + elif encoding == 'frequency_torch': + encoder = FreqEncoder_torch(input_dim=input_dim, max_freq_log2=multires-1, N_freqs=multires, log_sampling=True) + + elif encoding == 'frequency': # CUDA implementation, faster than torch. + from freqencoder import FreqEncoder + encoder = FreqEncoder(input_dim=input_dim, degree=multires) + + elif encoding == 'sphere_harmonics': + from shencoder import SHEncoder + encoder = SHEncoder(input_dim=input_dim, degree=degree) + + elif encoding == 'hashgrid': + from gridencoder import GridEncoder + encoder = GridEncoder(input_dim=input_dim, num_levels=num_levels, level_dim=level_dim, base_resolution=base_resolution, log2_hashmap_size=log2_hashmap_size, desired_resolution=desired_resolution, gridtype='hash', align_corners=align_corners, interpolation=interpolation) + + elif encoding == 'tiledgrid': + from gridencoder import GridEncoder + encoder = GridEncoder(input_dim=input_dim, num_levels=num_levels, level_dim=level_dim, base_resolution=base_resolution, log2_hashmap_size=log2_hashmap_size, desired_resolution=desired_resolution, gridtype='tiled', align_corners=align_corners, interpolation=interpolation) + + elif encoding == 'hashgrid_taichi': + from taichi_modules.hash_encoder import HashEncoderTaichi + encoder = HashEncoderTaichi(batch_size=4096) #TODO: hard encoded batch size + + else: + raise NotImplementedError('Unknown encoding mode, choose from [None, frequency, sphere_harmonics, hashgrid, tiledgrid]') + + return encoder, encoder.output_dim \ No newline at end of file diff --git a/freqencoder/__init__.py b/freqencoder/__init__.py new file mode 100644 index 0000000..69ec49c --- /dev/null +++ b/freqencoder/__init__.py @@ -0,0 +1 @@ +from .freq import FreqEncoder \ No newline at end of file diff --git a/freqencoder/backend.py b/freqencoder/backend.py new file mode 100644 index 0000000..fa0e820 --- /dev/null +++ b/freqencoder/backend.py @@ -0,0 +1,42 @@ +import os +from torch.utils.cpp_extension import load + +_src_path = os.path.dirname(os.path.abspath(__file__)) + +nvcc_flags = [ + '-O3', '-std=c++14', + '-U__CUDA_NO_HALF_OPERATORS__', '-U__CUDA_NO_HALF_CONVERSIONS__', '-U__CUDA_NO_HALF2_OPERATORS__', + '-use_fast_math' +] + +if os.name == "posix": + c_flags = ['-O3', '-std=c++14'] +elif os.name == "nt": + c_flags = ['/O2', '/std:c++17'] + + # find cl.exe + def find_cl_path(): + import glob + for program_files in [r"C:\\Program Files (x86)", r"C:\\Program Files"]: + for edition in ["Enterprise", "Professional", "BuildTools", "Community"]: + paths = sorted(glob.glob(r"%s\\Microsoft Visual Studio\\*\\%s\\VC\\Tools\\MSVC\\*\\bin\\Hostx64\\x64" % (program_files, edition)), reverse=True) + if paths: + return paths[0] + + # If cl.exe is not on path, try to find it. + if os.system("where cl.exe >nul 2>nul") != 0: + cl_path = find_cl_path() + if cl_path is None: + raise RuntimeError("Could not locate a supported Microsoft Visual C++ installation") + os.environ["PATH"] += ";" + cl_path + +_backend = load(name='_freqencoder', + extra_cflags=c_flags, + extra_cuda_cflags=nvcc_flags, + sources=[os.path.join(_src_path, 'src', f) for f in [ + 'freqencoder.cu', + 'bindings.cpp', + ]], + ) + +__all__ = ['_backend'] \ No newline at end of file diff --git a/freqencoder/freq.py b/freqencoder/freq.py new file mode 100644 index 0000000..5cba1e6 --- /dev/null +++ b/freqencoder/freq.py @@ -0,0 +1,77 @@ +import numpy as np + +import torch +import torch.nn as nn +from torch.autograd import Function +from torch.autograd.function import once_differentiable +from torch.cuda.amp import custom_bwd, custom_fwd + +try: + import _freqencoder as _backend +except ImportError: + from .backend import _backend + + +class _freq_encoder(Function): + @staticmethod + @custom_fwd(cast_inputs=torch.float32) # force float32 for better precision + def forward(ctx, inputs, degree, output_dim): + # inputs: [B, input_dim], float + # RETURN: [B, F], float + + if not inputs.is_cuda: inputs = inputs.cuda() + inputs = inputs.contiguous() + + B, input_dim = inputs.shape # batch size, coord dim + + outputs = torch.empty(B, output_dim, dtype=inputs.dtype, device=inputs.device) + + _backend.freq_encode_forward(inputs, B, input_dim, degree, output_dim, outputs) + + ctx.save_for_backward(inputs, outputs) + ctx.dims = [B, input_dim, degree, output_dim] + + return outputs + + @staticmethod + #@once_differentiable + @custom_bwd + def backward(ctx, grad): + # grad: [B, C * C] + + grad = grad.contiguous() + inputs, outputs = ctx.saved_tensors + B, input_dim, degree, output_dim = ctx.dims + + grad_inputs = torch.zeros_like(inputs) + _backend.freq_encode_backward(grad, outputs, B, input_dim, degree, output_dim, grad_inputs) + + return grad_inputs, None, None + + +freq_encode = _freq_encoder.apply + + +class FreqEncoder(nn.Module): + def __init__(self, input_dim=3, degree=4): + super().__init__() + + self.input_dim = input_dim + self.degree = degree + self.output_dim = input_dim + input_dim * 2 * degree + + def __repr__(self): + return f"FreqEncoder: input_dim={self.input_dim} degree={self.degree} output_dim={self.output_dim}" + + def forward(self, inputs, **kwargs): + # inputs: [..., input_dim] + # return: [..., ] + + prefix_shape = list(inputs.shape[:-1]) + inputs = inputs.reshape(-1, self.input_dim) + + outputs = freq_encode(inputs, self.degree, self.output_dim) + + outputs = outputs.reshape(prefix_shape + [self.output_dim]) + + return outputs \ No newline at end of file diff --git a/freqencoder/setup.py b/freqencoder/setup.py new file mode 100644 index 0000000..ea64112 --- /dev/null +++ b/freqencoder/setup.py @@ -0,0 +1,52 @@ +import os +from setuptools import setup +from torch.utils.cpp_extension import BuildExtension, CUDAExtension + +_src_path = os.path.dirname(os.path.abspath(__file__)) + +nvcc_flags = [ + '-O3', '-std=c++14', + '-U__CUDA_NO_HALF_OPERATORS__', '-U__CUDA_NO_HALF_CONVERSIONS__', '-U__CUDA_NO_HALF2_OPERATORS__', + '-use_fast_math' +] + +if os.name == "posix": + c_flags = ['-O3', '-std=c++14'] +elif os.name == "nt": + c_flags = ['/O2', '/std:c++17'] + + # find cl.exe + def find_cl_path(): + import glob + for program_files in [r"C:\\Program Files (x86)", r"C:\\Program Files"]: + for edition in ["Enterprise", "Professional", "BuildTools", "Community"]: + paths = sorted(glob.glob(r"%s\\Microsoft Visual Studio\\*\\%s\\VC\\Tools\\MSVC\\*\\bin\\Hostx64\\x64" % (program_files, edition)), reverse=True) + if paths: + return paths[0] + + # If cl.exe is not on path, try to find it. + if os.system("where cl.exe >nul 2>nul") != 0: + cl_path = find_cl_path() + if cl_path is None: + raise RuntimeError("Could not locate a supported Microsoft Visual C++ installation") + os.environ["PATH"] += ";" + cl_path + +setup( + name='freqencoder', # package name, import this to use python API + ext_modules=[ + CUDAExtension( + name='_freqencoder', # extension name, import this to use CUDA API + sources=[os.path.join(_src_path, 'src', f) for f in [ + 'freqencoder.cu', + 'bindings.cpp', + ]], + extra_compile_args={ + 'cxx': c_flags, + 'nvcc': nvcc_flags, + } + ), + ], + cmdclass={ + 'build_ext': BuildExtension, + } +) \ No newline at end of file diff --git a/freqencoder/src/bindings.cpp b/freqencoder/src/bindings.cpp new file mode 100644 index 0000000..bb5f285 --- /dev/null +++ b/freqencoder/src/bindings.cpp @@ -0,0 +1,8 @@ +#include + +#include "freqencoder.h" + +PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) { + m.def("freq_encode_forward", &freq_encode_forward, "freq encode forward (CUDA)"); + m.def("freq_encode_backward", &freq_encode_backward, "freq encode backward (CUDA)"); +} \ No newline at end of file diff --git a/freqencoder/src/freqencoder.cu b/freqencoder/src/freqencoder.cu new file mode 100644 index 0000000..072da74 --- /dev/null +++ b/freqencoder/src/freqencoder.cu @@ -0,0 +1,129 @@ +#include + +#include +#include +#include + +#include +#include + +#include +#include + +#include + + +#define CHECK_CUDA(x) TORCH_CHECK(x.device().is_cuda(), #x " must be a CUDA tensor") +#define CHECK_CONTIGUOUS(x) TORCH_CHECK(x.is_contiguous(), #x " must be a contiguous tensor") +#define CHECK_IS_INT(x) TORCH_CHECK(x.scalar_type() == at::ScalarType::Int, #x " must be an int tensor") +#define CHECK_IS_FLOATING(x) TORCH_CHECK(x.scalar_type() == at::ScalarType::Float || x.scalar_type() == at::ScalarType::Half || x.scalar_type() == at::ScalarType::Double, #x " must be a floating tensor") + +inline constexpr __device__ float PI() { return 3.141592653589793f; } + +template +__host__ __device__ T div_round_up(T val, T divisor) { + return (val + divisor - 1) / divisor; +} + +// inputs: [B, D] +// outputs: [B, C], C = D + D * deg * 2 +__global__ void kernel_freq( + const float * __restrict__ inputs, + uint32_t B, uint32_t D, uint32_t deg, uint32_t C, + float * outputs +) { + // parallel on per-element + const uint32_t t = threadIdx.x + blockIdx.x * blockDim.x; + if (t >= B * C) return; + + // get index + const uint32_t b = t / C; + const uint32_t c = t - b * C; // t % C; + + // locate + inputs += b * D; + outputs += t; + + // write self + if (c < D) { + outputs[0] = inputs[c]; + // write freq + } else { + const uint32_t col = c / D - 1; + const uint32_t d = c % D; + const uint32_t freq = col / 2; + const float phase_shift = (col % 2) * (PI() / 2); + outputs[0] = __sinf(scalbnf(inputs[d], freq) + phase_shift); + } +} + +// grad: [B, C], C = D + D * deg * 2 +// outputs: [B, C] +// grad_inputs: [B, D] +__global__ void kernel_freq_backward( + const float * __restrict__ grad, + const float * __restrict__ outputs, + uint32_t B, uint32_t D, uint32_t deg, uint32_t C, + float * grad_inputs +) { + // parallel on per-element + const uint32_t t = threadIdx.x + blockIdx.x * blockDim.x; + if (t >= B * D) return; + + const uint32_t b = t / D; + const uint32_t d = t - b * D; // t % D; + + // locate + grad += b * C; + outputs += b * C; + grad_inputs += t; + + // register + float result = grad[d]; + grad += D; + outputs += D; + + for (uint32_t f = 0; f < deg; f++) { + result += scalbnf(1.0f, f) * (grad[d] * outputs[D + d] - grad[D + d] * outputs[d]); + grad += 2 * D; + outputs += 2 * D; + } + + // write + grad_inputs[0] = result; +} + + +void freq_encode_forward(at::Tensor inputs, const uint32_t B, const uint32_t D, const uint32_t deg, const uint32_t C, at::Tensor outputs) { + CHECK_CUDA(inputs); + CHECK_CUDA(outputs); + + CHECK_CONTIGUOUS(inputs); + CHECK_CONTIGUOUS(outputs); + + CHECK_IS_FLOATING(inputs); + CHECK_IS_FLOATING(outputs); + + static constexpr uint32_t N_THREADS = 128; + + kernel_freq<<>>(inputs.data_ptr(), B, D, deg, C, outputs.data_ptr()); +} + + +void freq_encode_backward(at::Tensor grad, at::Tensor outputs, const uint32_t B, const uint32_t D, const uint32_t deg, const uint32_t C, at::Tensor grad_inputs) { + CHECK_CUDA(grad); + CHECK_CUDA(outputs); + CHECK_CUDA(grad_inputs); + + CHECK_CONTIGUOUS(grad); + CHECK_CONTIGUOUS(outputs); + CHECK_CONTIGUOUS(grad_inputs); + + CHECK_IS_FLOATING(grad); + CHECK_IS_FLOATING(outputs); + CHECK_IS_FLOATING(grad_inputs); + + static constexpr uint32_t N_THREADS = 128; + + kernel_freq_backward<<>>(grad.data_ptr(), outputs.data_ptr(), B, D, deg, C, grad_inputs.data_ptr()); +} \ No newline at end of file diff --git a/freqencoder/src/freqencoder.h b/freqencoder/src/freqencoder.h new file mode 100644 index 0000000..34f28c7 --- /dev/null +++ b/freqencoder/src/freqencoder.h @@ -0,0 +1,10 @@ +# pragma once + +#include +#include + +// _backend.freq_encode_forward(inputs, B, input_dim, degree, output_dim, outputs) +void freq_encode_forward(at::Tensor inputs, const uint32_t B, const uint32_t D, const uint32_t deg, const uint32_t C, at::Tensor outputs); + +// _backend.freq_encode_backward(grad, outputs, B, input_dim, degree, output_dim, grad_inputs) +void freq_encode_backward(at::Tensor grad, at::Tensor outputs, const uint32_t B, const uint32_t D, const uint32_t deg, const uint32_t C, at::Tensor grad_inputs); \ No newline at end of file diff --git a/gradio_app.py b/gradio_app.py new file mode 100644 index 0000000..9573bdf --- /dev/null +++ b/gradio_app.py @@ -0,0 +1,246 @@ +import torch +import argparse + +from nerf.provider import NeRFDataset +from nerf.utils import * + +import gradio as gr +import gc + +print(f'[INFO] loading options..') + +# fake config object, this should not be used in CMD, only allow change from gradio UI. +parser = argparse.ArgumentParser() +parser.add_argument('--text', default=None, help="text prompt") +parser.add_argument('--negative', default='', type=str, help="negative text prompt") +parser.add_argument('--test', action='store_true', help="test mode") +parser.add_argument('--eval_interval', type=int, default=10, help="evaluate on the valid set every interval epochs") +parser.add_argument('--workspace', type=str, default='trial_gradio') +parser.add_argument('--guidance', type=str, default='stable-diffusion', help='choose from [stable-diffusion, clip]') +parser.add_argument('--seed', type=int, default=0) + +parser.add_argument('--save_mesh', action='store_true', help="export an obj mesh with texture") +parser.add_argument('--mcubes_resolution', type=int, default=256, help="mcubes resolution for extracting mesh") +parser.add_argument('--decimate_target', type=int, default=1e5, help="target face number for mesh decimation") + +### training options +parser.add_argument('--iters', type=int, default=10000, help="training iters") +parser.add_argument('--lr', type=float, default=1e-3, help="initial learning rate") +parser.add_argument('--ckpt', type=str, default='latest') +parser.add_argument('--cuda_ray', action='store_true', help="use CUDA raymarching instead of pytorch") +parser.add_argument('--max_steps', type=int, default=1024, help="max num steps sampled per ray (only valid when using --cuda_ray)") +parser.add_argument('--num_steps', type=int, default=64, help="num steps sampled per ray (only valid when not using --cuda_ray)") +parser.add_argument('--upsample_steps', type=int, default=64, help="num steps up-sampled per ray (only valid when not using --cuda_ray)") +parser.add_argument('--update_extra_interval', type=int, default=16, help="iter interval to update extra status (only valid when using --cuda_ray)") +parser.add_argument('--max_ray_batch', type=int, default=4096, help="batch size of rays at inference to avoid OOM (only valid when not using --cuda_ray)") +parser.add_argument('--warmup_iters', type=int, default=1000, help="training iters that only use albedo shading") +parser.add_argument('--uniform_sphere_rate', type=float, default=0.5, help="likelihood of sampling camera location uniformly on the sphere surface area") +# model options +parser.add_argument('--bg_radius', type=float, default=1.4, help="if positive, use a background model at sphere(bg_radius)") +parser.add_argument('--density_activation', type=str, default='softplus', choices=['softplus', 'exp'], help="density activation function") +parser.add_argument('--density_thresh', type=float, default=10, help="threshold for density grid to be occupied") +parser.add_argument('--blob_density', type=float, default=10, help="max (center) density for the density blob") +parser.add_argument('--blob_radius', type=float, default=0.3, help="control the radius for the density blob") +# network backbone +parser.add_argument('--fp16', action='store_true', help="use float16 for training") +parser.add_argument('--vram_O', action='store_true', help="optimization for low VRAM usage") +parser.add_argument('--backbone', type=str, default='grid', help="nerf backbone, choose from [grid, vanilla]") +parser.add_argument('--optim', type=str, default='adan', choices=['adan', 'adam', 'adamw'], help="optimizer") +parser.add_argument('--sd_version', type=str, default='2.1', choices=['1.5', '2.0', '2.1'], help="stable diffusion version") +parser.add_argument('--hf_key', type=str, default=None, help="hugging face Stable diffusion model key") +# rendering resolution in training, decrease this if CUDA OOM. +parser.add_argument('--w', type=int, default=64, help="render width for NeRF in training") +parser.add_argument('--h', type=int, default=64, help="render height for NeRF in training") +parser.add_argument('--jitter_pose', action='store_true', help="add jitters to the randomly sampled camera poses") + +### dataset options +parser.add_argument('--bound', type=float, default=1, help="assume the scene is bounded in box(-bound, bound)") +parser.add_argument('--dt_gamma', type=float, default=0, help="dt_gamma (>=0) for adaptive ray marching. set to 0 to disable, >0 to accelerate rendering (but usually with worse quality)") +parser.add_argument('--min_near', type=float, default=0.1, help="minimum near distance for camera") +parser.add_argument('--radius_range', type=float, nargs='*', default=[1.0, 1.5], help="training camera radius range") +parser.add_argument('--fovy_range', type=float, nargs='*', default=[40, 70], help="training camera fovy range") +parser.add_argument('--angle_overhead', type=float, default=30, help="[0, angle_overhead] is the overhead region") +parser.add_argument('--angle_front', type=float, default=60, help="[0, angle_front] is the front region, [180, 180+angle_front] the back region, otherwise the side region.") + +parser.add_argument('--lambda_entropy', type=float, default=1e-4, help="loss scale for alpha entropy") +parser.add_argument('--lambda_opacity', type=float, default=0, help="loss scale for alpha value") +parser.add_argument('--lambda_orient', type=float, default=1e-2, help="loss scale for orientation") +parser.add_argument('--lambda_smooth', type=float, default=0, help="loss scale for surface smoothness") + +### GUI options +parser.add_argument('--gui', action='store_true', help="start a GUI") +parser.add_argument('--W', type=int, default=800, help="GUI width") +parser.add_argument('--H', type=int, default=800, help="GUI height") +parser.add_argument('--radius', type=float, default=3, help="default GUI camera radius from center") +parser.add_argument('--fovy', type=float, default=60, help="default GUI camera fovy") +parser.add_argument('--light_theta', type=float, default=60, help="default GUI light direction in [0, 180], corresponding to elevation [90, -90]") +parser.add_argument('--light_phi', type=float, default=0, help="default GUI light direction in [0, 360), azimuth") +parser.add_argument('--max_spp', type=int, default=1, help="GUI rendering max sample per pixel") + +parser.add_argument('--need_share', type=bool, default=False, help="do you want to share gradio app to external network?") + +opt = parser.parse_args() + +# default to use -O !!! +opt.fp16 = True +opt.cuda_ray = True +opt.vram_O = True +# opt.lambda_entropy = 1e-4 +# opt.lambda_opacity = 0 + +if opt.backbone == 'vanilla': + from nerf.network import NeRFNetwork +elif opt.backbone == 'grid': + from nerf.network_grid import NeRFNetwork +else: + raise NotImplementedError(f'--backbone {opt.backbone} is not implemented!') + +print(opt) + +device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') + +print(f'[INFO] loading models..') + +if opt.guidance == 'stable-diffusion': + from guidance.sd_utils import StableDiffusion + guidance = StableDiffusion(device, opt.fp16, opt.vram_O, opt.sd_version, opt.hf_key) +elif opt.guidance == 'clip': + from guidance.clip_utils import CLIP + guidance = CLIP(device) +else: + raise NotImplementedError(f'--guidance {opt.guidance} is not implemented.') + +train_loader = NeRFDataset(opt, device=device, type='train', H=opt.h, W=opt.w, size=100).dataloader() +valid_loader = NeRFDataset(opt, device=device, type='val', H=opt.H, W=opt.W, size=5).dataloader() +test_loader = NeRFDataset(opt, device=device, type='test', H=opt.H, W=opt.W, size=100).dataloader() + +print(f'[INFO] everything loaded!') + +trainer = None +model = None + +# define UI + +with gr.Blocks(css=".gradio-container {max-width: 512px; margin: auto;}") as demo: + + # title + gr.Markdown('[Stable-DreamFusion](https://github.com/ashawkey/stable-dreamfusion) Text-to-3D Example') + + # inputs + prompt = gr.Textbox(label="Prompt", max_lines=1, value="a DSLR photo of a koi fish") + iters = gr.Slider(label="Iters", minimum=1000, maximum=20000, value=5000, step=100) + seed = gr.Slider(label="Seed", minimum=0, maximum=2147483647, step=1, randomize=True) + button = gr.Button('Generate') + + # outputs + image = gr.Image(label="image", visible=True) + video = gr.Video(label="video", visible=False) + logs = gr.Textbox(label="logging") + + # gradio main func + def submit(text, iters, seed): + + global trainer, model + + # seed + opt.seed = seed + opt.text = text + opt.iters = iters + + seed_everything(seed) + + # clean up + if trainer is not None: + del model + del trainer + gc.collect() + torch.cuda.empty_cache() + print('[INFO] clean up!') + + # simply reload everything... + model = NeRFNetwork(opt) + + if opt.optim == 'adan': + from optimizer import Adan + # Adan usually requires a larger LR + optimizer = lambda model: Adan(model.get_params(5 * opt.lr), eps=1e-15) + elif opt.optim == 'adamw': + optimizer = lambda model: torch.optim.AdamW(model.get_params(opt.lr), betas=(0.9, 0.99), eps=1e-15) + else: # adam + optimizer = lambda model: torch.optim.Adam(model.get_params(opt.lr), betas=(0.9, 0.99), eps=1e-15) + + scheduler = lambda optimizer: optim.lr_scheduler.LambdaLR(optimizer, lambda iter: 1) # fixed + + trainer = Trainer('df', opt, model, guidance, device=device, workspace=opt.workspace, optimizer=optimizer, ema_decay=0.95, fp16=opt.fp16, lr_scheduler=scheduler, use_checkpoint=opt.ckpt, eval_interval=opt.eval_interval, scheduler_update_every_step=True) + + # train (every ep only contain 8 steps, so we can get some vis every ~10s) + STEPS = 8 + max_epochs = np.ceil(opt.iters / STEPS).astype(np.int32) + + # we have to get the explicit training loop out here to yield progressive results... + loader = iter(valid_loader) + + start_t = time.time() + + for epoch in range(max_epochs): + + trainer.train_gui(train_loader, step=STEPS) + + # manual test and get intermediate results + try: + data = next(loader) + except StopIteration: + loader = iter(valid_loader) + data = next(loader) + + trainer.model.eval() + + if trainer.ema is not None: + trainer.ema.store() + trainer.ema.copy_to() + + with torch.no_grad(): + with torch.cuda.amp.autocast(enabled=trainer.fp16): + preds, preds_depth = trainer.test_step(data, perturb=False) + + if trainer.ema is not None: + trainer.ema.restore() + + pred = preds[0].detach().cpu().numpy() + # pred_depth = preds_depth[0].detach().cpu().numpy() + + pred = (pred * 255).astype(np.uint8) + + yield { + image: gr.update(value=pred, visible=True), + video: gr.update(visible=False), + logs: f"training iters: {epoch * STEPS} / {iters}, lr: {trainer.optimizer.param_groups[0]['lr']:.6f}", + } + + + # test + trainer.test(test_loader) + + results = glob.glob(os.path.join(opt.workspace, 'results', '*rgb*.mp4')) + assert results is not None, "cannot retrieve results!" + results.sort(key=lambda x: os.path.getmtime(x)) # sort by mtime + + end_t = time.time() + + yield { + image: gr.update(visible=False), + video: gr.update(value=results[-1], visible=True), + logs: f"Generation Finished in {(end_t - start_t)/ 60:.4f} minutes!", + } + + + button.click( + submit, + [prompt, iters, seed], + [image, video, logs] + ) + +# concurrency_count: only allow ONE running progress, else GPU will OOM. +demo.queue(concurrency_count=1) + +demo.launch(share=opt.need_share) diff --git a/gridencoder/__init__.py b/gridencoder/__init__.py new file mode 100644 index 0000000..f1476ce --- /dev/null +++ b/gridencoder/__init__.py @@ -0,0 +1 @@ +from .grid import GridEncoder \ No newline at end of file diff --git a/gridencoder/backend.py b/gridencoder/backend.py new file mode 100644 index 0000000..b403f34 --- /dev/null +++ b/gridencoder/backend.py @@ -0,0 +1,40 @@ +import os +from torch.utils.cpp_extension import load + +_src_path = os.path.dirname(os.path.abspath(__file__)) + +nvcc_flags = [ + '-O3', '-std=c++14', + '-U__CUDA_NO_HALF_OPERATORS__', '-U__CUDA_NO_HALF_CONVERSIONS__', '-U__CUDA_NO_HALF2_OPERATORS__', +] + +if os.name == "posix": + c_flags = ['-O3', '-std=c++14'] +elif os.name == "nt": + c_flags = ['/O2', '/std:c++17'] + + # find cl.exe + def find_cl_path(): + import glob + for program_files in [r"C:\\Program Files (x86)", r"C:\\Program Files"]: + for edition in ["Enterprise", "Professional", "BuildTools", "Community"]: + paths = sorted(glob.glob(r"%s\\Microsoft Visual Studio\\*\\%s\\VC\\Tools\\MSVC\\*\\bin\\Hostx64\\x64" % (program_files, edition)), reverse=True) + if paths: + return paths[0] + # If cl.exe is not on path, try to find it. + if os.system("where cl.exe >nul 2>nul") != 0: + cl_path = find_cl_path() + if cl_path is None: + raise RuntimeError("Could not locate a supported Microsoft Visual C++ installation") + os.environ["PATH"] += ";" + cl_path + +_backend = load(name='_grid_encoder', + extra_cflags=c_flags, + extra_cuda_cflags=nvcc_flags, + sources=[os.path.join(_src_path, 'src', f) for f in [ + 'gridencoder.cu', + 'bindings.cpp', + ]], + ) + +__all__ = ['_backend'] \ No newline at end of file diff --git a/gridencoder/grid.py b/gridencoder/grid.py new file mode 100644 index 0000000..3f91daf --- /dev/null +++ b/gridencoder/grid.py @@ -0,0 +1,206 @@ +import math +import numpy as np + +import torch +import torch.nn as nn +from torch.autograd import Function +from torch.autograd.function import once_differentiable +from torch.cuda.amp import custom_bwd, custom_fwd + +try: + import _gridencoder as _backend +except ImportError: + from .backend import _backend + +_gridtype_to_id = { + 'hash': 0, + 'tiled': 1, +} + +_interp_to_id = { + 'linear': 0, + 'smoothstep': 1, +} + +class _grid_encode(Function): + @staticmethod + @custom_fwd + def forward(ctx, inputs, embeddings, offsets, per_level_scale, base_resolution, calc_grad_inputs=False, gridtype=0, align_corners=False, interpolation=0, max_level=None): + # inputs: [B, D], float in [0, 1] + # embeddings: [sO, C], float + # offsets: [L + 1], int + # RETURN: [B, F], float + + inputs = inputs.contiguous() + + B, D = inputs.shape # batch size, coord dim + L = offsets.shape[0] - 1 # level + C = embeddings.shape[1] # embedding dim for each level + S = np.log2(per_level_scale) # resolution multiplier at each level, apply log2 for later CUDA exp2f + H = base_resolution # base resolution + + max_level = L if max_level is None else max(min(int(math.ceil(max_level * L)), L), 1) + + # manually handle autocast (only use half precision embeddings, inputs must be float for enough precision) + # if C % 2 != 0, force float, since half for atomicAdd is very slow. + if torch.is_autocast_enabled() and C % 2 == 0: + embeddings = embeddings.to(torch.half) + + # L first, optimize cache for cuda kernel, but needs an extra permute later + outputs = torch.empty(L, B, C, device=inputs.device, dtype=embeddings.dtype) + + # zero init if we only calculate partial levels + if max_level < L: outputs.zero_() + + if calc_grad_inputs: + dy_dx = torch.empty(B, L * D * C, device=inputs.device, dtype=embeddings.dtype) + if max_level < L: dy_dx.zero_() + else: + dy_dx = None + + _backend.grid_encode_forward(inputs, embeddings, offsets, outputs, B, D, C, L, max_level, S, H, dy_dx, gridtype, align_corners, interpolation) + + # permute back to [B, L * C] + outputs = outputs.permute(1, 0, 2).reshape(B, L * C) + + ctx.save_for_backward(inputs, embeddings, offsets, dy_dx) + ctx.dims = [B, D, C, L, S, H, gridtype, interpolation, max_level] + ctx.align_corners = align_corners + + return outputs + + @staticmethod + #@once_differentiable + @custom_bwd + def backward(ctx, grad): + + inputs, embeddings, offsets, dy_dx = ctx.saved_tensors + B, D, C, L, S, H, gridtype, interpolation, max_level = ctx.dims + align_corners = ctx.align_corners + + # grad: [B, L * C] --> [L, B, C] + grad = grad.view(B, L, C).permute(1, 0, 2).contiguous() + + grad_embeddings = torch.zeros_like(embeddings) + + if dy_dx is not None: + grad_inputs = torch.zeros_like(inputs, dtype=embeddings.dtype) + else: + grad_inputs = None + + _backend.grid_encode_backward(grad, inputs, embeddings, offsets, grad_embeddings, B, D, C, L, max_level, S, H, dy_dx, grad_inputs, gridtype, align_corners, interpolation) + + if dy_dx is not None: + grad_inputs = grad_inputs.to(inputs.dtype) + + return grad_inputs, grad_embeddings, None, None, None, None, None, None, None, None + + + +grid_encode = _grid_encode.apply + + +class GridEncoder(nn.Module): + def __init__(self, input_dim=3, num_levels=16, level_dim=2, per_level_scale=2, base_resolution=16, log2_hashmap_size=19, desired_resolution=None, gridtype='hash', align_corners=False, interpolation='linear'): + super().__init__() + + # the finest resolution desired at the last level, if provided, overridee per_level_scale + if desired_resolution is not None: + per_level_scale = np.exp2(np.log2(desired_resolution / base_resolution) / (num_levels - 1)) + + self.input_dim = input_dim # coord dims, 2 or 3 + self.num_levels = num_levels # num levels, each level multiply resolution by 2 + self.level_dim = level_dim # encode channels per level + self.per_level_scale = per_level_scale # multiply resolution by this scale at each level. + self.log2_hashmap_size = log2_hashmap_size + self.base_resolution = base_resolution + self.output_dim = num_levels * level_dim + self.gridtype = gridtype + self.gridtype_id = _gridtype_to_id[gridtype] # "tiled" or "hash" + self.interpolation = interpolation + self.interp_id = _interp_to_id[interpolation] # "linear" or "smoothstep" + self.align_corners = align_corners + + # allocate parameters + offsets = [] + offset = 0 + self.max_params = 2 ** log2_hashmap_size + for i in range(num_levels): + resolution = int(np.ceil(base_resolution * per_level_scale ** i)) + params_in_level = min(self.max_params, (resolution) ** input_dim) # limit max number + params_in_level = int(np.ceil(params_in_level / 8) * 8) # make divisible + offsets.append(offset) + offset += params_in_level + offsets.append(offset) + offsets = torch.from_numpy(np.array(offsets, dtype=np.int32)) + self.register_buffer('offsets', offsets) + + self.n_params = offsets[-1] * level_dim + + # parameters + self.embeddings = nn.Parameter(torch.empty(offset, level_dim)) + + self.reset_parameters() + + def reset_parameters(self): + std = 1e-4 + self.embeddings.data.uniform_(-std, std) + + def __repr__(self): + return f"GridEncoder: input_dim={self.input_dim} num_levels={self.num_levels} level_dim={self.level_dim} resolution={self.base_resolution} -> {int(round(self.base_resolution * self.per_level_scale ** (self.num_levels - 1)))} per_level_scale={self.per_level_scale:.4f} params={tuple(self.embeddings.shape)} gridtype={self.gridtype} align_corners={self.align_corners} interpolation={self.interpolation}" + + def forward(self, inputs, bound=1, max_level=None): + # inputs: [..., input_dim], normalized real world positions in [-bound, bound] + # max_level: only calculate first max_level levels (None will use all levels) + # return: [..., num_levels * level_dim] + + inputs = (inputs + bound) / (2 * bound) # map to [0, 1] + + #print('inputs', inputs.shape, inputs.dtype, inputs.min().item(), inputs.max().item()) + + prefix_shape = list(inputs.shape[:-1]) + inputs = inputs.view(-1, self.input_dim) + + outputs = grid_encode(inputs, self.embeddings, self.offsets, self.per_level_scale, self.base_resolution, inputs.requires_grad, self.gridtype_id, self.align_corners, self.interp_id, max_level) + outputs = outputs.view(prefix_shape + [self.output_dim]) + + #print('outputs', outputs.shape, outputs.dtype, outputs.min().item(), outputs.max().item()) + + return outputs + + # always run in float precision! + @torch.cuda.amp.autocast(enabled=False) + def grad_total_variation(self, weight=1e-7, inputs=None, bound=1, B=1000000): + # inputs: [..., input_dim], float in [-b, b], location to calculate TV loss. + + D = self.input_dim + C = self.embeddings.shape[1] # embedding dim for each level + L = self.offsets.shape[0] - 1 # level + S = np.log2(self.per_level_scale) # resolution multiplier at each level, apply log2 for later CUDA exp2f + H = self.base_resolution # base resolution + + if inputs is None: + # randomized in [0, 1] + inputs = torch.rand(B, self.input_dim, device=self.embeddings.device) + else: + inputs = (inputs + bound) / (2 * bound) # map to [0, 1] + inputs = inputs.view(-1, self.input_dim) + B = inputs.shape[0] + + if self.embeddings.grad is None: + raise ValueError('grad is None, should be called after loss.backward() and before optimizer.step()!') + + _backend.grad_total_variation(inputs, self.embeddings, self.embeddings.grad, self.offsets, weight, B, D, C, L, S, H, self.gridtype_id, self.align_corners) + + @torch.cuda.amp.autocast(enabled=False) + def grad_weight_decay(self, weight=0.1): + # level-wise meaned weight decay (ref: zip-nerf) + + B = self.embeddings.shape[0] # size of embedding + C = self.embeddings.shape[1] # embedding dim for each level + L = self.offsets.shape[0] - 1 # level + + if self.embeddings.grad is None: + raise ValueError('grad is None, should be called after loss.backward() and before optimizer.step()!') + + _backend.grad_weight_decay(self.embeddings, self.embeddings.grad, self.offsets, weight, B, C, L) \ No newline at end of file diff --git a/gridencoder/setup.py b/gridencoder/setup.py new file mode 100644 index 0000000..a91b0c1 --- /dev/null +++ b/gridencoder/setup.py @@ -0,0 +1,51 @@ +import os +from setuptools import setup +from torch.utils.cpp_extension import BuildExtension, CUDAExtension + +_src_path = os.path.dirname(os.path.abspath(__file__)) + +nvcc_flags = [ + '-O3', '-std=c++14', + '-U__CUDA_NO_HALF_OPERATORS__', '-U__CUDA_NO_HALF_CONVERSIONS__', '-U__CUDA_NO_HALF2_OPERATORS__', +] + +if os.name == "posix": + c_flags = ['-O3', '-std=c++14'] +elif os.name == "nt": + c_flags = ['/O2', '/std:c++17'] + + # find cl.exe + def find_cl_path(): + import glob + for program_files in [r"C:\\Program Files (x86)", r"C:\\Program Files"]: + for edition in ["Enterprise", "Professional", "BuildTools", "Community"]: + paths = sorted(glob.glob(r"%s\\Microsoft Visual Studio\\*\\%s\\VC\\Tools\\MSVC\\*\\bin\\Hostx64\\x64" % (program_files, edition)), reverse=True) + if paths: + return paths[0] + + # If cl.exe is not on path, try to find it. + if os.system("where cl.exe >nul 2>nul") != 0: + cl_path = find_cl_path() + if cl_path is None: + raise RuntimeError("Could not locate a supported Microsoft Visual C++ installation") + os.environ["PATH"] += ";" + cl_path + +setup( + name='gridencoder', # package name, import this to use python API + ext_modules=[ + CUDAExtension( + name='_gridencoder', # extension name, import this to use CUDA API + sources=[os.path.join(_src_path, 'src', f) for f in [ + 'gridencoder.cu', + 'bindings.cpp', + ]], + extra_compile_args={ + 'cxx': c_flags, + 'nvcc': nvcc_flags, + } + ), + ], + cmdclass={ + 'build_ext': BuildExtension, + } +) \ No newline at end of file diff --git a/gridencoder/src/bindings.cpp b/gridencoder/src/bindings.cpp new file mode 100644 index 0000000..fc3dd5e --- /dev/null +++ b/gridencoder/src/bindings.cpp @@ -0,0 +1,10 @@ +#include + +#include "gridencoder.h" + +PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) { + m.def("grid_encode_forward", &grid_encode_forward, "grid_encode_forward (CUDA)"); + m.def("grid_encode_backward", &grid_encode_backward, "grid_encode_backward (CUDA)"); + m.def("grad_total_variation", &grad_total_variation, "grad_total_variation (CUDA)"); + m.def("grad_weight_decay", &grad_weight_decay, "grad_weight_decay (CUDA)"); +} \ No newline at end of file diff --git a/gridencoder/src/gridencoder.cu b/gridencoder/src/gridencoder.cu new file mode 100644 index 0000000..93f5b80 --- /dev/null +++ b/gridencoder/src/gridencoder.cu @@ -0,0 +1,713 @@ +#include +#include +#include + +#include +#include + +#include +#include + +#include +#include + + +#define CHECK_CUDA(x) TORCH_CHECK(x.device().is_cuda(), #x " must be a CUDA tensor") +#define CHECK_CONTIGUOUS(x) TORCH_CHECK(x.is_contiguous(), #x " must be a contiguous tensor") +#define CHECK_IS_INT(x) TORCH_CHECK(x.scalar_type() == at::ScalarType::Int, #x " must be an int tensor") +#define CHECK_IS_FLOATING(x) TORCH_CHECK(x.scalar_type() == at::ScalarType::Float || x.scalar_type() == at::ScalarType::Half || x.scalar_type() == at::ScalarType::Double, #x " must be a floating tensor") + + +// just for compatability of half precision in AT_DISPATCH_FLOATING_TYPES_AND_HALF... program will never reach here! + __device__ inline at::Half atomicAdd(at::Half *address, at::Half val) { + // requires CUDA >= 10 and ARCH >= 70 + // this is very slow compared to float or __half2, never use it. + //return atomicAdd(reinterpret_cast<__half*>(address), val); +} + + +template +__host__ __device__ inline T div_round_up(T val, T divisor) { + return (val + divisor - 1) / divisor; +} + +template +__device__ inline T smoothstep(T val) { + return val*val*(3.0f - 2.0f * val); +} + +template +__device__ inline T smoothstep_derivative(T val) { + return 6*val*(1.0f - val); +} + + +template +__device__ uint32_t fast_hash(const uint32_t pos_grid[D]) { + + // coherent type of hashing + constexpr uint32_t primes[7] = { 1u, 2654435761u, 805459861u, 3674653429u, 2097192037u, 1434869437u, 2165219737u }; + + uint32_t result = 0; + #pragma unroll + for (uint32_t i = 0; i < D; ++i) { + result ^= pos_grid[i] * primes[i]; + } + + return result; +} + + +template +__device__ uint32_t get_grid_index(const uint32_t gridtype, const uint32_t ch, const uint32_t hashmap_size, const uint32_t resolution, const uint32_t pos_grid[D]) { + uint32_t stride = 1; + uint32_t index = 0; + + #pragma unroll + for (uint32_t d = 0; d < D && stride <= hashmap_size; d++) { + index += pos_grid[d] * stride; + stride *= resolution; + } + + // NOTE: for NeRF, the hash is in fact not necessary. Check https://github.com/NVlabs/instant-ngp/issues/97. + // gridtype: 0 == hash, 1 == tiled + if (gridtype == 0 && stride > hashmap_size) { + index = fast_hash(pos_grid); + } + + return (index % hashmap_size) * C + ch; +} + + +template +__global__ void kernel_grid( + const float * __restrict__ inputs, + const scalar_t * __restrict__ grid, + const int * __restrict__ offsets, + scalar_t * __restrict__ outputs, + const uint32_t B, const uint32_t L, const float S, const uint32_t H, + scalar_t * __restrict__ dy_dx, + const uint32_t gridtype, + const bool align_corners, + const uint32_t interp +) { + const uint32_t b = blockIdx.x * blockDim.x + threadIdx.x; + + if (b >= B) return; + + const uint32_t level = blockIdx.y; + + // locate + grid += (uint32_t)offsets[level] * C; + inputs += b * D; + outputs += level * B * C + b * C; + + // check input range (should be in [0, 1]) + bool flag_oob = false; + #pragma unroll + for (uint32_t d = 0; d < D; d++) { + if (inputs[d] < 0 || inputs[d] > 1) { + flag_oob = true; + } + } + // if input out of bound, just set output to 0 + if (flag_oob) { + #pragma unroll + for (uint32_t ch = 0; ch < C; ch++) { + outputs[ch] = 0; + } + if (dy_dx) { + dy_dx += b * D * L * C + level * D * C; // B L D C + #pragma unroll + for (uint32_t d = 0; d < D; d++) { + #pragma unroll + for (uint32_t ch = 0; ch < C; ch++) { + dy_dx[d * C + ch] = 0; + } + } + } + return; + } + + const uint32_t hashmap_size = offsets[level + 1] - offsets[level]; + const uint32_t resolution = (uint32_t)ceil(exp2f(level * S) * H); + + // calculate coordinate (always use float for precision!) + float pos[D]; + float pos_deriv[D]; + uint32_t pos_grid[D]; + + #pragma unroll + for (uint32_t d = 0; d < D; d++) { + + // align_corners + if (align_corners) { + pos[d] = inputs[d] * (float)(resolution - 1); // [0, resolution - 1] + pos_grid[d] = min((uint32_t)floorf(pos[d]), resolution - 2); // left-top corner, [0, resolution - 2] + } else { + pos[d] = fminf(fmaxf(inputs[d] * (float)resolution - 0.5f, 0.0f), (float)(resolution - 1)); // [-0.5, resolution-0.5] --> [0, resolution - 1] + pos_grid[d] = (uint32_t)floorf(pos[d]); // left-top corner, [0, resolution - 1] + } + pos[d] -= (float)pos_grid[d]; + + // smoothstep instead of linear + if (interp == 1) { + pos_deriv[d] = smoothstep_derivative(pos[d]); + pos[d] = smoothstep(pos[d]); + } else { + pos_deriv[d] = 1.0f; + } + } + + // verification of alignment + // if (level == L - 1 && b < 4) { + // printf("[b=%d, l=%d] pos=(%f, %f)+(%d, %d)\n", b, level, pos[0], pos[1], pos_grid[0], pos_grid[1]); + // } + + // interpolate + scalar_t results[C] = {0}; // temp results in register + + #pragma unroll + for (uint32_t idx = 0; idx < (1 << D); idx++) { + float w = 1; + uint32_t pos_grid_local[D]; + + #pragma unroll + for (uint32_t d = 0; d < D; d++) { + if ((idx & (1 << d)) == 0) { + w *= 1 - pos[d]; + pos_grid_local[d] = pos_grid[d]; + } else { + w *= pos[d]; + pos_grid_local[d] = min(pos_grid[d] + 1, resolution - 1); + } + } + + uint32_t index = get_grid_index(gridtype, 0, hashmap_size, resolution, pos_grid_local); + + // writing to register (fast) + #pragma unroll + for (uint32_t ch = 0; ch < C; ch++) { + results[ch] += w * grid[index + ch]; + } + + //printf("[b=%d, l=%d] int %d, idx %d, w %f, val %f\n", b, level, idx, index, w, grid[index]); + } + + // writing to global memory (slow) + #pragma unroll + for (uint32_t ch = 0; ch < C; ch++) { + outputs[ch] = results[ch]; + } + + // prepare dy_dx + // differentiable (soft) indexing: https://discuss.pytorch.org/t/differentiable-indexing/17647/9 + if (dy_dx) { + + dy_dx += b * D * L * C + level * D * C; // B L D C + + #pragma unroll + for (uint32_t gd = 0; gd < D; gd++) { + + scalar_t results_grad[C] = {0}; + + #pragma unroll + for (uint32_t idx = 0; idx < (1 << (D - 1)); idx++) { + float w = (float)(align_corners ? resolution - 1 : resolution); + uint32_t pos_grid_local[D]; + + #pragma unroll + for (uint32_t nd = 0; nd < D - 1; nd++) { + const uint32_t d = (nd >= gd) ? (nd + 1) : nd; + + if ((idx & (1 << nd)) == 0) { + w *= 1 - pos[d]; + pos_grid_local[d] = pos_grid[d]; + } else { + w *= pos[d]; + pos_grid_local[d] = min(pos_grid[d] + 1, resolution - 1); + } + } + + pos_grid_local[gd] = pos_grid[gd]; + uint32_t index_left = get_grid_index(gridtype, 0, hashmap_size, resolution, pos_grid_local); + pos_grid_local[gd] = min(pos_grid[gd] + 1, resolution - 1); + uint32_t index_right = get_grid_index(gridtype, 0, hashmap_size, resolution, pos_grid_local); + + #pragma unroll + for (uint32_t ch = 0; ch < C; ch++) { + results_grad[ch] += w * (grid[index_right + ch] - grid[index_left + ch]) * pos_deriv[gd]; + } + } + + #pragma unroll + for (uint32_t ch = 0; ch < C; ch++) { + dy_dx[gd * C + ch] = results_grad[ch]; + } + } + } +} + + +template +__global__ void kernel_grid_backward( + const scalar_t * __restrict__ grad, + const float * __restrict__ inputs, + const scalar_t * __restrict__ grid, + const int * __restrict__ offsets, + scalar_t * __restrict__ grad_grid, + const uint32_t B, const uint32_t L, const float S, const uint32_t H, + const uint32_t gridtype, + const bool align_corners, + const uint32_t interp +) { + const uint32_t b = (blockIdx.x * blockDim.x + threadIdx.x) * N_C / C; + if (b >= B) return; + + const uint32_t level = blockIdx.y; + const uint32_t ch = (blockIdx.x * blockDim.x + threadIdx.x) * N_C - b * C; + + // locate + grad_grid += offsets[level] * C; + inputs += b * D; + grad += level * B * C + b * C + ch; // L, B, C + + const uint32_t hashmap_size = offsets[level + 1] - offsets[level]; + const uint32_t resolution = (uint32_t)ceil(exp2f(level * S) * H); + + // check input range (should be in [0, 1]) + #pragma unroll + for (uint32_t d = 0; d < D; d++) { + if (inputs[d] < 0 || inputs[d] > 1) { + return; // grad is init as 0, so we simply return. + } + } + + // calculate coordinate + float pos[D]; + uint32_t pos_grid[D]; + + #pragma unroll + for (uint32_t d = 0; d < D; d++) { + // align_corners + if (align_corners) { + pos[d] = inputs[d] * (float)(resolution - 1); // [0, resolution - 1] + pos_grid[d] = min((uint32_t)floorf(pos[d]), resolution - 2); // left-top corner, [0, resolution - 2] + } else { + pos[d] = fminf(fmaxf(inputs[d] * (float)resolution - 0.5f, 0.0f), (float)(resolution - 1)); // [-0.5, resolution-0.5] --> [0, resolution - 1] + pos_grid[d] = (uint32_t)floorf(pos[d]); // left-top corner, [0, resolution - 1] + } + pos[d] -= (float)pos_grid[d]; + // smoothstep instead of linear + if (interp == 1) { + pos[d] = smoothstep(pos[d]); + } + } + + scalar_t grad_cur[N_C] = {0}; // fetch to register + #pragma unroll + for (uint32_t c = 0; c < N_C; c++) { + grad_cur[c] = grad[c]; + } + + // interpolate + #pragma unroll + for (uint32_t idx = 0; idx < (1 << D); idx++) { + float w = 1; + uint32_t pos_grid_local[D]; + + #pragma unroll + for (uint32_t d = 0; d < D; d++) { + if ((idx & (1 << d)) == 0) { + w *= 1 - pos[d]; + pos_grid_local[d] = pos_grid[d]; + } else { + w *= pos[d]; + pos_grid_local[d] = min(pos_grid[d] + 1, resolution - 1); + } + } + + uint32_t index = get_grid_index(gridtype, ch, hashmap_size, resolution, pos_grid_local); + + // atomicAdd for __half is slow (especially for large values), so we use __half2 if N_C % 2 == 0 + // TODO: use float which is better than __half, if N_C % 2 != 0 + if (std::is_same::value && N_C % 2 == 0) { + #pragma unroll + for (uint32_t c = 0; c < N_C; c += 2) { + // process two __half at once (by interpreting as a __half2) + __half2 v = {(__half)(w * grad_cur[c]), (__half)(w * grad_cur[c + 1])}; + atomicAdd((__half2*)&grad_grid[index + c], v); + } + // float, or __half when N_C % 2 != 0 (which means C == 1) + } else { + #pragma unroll + for (uint32_t c = 0; c < N_C; c++) { + atomicAdd(&grad_grid[index + c], w * grad_cur[c]); + } + } + } +} + + +template +__global__ void kernel_input_backward( + const scalar_t * __restrict__ grad, + const scalar_t * __restrict__ dy_dx, + scalar_t * __restrict__ grad_inputs, + uint32_t B, uint32_t L +) { + const uint32_t t = threadIdx.x + blockIdx.x * blockDim.x; + if (t >= B * D) return; + + const uint32_t b = t / D; + const uint32_t d = t - b * D; + + dy_dx += b * L * D * C; + + scalar_t result = 0; + + # pragma unroll + for (int l = 0; l < L; l++) { + # pragma unroll + for (int ch = 0; ch < C; ch++) { + result += grad[l * B * C + b * C + ch] * dy_dx[l * D * C + d * C + ch]; + } + } + + grad_inputs[t] = result; +} + + +template +void kernel_grid_wrapper(const float *inputs, const scalar_t *embeddings, const int *offsets, scalar_t *outputs, const uint32_t B, const uint32_t C, const uint32_t L, const uint32_t max_level, const float S, const uint32_t H, scalar_t *dy_dx, const uint32_t gridtype, const bool align_corners, const uint32_t interp) { + static constexpr uint32_t N_THREAD = 512; + const dim3 blocks_hashgrid = { div_round_up(B, N_THREAD), max_level, 1 }; + switch (C) { + case 1: kernel_grid<<>>(inputs, embeddings, offsets, outputs, B, L, S, H, dy_dx, gridtype, align_corners, interp); break; + case 2: kernel_grid<<>>(inputs, embeddings, offsets, outputs, B, L, S, H, dy_dx, gridtype, align_corners, interp); break; + case 4: kernel_grid<<>>(inputs, embeddings, offsets, outputs, B, L, S, H, dy_dx, gridtype, align_corners, interp); break; + case 8: kernel_grid<<>>(inputs, embeddings, offsets, outputs, B, L, S, H, dy_dx, gridtype, align_corners, interp); break; + case 16: kernel_grid<<>>(inputs, embeddings, offsets, outputs, B, L, S, H, dy_dx, gridtype, align_corners, interp); break; + case 32: kernel_grid<<>>(inputs, embeddings, offsets, outputs, B, L, S, H, dy_dx, gridtype, align_corners, interp); break; + default: throw std::runtime_error{"GridEncoding: C must be 1, 2, 4, 8, 16 or 32."}; + } +} + +// inputs: [B, D], float, in [0, 1] +// embeddings: [sO, C], float +// offsets: [L + 1], uint32_t +// outputs: [L, B, C], float (L first, so only one level of hashmap needs to fit into cache at a time.) +// H: base resolution +// dy_dx: [B, L * D * C] +template +void grid_encode_forward_cuda(const float *inputs, const scalar_t *embeddings, const int *offsets, scalar_t *outputs, const uint32_t B, const uint32_t D, const uint32_t C, const uint32_t L, const uint32_t max_level, const float S, const uint32_t H, scalar_t *dy_dx, const uint32_t gridtype, const bool align_corners, const uint32_t interp) { + switch (D) { + case 2: kernel_grid_wrapper(inputs, embeddings, offsets, outputs, B, C, L, max_level, S, H, dy_dx, gridtype, align_corners, interp); break; + case 3: kernel_grid_wrapper(inputs, embeddings, offsets, outputs, B, C, L, max_level, S, H, dy_dx, gridtype, align_corners, interp); break; + case 4: kernel_grid_wrapper(inputs, embeddings, offsets, outputs, B, C, L, max_level, S, H, dy_dx, gridtype, align_corners, interp); break; + case 5: kernel_grid_wrapper(inputs, embeddings, offsets, outputs, B, C, L, max_level, S, H, dy_dx, gridtype, align_corners, interp); break; + default: throw std::runtime_error{"GridEncoding: D must be 2, 3, 4 or 5."}; + } +} + +template +void kernel_grid_backward_wrapper(const scalar_t *grad, const float *inputs, const scalar_t *embeddings, const int *offsets, scalar_t *grad_embeddings, const uint32_t B, const uint32_t C, const uint32_t L, const uint32_t max_level, const float S, const uint32_t H, scalar_t *dy_dx, scalar_t *grad_inputs, const uint32_t gridtype, const bool align_corners, const uint32_t interp) { + static constexpr uint32_t N_THREAD = 256; + const uint32_t N_C = std::min(2u, C); // n_features_per_thread + const dim3 blocks_hashgrid = { div_round_up(B * C / N_C, N_THREAD), max_level, 1 }; + switch (C) { + case 1: + kernel_grid_backward<<>>(grad, inputs, embeddings, offsets, grad_embeddings, B, L, S, H, gridtype, align_corners, interp); + if (dy_dx) kernel_input_backward<<>>(grad, dy_dx, grad_inputs, B, L); + break; + case 2: + kernel_grid_backward<<>>(grad, inputs, embeddings, offsets, grad_embeddings, B, L, S, H, gridtype, align_corners, interp); + if (dy_dx) kernel_input_backward<<>>(grad, dy_dx, grad_inputs, B, L); + break; + case 4: + kernel_grid_backward<<>>(grad, inputs, embeddings, offsets, grad_embeddings, B, L, S, H, gridtype, align_corners, interp); + if (dy_dx) kernel_input_backward<<>>(grad, dy_dx, grad_inputs, B, L); + break; + case 8: + kernel_grid_backward<<>>(grad, inputs, embeddings, offsets, grad_embeddings, B, L, S, H, gridtype, align_corners, interp); + if (dy_dx) kernel_input_backward<<>>(grad, dy_dx, grad_inputs, B, L); + break; + case 16: + kernel_grid_backward<<>>(grad, inputs, embeddings, offsets, grad_embeddings, B, L, S, H, gridtype, align_corners, interp); + if (dy_dx) kernel_input_backward<<>>(grad, dy_dx, grad_inputs, B, L); + break; + case 32: + kernel_grid_backward<<>>(grad, inputs, embeddings, offsets, grad_embeddings, B, L, S, H, gridtype, align_corners, interp); + if (dy_dx) kernel_input_backward<<>>(grad, dy_dx, grad_inputs, B, L); + break; + default: throw std::runtime_error{"GridEncoding: C must be 1, 2, 4, 8, 16 or 32."}; + } +} + + +// grad: [L, B, C], float +// inputs: [B, D], float, in [0, 1] +// embeddings: [sO, C], float +// offsets: [L + 1], uint32_t +// grad_embeddings: [sO, C] +// H: base resolution +template +void grid_encode_backward_cuda(const scalar_t *grad, const float *inputs, const scalar_t *embeddings, const int *offsets, scalar_t *grad_embeddings, const uint32_t B, const uint32_t D, const uint32_t C, const uint32_t L, const uint32_t max_level, const float S, const uint32_t H, scalar_t *dy_dx, scalar_t *grad_inputs, const uint32_t gridtype, const bool align_corners, const uint32_t interp) { + switch (D) { + case 2: kernel_grid_backward_wrapper(grad, inputs, embeddings, offsets, grad_embeddings, B, C, L, max_level, S, H, dy_dx, grad_inputs, gridtype, align_corners, interp); break; + case 3: kernel_grid_backward_wrapper(grad, inputs, embeddings, offsets, grad_embeddings, B, C, L, max_level, S, H, dy_dx, grad_inputs, gridtype, align_corners, interp); break; + case 4: kernel_grid_backward_wrapper(grad, inputs, embeddings, offsets, grad_embeddings, B, C, L, max_level, S, H, dy_dx, grad_inputs, gridtype, align_corners, interp); break; + case 5: kernel_grid_backward_wrapper(grad, inputs, embeddings, offsets, grad_embeddings, B, C, L, max_level, S, H, dy_dx, grad_inputs, gridtype, align_corners, interp); break; + default: throw std::runtime_error{"GridEncoding: D must be 2, 3, 4 or 5."}; + } +} + + + +void grid_encode_forward(const at::Tensor inputs, const at::Tensor embeddings, const at::Tensor offsets, at::Tensor outputs, const uint32_t B, const uint32_t D, const uint32_t C, const uint32_t L, const uint32_t max_level, const float S, const uint32_t H, at::optional dy_dx, const uint32_t gridtype, const bool align_corners, const uint32_t interp) { + CHECK_CUDA(inputs); + CHECK_CUDA(embeddings); + CHECK_CUDA(offsets); + CHECK_CUDA(outputs); + // CHECK_CUDA(dy_dx); + + CHECK_CONTIGUOUS(inputs); + CHECK_CONTIGUOUS(embeddings); + CHECK_CONTIGUOUS(offsets); + CHECK_CONTIGUOUS(outputs); + // CHECK_CONTIGUOUS(dy_dx); + + CHECK_IS_FLOATING(inputs); + CHECK_IS_FLOATING(embeddings); + CHECK_IS_INT(offsets); + CHECK_IS_FLOATING(outputs); + // CHECK_IS_FLOATING(dy_dx); + + AT_DISPATCH_FLOATING_TYPES_AND_HALF( + embeddings.scalar_type(), "grid_encode_forward", ([&] { + grid_encode_forward_cuda(inputs.data_ptr(), embeddings.data_ptr(), offsets.data_ptr(), outputs.data_ptr(), B, D, C, L, max_level, S, H, dy_dx.has_value() ? dy_dx.value().data_ptr() : nullptr, gridtype, align_corners, interp); + })); +} + +void grid_encode_backward(const at::Tensor grad, const at::Tensor inputs, const at::Tensor embeddings, const at::Tensor offsets, at::Tensor grad_embeddings, const uint32_t B, const uint32_t D, const uint32_t C, const uint32_t L, const uint32_t max_level, const float S, const uint32_t H, const at::optional dy_dx, at::optional grad_inputs, const uint32_t gridtype, const bool align_corners, const uint32_t interp) { + CHECK_CUDA(grad); + CHECK_CUDA(inputs); + CHECK_CUDA(embeddings); + CHECK_CUDA(offsets); + CHECK_CUDA(grad_embeddings); + // CHECK_CUDA(dy_dx); + // CHECK_CUDA(grad_inputs); + + CHECK_CONTIGUOUS(grad); + CHECK_CONTIGUOUS(inputs); + CHECK_CONTIGUOUS(embeddings); + CHECK_CONTIGUOUS(offsets); + CHECK_CONTIGUOUS(grad_embeddings); + // CHECK_CONTIGUOUS(dy_dx); + // CHECK_CONTIGUOUS(grad_inputs); + + CHECK_IS_FLOATING(grad); + CHECK_IS_FLOATING(inputs); + CHECK_IS_FLOATING(embeddings); + CHECK_IS_INT(offsets); + CHECK_IS_FLOATING(grad_embeddings); + // CHECK_IS_FLOATING(dy_dx); + // CHECK_IS_FLOATING(grad_inputs); + + AT_DISPATCH_FLOATING_TYPES_AND_HALF( + grad.scalar_type(), "grid_encode_backward", ([&] { + grid_encode_backward_cuda(grad.data_ptr(), inputs.data_ptr(), embeddings.data_ptr(), offsets.data_ptr(), grad_embeddings.data_ptr(), B, D, C, L, max_level, S, H, dy_dx.has_value() ? dy_dx.value().data_ptr() : nullptr, grad_inputs.has_value() ? grad_inputs.value().data_ptr() : nullptr, gridtype, align_corners, interp); + })); + +} + + +template +__global__ void kernel_grad_tv( + const scalar_t * __restrict__ inputs, + const scalar_t * __restrict__ grid, + scalar_t * __restrict__ grad, + const int * __restrict__ offsets, + const float weight, + const uint32_t B, const uint32_t L, const float S, const uint32_t H, + const uint32_t gridtype, + const bool align_corners +) { + const uint32_t b = blockIdx.x * blockDim.x + threadIdx.x; + + if (b >= B) return; + + const uint32_t level = blockIdx.y; + + // locate + inputs += b * D; + grid += (uint32_t)offsets[level] * C; + grad += (uint32_t)offsets[level] * C; + + // check input range (should be in [0, 1]) + bool flag_oob = false; + #pragma unroll + for (uint32_t d = 0; d < D; d++) { + if (inputs[d] < 0 || inputs[d] > 1) { + flag_oob = true; + } + } + + // if input out of bound, do nothing + if (flag_oob) return; + + const uint32_t hashmap_size = offsets[level + 1] - offsets[level]; + const uint32_t resolution = (uint32_t)ceil(exp2f(level * S) * H); + + // calculate coordinate + float pos[D]; + uint32_t pos_grid[D]; // [0, resolution] + + #pragma unroll + for (uint32_t d = 0; d < D; d++) { + // align_corners + if (align_corners) { + pos[d] = inputs[d] * (float)(resolution - 1); // [0, resolution - 1] + pos_grid[d] = min((uint32_t)floorf(pos[d]), resolution - 2); // left-top corner, [0, resolution - 2] + } else { + pos[d] = fminf(fmaxf(inputs[d] * (float)resolution - 0.5f, 0.0f), (float)(resolution - 1)); // [-0.5, resolution-0.5] --> [0, resolution - 1] + pos_grid[d] = (uint32_t)floorf(pos[d]); // left-top corner, [0, resolution - 1] + } + } + + //printf("[b=%d, l=%d] pos=(%f, %f)+(%d, %d)\n", b, level, pos[0], pos[1], pos_grid[0], pos_grid[1]); + + // total variation on pos_grid + scalar_t results[C] = {0}; // temp results in register + scalar_t idelta[C] = {0}; + + uint32_t index = get_grid_index(gridtype, 0, hashmap_size, resolution, pos_grid); + + scalar_t w = weight / (2 * D); + + #pragma unroll + for (uint32_t d = 0; d < D; d++) { + + uint32_t cur_d = pos_grid[d]; + scalar_t grad_val; + + // right side + if (cur_d < resolution) { + pos_grid[d] = cur_d + 1; + uint32_t index_right = get_grid_index(gridtype, 0, hashmap_size, resolution, pos_grid); + + #pragma unroll + for (uint32_t ch = 0; ch < C; ch++) { + grad_val = (grid[index + ch] - grid[index_right + ch]); + results[ch] += grad_val; + idelta[ch] += grad_val * grad_val; + } + } + + // left side + if (cur_d > 0) { + pos_grid[d] = cur_d - 1; + uint32_t index_left = get_grid_index(gridtype, 0, hashmap_size, resolution, pos_grid); + + #pragma unroll + for (uint32_t ch = 0; ch < C; ch++) { + grad_val = (grid[index + ch] - grid[index_left + ch]); + results[ch] += grad_val; + idelta[ch] += grad_val * grad_val; + } + } + + // reset + pos_grid[d] = cur_d; + } + + // writing to global memory (slow) + #pragma unroll + for (uint32_t ch = 0; ch < C; ch++) { + // index may collide, so use atomic! + atomicAdd(&grad[index + ch], w * results[ch] * rsqrtf(idelta[ch] + 1e-9f)); + } + +} + + +template +void kernel_grad_tv_wrapper(const scalar_t *inputs, const scalar_t *embeddings, scalar_t *grad, const int *offsets, const float weight, const uint32_t B, const uint32_t C, const uint32_t L, const float S, const uint32_t H, const uint32_t gridtype, const bool align_corners) { + static constexpr uint32_t N_THREAD = 512; + const dim3 blocks_hashgrid = { div_round_up(B, N_THREAD), L, 1 }; + switch (C) { + case 1: kernel_grad_tv<<>>(inputs, embeddings, grad, offsets, weight, B, L, S, H, gridtype, align_corners); break; + case 2: kernel_grad_tv<<>>(inputs, embeddings, grad, offsets, weight, B, L, S, H, gridtype, align_corners); break; + case 4: kernel_grad_tv<<>>(inputs, embeddings, grad, offsets, weight, B, L, S, H, gridtype, align_corners); break; + case 8: kernel_grad_tv<<>>(inputs, embeddings, grad, offsets, weight, B, L, S, H, gridtype, align_corners); break; + case 16: kernel_grad_tv<<>>(inputs, embeddings, grad, offsets, weight, B, L, S, H, gridtype, align_corners); break; + case 32: kernel_grad_tv<<>>(inputs, embeddings, grad, offsets, weight, B, L, S, H, gridtype, align_corners); break; + default: throw std::runtime_error{"GridEncoding: C must be 1, 2, 4, 8, 16 or 32."}; + } +} + + +template +void grad_total_variation_cuda(const scalar_t *inputs, const scalar_t *embeddings, scalar_t *grad, const int *offsets, const float weight, const uint32_t B, const uint32_t D, const uint32_t C, const uint32_t L, const float S, const uint32_t H, const uint32_t gridtype, const bool align_corners) { + switch (D) { + case 2: kernel_grad_tv_wrapper(inputs, embeddings, grad, offsets, weight, B, C, L, S, H, gridtype, align_corners); break; + case 3: kernel_grad_tv_wrapper(inputs, embeddings, grad, offsets, weight, B, C, L, S, H, gridtype, align_corners); break; + case 4: kernel_grad_tv_wrapper(inputs, embeddings, grad, offsets, weight, B, C, L, S, H, gridtype, align_corners); break; + case 5: kernel_grad_tv_wrapper(inputs, embeddings, grad, offsets, weight, B, C, L, S, H, gridtype, align_corners); break; + default: throw std::runtime_error{"GridEncoding: D must be 2, 3, 4, or 5."}; + } +} + + +void grad_total_variation(const at::Tensor inputs, const at::Tensor embeddings, at::Tensor grad, const at::Tensor offsets, const float weight, const uint32_t B, const uint32_t D, const uint32_t C, const uint32_t L, const float S, const uint32_t H, const uint32_t gridtype, const bool align_corners) { + + AT_DISPATCH_FLOATING_TYPES_AND_HALF( + embeddings.scalar_type(), "grad_total_variation", ([&] { + grad_total_variation_cuda(inputs.data_ptr(), embeddings.data_ptr(), grad.data_ptr(), offsets.data_ptr(), weight, B, D, C, L, S, H, gridtype, align_corners); + })); +} + +template +__global__ void kernel_grad_wd( + const scalar_t * __restrict__ grid, + scalar_t * __restrict__ grad, + const int * __restrict__ offsets, + const float weight, + const uint32_t B, const uint32_t L, const uint32_t C +) { + const uint32_t b = blockIdx.x * blockDim.x + threadIdx.x; + + if (b >= B * C) return; + + // locate + grid += b; + grad += b; + + // decide in which level is this thread... + uint32_t level = 0; + const uint32_t n = b / C; + // binary search b in offsets + uint32_t l = 0, r = L; + while (l < r) { + uint32_t m = (l + r) / 2; + if (offsets[m] <= n) { + level = m; + l = m + 1; + } else { + r = m; + } + } + + const uint32_t hashmap_size = offsets[level + 1] - offsets[level]; + grad[0] += 2 * weight * grid[0] / hashmap_size; +} + +void grad_weight_decay(const at::Tensor embeddings, at::Tensor grad, const at::Tensor offsets, const float weight, const uint32_t B, const uint32_t C, const uint32_t L) { + + AT_DISPATCH_FLOATING_TYPES_AND_HALF( + embeddings.scalar_type(), "grad_weight_decay", ([&] { + static constexpr uint32_t N_THREAD = 1024; + const dim3 blocks_hashgrid = { div_round_up(B * C, N_THREAD), 1, 1 }; + kernel_grad_wd<<>>(embeddings.data_ptr(), grad.data_ptr(), offsets.data_ptr(), weight, B, L, C); + })); +} \ No newline at end of file diff --git a/gridencoder/src/gridencoder.h b/gridencoder/src/gridencoder.h new file mode 100644 index 0000000..3df2e08 --- /dev/null +++ b/gridencoder/src/gridencoder.h @@ -0,0 +1,18 @@ +#ifndef _HASH_ENCODE_H +#define _HASH_ENCODE_H + +#include +#include + +// inputs: [B, D], float, in [0, 1] +// embeddings: [sO, C], float +// offsets: [L + 1], uint32_t +// outputs: [B, L * C], float +// H: base resolution +void grid_encode_forward(const at::Tensor inputs, const at::Tensor embeddings, const at::Tensor offsets, at::Tensor outputs, const uint32_t B, const uint32_t D, const uint32_t C, const uint32_t L, const uint32_t max_level, const float S, const uint32_t H, at::optional dy_dx, const uint32_t gridtype, const bool align_corners, const uint32_t interp); +void grid_encode_backward(const at::Tensor grad, const at::Tensor inputs, const at::Tensor embeddings, const at::Tensor offsets, at::Tensor grad_embeddings, const uint32_t B, const uint32_t D, const uint32_t C, const uint32_t L, const uint32_t max_level, const float S, const uint32_t H, const at::optional dy_dx, at::optional grad_inputs, const uint32_t gridtype, const bool align_corners, const uint32_t interp); + +void grad_total_variation(const at::Tensor inputs, const at::Tensor embeddings, at::Tensor grad, const at::Tensor offsets, const float weight, const uint32_t B, const uint32_t D, const uint32_t C, const uint32_t L, const float S, const uint32_t H, const uint32_t gridtype, const bool align_corners); +void grad_weight_decay(const at::Tensor embeddings, at::Tensor grad, const at::Tensor offsets, const float weight, const uint32_t B, const uint32_t C, const uint32_t L); + +#endif \ No newline at end of file diff --git a/guidance/clip_utils.py b/guidance/clip_utils.py new file mode 100644 index 0000000..ddc0500 --- /dev/null +++ b/guidance/clip_utils.py @@ -0,0 +1,52 @@ +import torch +import torch.nn as nn + +import torchvision.transforms as T +import torchvision.transforms.functional as TF + +import clip + +class CLIP(nn.Module): + def __init__(self, device, **kwargs): + super().__init__() + + self.device = device + self.clip_model, self.clip_preprocess = clip.load("ViT-B/16", device=self.device, jit=False) + + self.aug = T.Compose([ + T.Resize((224, 224)), + T.Normalize((0.48145466, 0.4578275, 0.40821073), (0.26862954, 0.26130258, 0.27577711)), + ]) + + def get_text_embeds(self, prompt, **kwargs): + + text = clip.tokenize(prompt).to(self.device) + text_z = self.clip_model.encode_text(text) + text_z = text_z / text_z.norm(dim=-1, keepdim=True) + + return text_z + + def get_img_embeds(self, image, **kwargs): + + image_z = self.clip_model.encode_image(self.aug(image)) + image_z = image_z / image_z.norm(dim=-1, keepdim=True) + + return image_z + + + def train_step(self, clip_z, pred_rgb, grad_scale=10, **kwargs): + + image_z = self.clip_model.encode_image(self.aug(pred_rgb)) + image_z = image_z / image_z.norm(dim=-1, keepdim=True) # normalize features + + loss = 0 + if 'image' in clip_z: + loss = loss - (image_z * clip_z['image']).sum(-1).mean() + + if 'text' in clip_z: + loss = loss - (image_z * clip_z['text']).sum(-1).mean() + + loss = loss * grad_scale + + return loss + diff --git a/guidance/if_utils.py b/guidance/if_utils.py new file mode 100644 index 0000000..0dcce22 --- /dev/null +++ b/guidance/if_utils.py @@ -0,0 +1,207 @@ +from transformers import logging +from diffusers import IFPipeline, DDPMScheduler + +# suppress partial model loading warning +logging.set_verbosity_error() + +import torch +import torch.nn as nn +import torch.nn.functional as F + +from torch.cuda.amp import custom_bwd, custom_fwd + + +class SpecifyGradient(torch.autograd.Function): + @staticmethod + @custom_fwd + def forward(ctx, input_tensor, gt_grad): + ctx.save_for_backward(gt_grad) + # we return a dummy value 1, which will be scaled by amp's scaler so we get the scale in backward. + return torch.ones([1], device=input_tensor.device, dtype=input_tensor.dtype) + + @staticmethod + @custom_bwd + def backward(ctx, grad_scale): + gt_grad, = ctx.saved_tensors + gt_grad = gt_grad * grad_scale + return gt_grad, None + +def seed_everything(seed): + torch.manual_seed(seed) + torch.cuda.manual_seed(seed) + #torch.backends.cudnn.deterministic = True + #torch.backends.cudnn.benchmark = True + + +class IF(nn.Module): + def __init__(self, device, vram_O, t_range=[0.02, 0.98]): + super().__init__() + + self.device = device + + print(f'[INFO] loading DeepFloyd IF-I-XL...') + + model_key = "DeepFloyd/IF-I-XL-v1.0" + + is_torch2 = torch.__version__[0] == '2' + + # Create model + pipe = IFPipeline.from_pretrained(model_key, variant="fp16", torch_dtype=torch.float16) + if not is_torch2: + pipe.enable_xformers_memory_efficient_attention() + + if vram_O: + pipe.unet.to(memory_format=torch.channels_last) + pipe.enable_attention_slicing(1) + pipe.enable_model_cpu_offload() + else: + pipe.to(device) + + self.unet = pipe.unet + self.tokenizer = pipe.tokenizer + self.text_encoder = pipe.text_encoder + self.unet = pipe.unet + self.scheduler = pipe.scheduler + + self.pipe = pipe + + self.num_train_timesteps = self.scheduler.config.num_train_timesteps + self.min_step = int(self.num_train_timesteps * t_range[0]) + self.max_step = int(self.num_train_timesteps * t_range[1]) + self.alphas = self.scheduler.alphas_cumprod.to(self.device) # for convenience + + print(f'[INFO] loaded DeepFloyd IF-I-XL!') + + @torch.no_grad() + def get_text_embeds(self, prompt): + # prompt: [str] + + # TODO: should I add the preprocessing at https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/deepfloyd_if/pipeline_if.py#LL486C10-L486C28 + prompt = self.pipe._text_preprocessing(prompt, clean_caption=False) + inputs = self.tokenizer(prompt, padding='max_length', max_length=77, truncation=True, add_special_tokens=True, return_tensors='pt') + embeddings = self.text_encoder(inputs.input_ids.to(self.device))[0] + + return embeddings + + + def train_step(self, text_embeddings, pred_rgb, guidance_scale=100, grad_scale=1): + + # [0, 1] to [-1, 1] and make sure shape is [64, 64] + images = F.interpolate(pred_rgb, (64, 64), mode='bilinear', align_corners=False) * 2 - 1 + + # timestep ~ U(0.02, 0.98) to avoid very high/low noise level + t = torch.randint(self.min_step, self.max_step + 1, (images.shape[0],), dtype=torch.long, device=self.device) + + # predict the noise residual with unet, NO grad! + with torch.no_grad(): + # add noise + noise = torch.randn_like(images) + images_noisy = self.scheduler.add_noise(images, noise, t) + + # pred noise + model_input = torch.cat([images_noisy] * 2) + model_input = self.scheduler.scale_model_input(model_input, t) + tt = torch.cat([t] * 2) + noise_pred = self.unet(model_input, tt, encoder_hidden_states=text_embeddings).sample + noise_pred_uncond, noise_pred_text = noise_pred.chunk(2) + noise_pred_uncond, _ = noise_pred_uncond.split(model_input.shape[1], dim=1) + noise_pred_text, predicted_variance = noise_pred_text.split(model_input.shape[1], dim=1) + noise_pred = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond) + + # TODO: how to use the variance here? + # noise_pred = torch.cat([noise_pred, predicted_variance], dim=1) + + # w(t), sigma_t^2 + w = (1 - self.alphas[t]) + grad = grad_scale * w[:, None, None, None] * (noise_pred - noise) + grad = torch.nan_to_num(grad) + + # since we omitted an item in grad, we need to use the custom function to specify the gradient + loss = SpecifyGradient.apply(images, grad) + + return loss + + @torch.no_grad() + def produce_imgs(self, text_embeddings, height=64, width=64, num_inference_steps=50, guidance_scale=7.5): + + images = torch.randn((1, 3, height, width), device=text_embeddings.device, dtype=text_embeddings.dtype) + images = images * self.scheduler.init_noise_sigma + + self.scheduler.set_timesteps(num_inference_steps) + + for i, t in enumerate(self.scheduler.timesteps): + # expand the latents if we are doing classifier-free guidance to avoid doing two forward passes. + model_input = torch.cat([images] * 2) + model_input = self.scheduler.scale_model_input(model_input, t) + + # predict the noise residual + noise_pred = self.unet(model_input, t, encoder_hidden_states=text_embeddings).sample + + # perform guidance + noise_pred_uncond, noise_pred_text = noise_pred.chunk(2) + noise_pred_uncond, _ = noise_pred_uncond.split(model_input.shape[1], dim=1) + noise_pred_text, predicted_variance = noise_pred_text.split(model_input.shape[1], dim=1) + noise_pred = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond) + noise_pred = torch.cat([noise_pred, predicted_variance], dim=1) + + # compute the previous noisy sample x_t -> x_t-1 + images = self.scheduler.step(noise_pred, t, images).prev_sample + + images = (images + 1) / 2 + + return images + + + def prompt_to_img(self, prompts, negative_prompts='', height=512, width=512, num_inference_steps=50, guidance_scale=7.5, latents=None): + + if isinstance(prompts, str): + prompts = [prompts] + + if isinstance(negative_prompts, str): + negative_prompts = [negative_prompts] + + # Prompts -> text embeds + pos_embeds = self.get_text_embeds(prompts) # [1, 77, 768] + neg_embeds = self.get_text_embeds(negative_prompts) + text_embeds = torch.cat([neg_embeds, pos_embeds], dim=0) # [2, 77, 768] + + # Text embeds -> img + imgs = self.produce_imgs(text_embeds, height=height, width=width, num_inference_steps=num_inference_steps, guidance_scale=guidance_scale) # [1, 4, 64, 64] + + # Img to Numpy + imgs = imgs.detach().cpu().permute(0, 2, 3, 1).numpy() + imgs = (imgs * 255).round().astype('uint8') + + return imgs + + +if __name__ == '__main__': + + import argparse + import matplotlib.pyplot as plt + + parser = argparse.ArgumentParser() + parser.add_argument('prompt', type=str) + parser.add_argument('--negative', default='', type=str) + parser.add_argument('--vram_O', action='store_true', help="optimization for low VRAM usage") + parser.add_argument('-H', type=int, default=64) + parser.add_argument('-W', type=int, default=64) + parser.add_argument('--seed', type=int, default=0) + parser.add_argument('--steps', type=int, default=50) + opt = parser.parse_args() + + seed_everything(opt.seed) + + device = torch.device('cuda') + + sd = IF(device, opt.vram_O) + + imgs = sd.prompt_to_img(opt.prompt, opt.negative, opt.H, opt.W, opt.steps) + + # visualize image + plt.imshow(imgs[0]) + plt.show() + + + + diff --git a/guidance/sd_utils.py b/guidance/sd_utils.py new file mode 100644 index 0000000..4bef064 --- /dev/null +++ b/guidance/sd_utils.py @@ -0,0 +1,707 @@ +from typing import List, Optional, Sequence, Tuple, Union, Mapping +import os + +from dataclasses import dataclass +from torch.cuda.amp import custom_bwd, custom_fwd +import torch +from torch import Tensor +import torch.nn.functional as F +import torch.nn as nn +import torch.nn.functional as F +from diffusers import AutoencoderKL, UNet2DConditionModel, PNDMScheduler, DDIMScheduler, StableDiffusionPipeline, StableDiffusionImg2ImgPipeline +from diffusers.utils.import_utils import is_xformers_available +from os.path import isfile +from pathlib import Path +import numpy as np +from PIL import Image +from torchvision.io import read_image +from torchvision import transforms +from torchvision.transforms import functional as TVF +from torchvision.utils import make_grid, save_image +from transformers import CLIPFeatureExtractor, CLIPModel, CLIPTokenizer, CLIPProcessor +import logging +logger = logging.getLogger(__name__) + + +def spherical_dist_loss(x, y): + x = F.normalize(x, dim=-1) + y = F.normalize(y, dim=-1) + return (x - y).norm(dim=-1).div(2).arcsin().pow(2).mul(2) + + +def seed_everything(seed=None): + if seed: + seed = int(seed) + random.seed(seed) + os.environ['PYTHONHASHSEED'] = str(seed) + np.random.seed(seed) + torch.manual_seed(seed) + torch.cuda.manual_seed(seed) + # torch.backends.cudnn.deterministic = True + torch.backends.cudnn.benchmark = True + +def save_tensor2image(x: torch.Tensor, path, channel_last=True, quality=75, **kwargs): + # assume the input x is channel last + if x.ndim == 4 and channel_last: + x = x.permute(0, 3, 1, 2) + TVF.to_pil_image(make_grid(x, value_range=(0, 1), **kwargs)).save(path, quality=quality) + + +def to_pil(x: torch.Tensor, **kwargs) -> Image.Image: + return TVF.to_pil_image(make_grid(x, value_range=(0, 1), **kwargs)) + + +def to_np_img(x: torch.Tensor) -> np.ndarray: + return (x.detach().permute(0, 2, 3, 1).cpu().numpy() * 255).round().astype(np.uint8) + + +class SpecifyGradient(torch.autograd.Function): + @staticmethod + @custom_fwd + def forward(ctx, input_tensor, gt_grad): + ctx.save_for_backward(gt_grad) + # we return a dummy value 1, which will be scaled by amp's scaler so we get the scale in backward. + return torch.ones([1], device=input_tensor.device, dtype=input_tensor.dtype) + + @staticmethod + @custom_bwd + def backward(ctx, grad_scale): + gt_grad, = ctx.saved_tensors + gt_grad = gt_grad * grad_scale + return gt_grad, None + + +def token_replace(prompt, negative, learned_embeds_path): + # Set up automatic token replacement for prompt + if '' in prompt or '' in negative: + if learned_embeds_path is None: + raise ValueError( + '--learned_embeds_path must be specified when using ') + import torch + tmp = list(torch.load(learned_embeds_path, map_location='cpu').keys()) + if len(tmp) != 1: + raise ValueError( + 'Something is wrong with the dict passed in for --learned_embeds_path') + token = tmp[0] + prompt = prompt.replace('', token) + negative = negative.replace('', token) + logger.info(f'Prompt after replacing : {prompt}') + logger.info(f'Negative prompt after replacing : {negative}') + return prompt, negative + + +@dataclass +class UNet2DConditionOutput: + # Not sure how to check what unet_traced.pt contains, and user wants. HalfTensor or FloatTensor + sample: torch.HalfTensor + + +def enable_vram(pipe): + pipe.enable_sequential_cpu_offload() + pipe.enable_vae_slicing() + pipe.unet.to(memory_format=torch.channels_last) + pipe.enable_attention_slicing(1) + # pipe.enable_model_cpu_offload() + + +def get_model_path(sd_version='2.1', clip_version='large', hf_key=None): + if hf_key is not None: + logger.info(f'[INFO] using hugging face custom model key: {hf_key}') + sd_path = hf_key + elif sd_version == '2.1': + sd_path = "stabilityai/stable-diffusion-2-1-base" + elif sd_version == '2.0': + sd_path = "stabilityai/stable-diffusion-2-base" + elif sd_version == '1.5': + sd_path = "runwayml/stable-diffusion-v1-5" + else: + raise ValueError( + f'Stable-diffusion version {sd_version} not supported.') + if clip_version == 'base': + clip_path = "openai/clip-vit-base-patch32" + else: + clip_path = "openai/clip-vit-large-patch14" + return sd_path, clip_path + + +class StableDiffusion(nn.Module): + def __init__(self, device, fp16, vram_O, + sd_version='2.1', hf_key=None, + t_range=[0.02, 0.98], + use_clip=False, + clip_version='base', + clip_iterative=True, + clip_t=0.4, + **kwargs + ): + super().__init__() + + self.device = device + self.sd_version = sd_version + self.vram_O = vram_O + self.fp16 = fp16 + + logger.info(f'[INFO] loading stable diffusion...') + + sd_path, clip_path = get_model_path(sd_version, clip_version, hf_key) + self.precision_t = torch.float16 if fp16 else torch.float32 + + # Create model + pipe = StableDiffusionPipeline.from_pretrained( + sd_path, torch_dtype=self.precision_t, local_files_only=False) + + if isfile('./unet_traced.pt'): + # use jitted unet + unet_traced = torch.jit.load('./unet_traced.pt') + + class TracedUNet(torch.nn.Module): + def __init__(self): + super().__init__() + self.in_channels = pipe.unet.in_channels + self.device = pipe.unet.device + + def forward(self, latent_model_input, t, encoder_hidden_states): + sample = unet_traced( + latent_model_input, t, encoder_hidden_states)[0] + return UNet2DConditionOutput(sample=sample) + pipe.unet = TracedUNet() + + self.vae = pipe.vae + self.tokenizer = pipe.tokenizer + self.text_encoder = pipe.text_encoder + self.unet = pipe.unet + + if kwargs.get('learned_embeds_path', None) is not None: + learned_embeds_path = kwargs['learned_embeds_path'] + if os.path.exists(learned_embeds_path): + logger.info( + f'[INFO] loading learned embeddings from {kwargs["learned_embeds_path"]}') + self.add_tokens_to_model_from_path(learned_embeds_path, kwargs.get('overrride_token', None)) + else: + logger.warning(f'learned_embeds_path {learned_embeds_path} does not exist!') + + if vram_O: + # this will change device from gpu to other types (meta) + enable_vram(pipe) + else: + if is_xformers_available(): + pipe.enable_xformers_memory_efficient_attention() + pipe.to(device) + + self.scheduler = DDIMScheduler.from_pretrained( + sd_path, subfolder="scheduler", torch_dtype=self.precision_t, local_files_only=False) + + self.num_train_timesteps = self.scheduler.config.num_train_timesteps + self.min_step = int(self.num_train_timesteps * t_range[0]) + self.max_step = int(self.num_train_timesteps * t_range[1]) + self.alphas = self.scheduler.alphas_cumprod.to( + self.device) # for convenience + + logger.info(f'[INFO] loaded stable diffusion!') + + # for CLIP + self.use_clip = use_clip + if self.use_clip: + #breakpoint() + self.clip_model = CLIPModel.from_pretrained(clip_path).to(device) + image_processor = CLIPProcessor.from_pretrained(clip_path).image_processor + self.image_processor = transforms.Compose([ + transforms.Resize((image_processor.crop_size['height'], image_processor.crop_size['width'])), + transforms.Normalize(image_processor.image_mean, image_processor.image_std), + ]) + for p in self.clip_model.parameters(): + p.requires_grad = False + + self.clip_iterative = clip_iterative + self.clip_t = int(self.num_train_timesteps * clip_t) + + @torch.no_grad() + def get_text_embeds(self, prompt): + # Tokenize text and get embeddings + text_input = self.tokenizer( + prompt, padding='max_length', max_length=self.tokenizer.model_max_length, truncation=True, return_tensors='pt') + + text_embeddings = self.text_encoder(text_input.input_ids.to(self.device))[0] + return text_embeddings + + @torch.no_grad() + def get_all_text_embeds(self, prompt): + # Tokenize text and get embeddings + text_input = self.tokenizer( + prompt, padding='max_length', max_length=self.tokenizer.model_max_length, truncation=True, return_tensors='pt') + + text_embeddings = self.text_encoder(text_input.input_ids.to(self.device)) + # text_z = text_z / text_z.norm(dim=-1, keepdim=True) + + # return all text embeddings and class embeddings + return torch.cat([text_embeddings[0], text_embeddings[1].unsqueeze(1)], dim=1) + + # @torch.no_grad() + def get_clip_img_embeds(self, img): + img = self.image_processor(img) + image_z = self.clip_model.get_image_features(img) + image_z = image_z / image_z.norm(dim=-1, keepdim=True) # normalize features + return image_z + + def clip_loss(self, ref_z, pred_rgb): + image_z = self.get_clip_img_embeds(pred_rgb) + loss = spherical_dist_loss(image_z, ref_z) + return loss + + + def set_epoch(self, epoch): + self.epoch = epoch + + def train_step(self, text_embeddings, pred_rgb, guidance_scale=100, as_latent=False, grad_clip=None, grad_scale=1.0, + image_ref_clip=None, text_ref_clip=None, clip_guidance=100, clip_image_loss=False, + density=None, + save_guidance_path=None + ): + enable_clip = self.use_clip and clip_guidance > 0 and not as_latent + enable_sds = True + #breakpoint() + if as_latent: + latents = F.interpolate( + pred_rgb, (64, 64), mode='bilinear', align_corners=False) * 2 - 1 + else: + # interp to 512x512 to be fed into vae. + pred_rgb_512 = F.interpolate( + pred_rgb, (512, 512), mode='bilinear', align_corners=False) + # encode image into latents with vae, requires grad! + latents = self.encode_imgs(pred_rgb_512) + + # timestep ~ U(0.02, 0.98) to avoid very high/low noise level + # Since during the optimzation, the 3D is getting better. + # mn = max(self.min_step, int(self.max_step - (self.max_step - self.min_step) / (self.opt.max_epoch // 3) * self.epoch + 0.5)) + t = torch.randint(self.min_step, self.max_step + 1, (latents.shape[0],), dtype=torch.long, device=self.device) + if enable_clip and self.clip_iterative: + if t > self.clip_t: + enable_clip = False + else: + enable_sds = False + + # predict the noise residual with unet, NO grad! + with torch.no_grad(): + # add noise + noise = torch.randn_like(latents) + latents_noisy = self.scheduler.add_noise(latents, noise, t) + + # pred noise + latent_model_input = torch.cat([latents_noisy] * 2) + # Save input tensors for UNet + # torch.save(latent_model_input, "train_latent_model_input.pt") + # torch.save(t, "train_t.pt") + # torch.save(text_embeddings, "train_text_embeddings.pt") + tt = torch.cat([t]*2) + noise_pred = self.unet(latent_model_input, tt, + encoder_hidden_states=text_embeddings).sample + + # perform guidance (high scale from paper!) + noise_pred_uncond, noise_pred_text = noise_pred.chunk(2) + noise_pred = noise_pred_text + guidance_scale * \ + (noise_pred_text - noise_pred_uncond) + + if enable_clip: + pred_original_sample = (latents_noisy - (1 - self.alphas[t]) ** (0.5) * noise_pred) / self.alphas[t] ** (0.5) + sample = pred_original_sample + sample = sample.detach().requires_grad_() + + sample = 1 / self.vae.config.scaling_factor * sample + out_image = self.vae.decode(sample).sample + out_image = (out_image / 2 + 0.5)#.clamp(0, 1) + image_embeddings_clip = self.get_clip_img_embeds(out_image) + ref_clip = image_ref_clip if clip_image_loss else text_ref_clip + loss_clip = spherical_dist_loss(image_embeddings_clip, ref_clip).mean() * clip_guidance * 50 # 100 + grad_clipd = - torch.autograd.grad(loss_clip, sample, retain_graph=True)[0] + else: + grad_clipd = 0 + + # import kiui + # latents_tmp = torch.randn((1, 4, 64, 64), device=self.device) + # latents_tmp = latents_tmp.detach() + # kiui.lo(latents_tmp) + # self.scheduler.set_timesteps(30) + # for i, t in enumerate(self.scheduler.timesteps): + # latent_model_input = torch.cat([latents_tmp] * 3) + # noise_pred = self.unet(latent_model_input, t, encoder_hidden_states=text_embeddings)['sample'] + # noise_pred_uncond, noise_pred_pos = noise_pred.chunk(2) + # noise_pred = noise_pred_uncond + 10 * (noise_pred_pos - noise_pred_uncond) + # latents_tmp = self.scheduler.step(noise_pred, t, latents_tmp)['prev_sample'] + # imgs = self.decode_latents(latents_tmp) + # kiui.vis.plot_image(imgs) + + if density is not None: + with torch.no_grad(): + density = F.interpolate(density.detach(), (64, 64), mode='bilinear', align_corners=False) + ids = torch.nonzero(density.squeeze()) + spatial_weight = torch.ones_like(density, device=density.device) + try: + up = ids[:, 0].min() + down = ids[:, 0].max() + 1 + ll = ids[:, 1].min() + rr = ids[:, 1].max() + 1 + spatial_weight[:, :, up:down, ll:rr] += 1 + except: + pass + # breakpoint() + # w(t), sigma_t^2 + w = (1 - self.alphas[t])[:, None, None, None] + # w = self.alphas[t] ** 0.5 * (1 - self.alphas[t]) + + if enable_sds: + grad_sds = grad_scale * w * (noise_pred - noise) + loss_sds = grad_sds.abs().mean().detach() + else: + grad_sds = 0. + loss_sds = 0. + + if enable_clip: + grad_clipd = w * grad_clipd.detach() + loss_clipd = grad_clipd.abs().mean().detach() + else: + grad_clipd = 0. + loss_clipd = 0. + + grad = grad_clipd + grad_sds + + if grad_clip is not None: + grad = grad.clamp(-grad_clip, grad_clip) + + if density is not None: + grad = grad * spatial_weight / 2 + + grad = torch.nan_to_num(grad) + + # since we omitted an item in grad, we need to use the custom function to specify the gradient + # loss = SpecifyGradient.apply(latents, grad) + # loss = loss.abs().mean().detach() + latents.backward(gradient=grad, retain_graph=True) + loss = grad.abs().mean().detach() + + if not enable_clip: + loss_sds = loss + + if save_guidance_path: + with torch.no_grad(): + # save original input + images = [] + os.makedirs(os.path.dirname(save_guidance_path), exist_ok=True) + timesteps = torch.arange(-1, 1000, 100, dtype=torch.long, device=self.device) + timesteps[0] *= 0 + for t in timesteps: + if as_latent: + pred_rgb_512 = self.decode_latents(latents) + latents_noisy = self.scheduler.add_noise(latents, noise, t) + + # pred noise + latent_model_input = torch.cat([latents_noisy] * 2) + + noise_pred = self.unet(latent_model_input, t, + encoder_hidden_states=text_embeddings).sample + + # perform guidance (high scale from paper!) + noise_pred_uncond, noise_pred_text = noise_pred.chunk(2) + noise_pred = noise_pred_text + guidance_scale * \ + (noise_pred_text - noise_pred_uncond) + + pred_original_sample = self.decode_latents((latents_noisy - (1 - self.alphas[t]) ** (0.5) * noise_pred) / self.alphas[t] ** (0.5)) + + # visualize predicted denoised image + # claforte: discuss this with Vikram!! + result_hopefully_less_noisy_image = self.decode_latents(latents - w*(noise_pred - noise)) + + # visualize noisier image + result_noisier_image = self.decode_latents(latents_noisy) + + # add in the last col, w/o rendered view contraint, using random noise as latent. + latent_model_input = torch.cat([noise] * 2) + noise_pred = self.unet(latent_model_input, t, + encoder_hidden_states=text_embeddings).sample + noise_pred_uncond, noise_pred_text = noise_pred.chunk(2) + noise_pred = noise_pred_text + guidance_scale * \ + (noise_pred_text - noise_pred_uncond) + noise_diffusion_out = self.decode_latents((noise - (1 - self.alphas[t]) ** (0.5) * noise_pred) / self.alphas[t] ** (0.5)) + # all 3 input images are [1, 3, H, W], e.g. [1, 3, 512, 512] + image = torch.cat([pred_rgb_512, pred_original_sample, result_noisier_image, result_hopefully_less_noisy_image, noise_diffusion_out],dim=0) + images.append(image) + viz_images = torch.cat(images, dim=0) + save_image(viz_images, save_guidance_path, nrow=5) + + return loss, {'loss_sds': loss_sds, 'loss_clipd': loss_clipd} + + @torch.no_grad() + def produce_latents(self, text_embeddings, height=512, width=512, num_inference_steps=50, guidance_scale=7.5, latents=None): + + if latents is None: + latents = torch.randn( + (text_embeddings.shape[0] // 2, self.unet.in_channels, height // 8, width // 8), device=self.device) + + self.scheduler.set_timesteps(num_inference_steps) + + with torch.autocast('cuda'): + for i, t in enumerate(self.scheduler.timesteps): + # expand the latents if we are doing classifier-free guidance to avoid doing two forward passes. + latent_model_input = torch.cat([latents] * 2) + # latent_model_input = scheduler.scale_model_input(latent_model_input, t) + + # Save input tensors for UNet + # torch.save(latent_model_input, "produce_latents_latent_model_input.pt") + # torch.save(t, "produce_latents_t.pt") + # torch.save(text_embeddings, "produce_latents_text_embeddings.pt") + # predict the noise residual + noise_pred = self.unet( + latent_model_input, t, encoder_hidden_states=text_embeddings)['sample'] + + # perform guidance + noise_pred_uncond, noise_pred_text = noise_pred.chunk(2) + noise_pred = noise_pred_text + guidance_scale * \ + (noise_pred_text - noise_pred_uncond) + + latents = self.scheduler.step(noise_pred, t, latents)[ + 'prev_sample'] + + return latents + + def decode_latents(self, latents): + + latents = 1 / self.vae.config.scaling_factor * latents + + # with torch.no_grad(): + imgs = self.vae.decode(latents).sample + + imgs = (imgs / 2 + 0.5).clamp(0, 1) + + return imgs + + def encode_imgs(self, imgs): + # imgs: [B, 3, H, W] + + imgs = 2 * imgs - 1 + + posterior = self.vae.encode(imgs).latent_dist + latents = posterior.sample() * self.vae.config.scaling_factor + + return latents + + def encode_imgs_mean(self, imgs): + # imgs: [B, 3, H, W] + + imgs = 2 * imgs - 1 + + latents = self.vae.encode(imgs).latent_dist.mean + latents = latents * self.vae.config.scaling_factor + + return latents + + @torch.no_grad() + def prompt_to_img(self, prompts, negative_prompts='', height=512, width=512, num_inference_steps=50, guidance_scale=7.5, latents=None, to_numpy=True): + + if isinstance(prompts, str): + prompts = [prompts] + + if isinstance(negative_prompts, str): + negative_prompts = [negative_prompts] * len(prompts) + + prompts = tuple(prompts) + negative_prompts = tuple(negative_prompts) + # Prompts -> text embeds + pos_embeds = self.get_text_embeds(prompts) # [1, 77, 768] + neg_embeds = self.get_text_embeds(negative_prompts) + text_embeds = torch.cat( + [neg_embeds, pos_embeds], dim=0) # [2, 77, 768] + + # Text embeds -> img latents + latents = self.produce_latents(text_embeds, height=height, width=width, latents=latents, + num_inference_steps=num_inference_steps, guidance_scale=guidance_scale) # [1, 4, 64, 64] + + # Img latents -> imgs + imgs = self.decode_latents(latents.to( + text_embeds.dtype)) # [1, 3, 512, 512] + + # Img to Numpy + if to_numpy: + imgs = to_np_img(imgs) + return imgs + + @torch.no_grad() + def img_to_img(self, prompts, negative_prompts='', height=512, width=512, num_inference_steps=50, guidance_scale=7.5, img=None, to_numpy=True, t=50): + """ + Known issues: + 1. Not able to reconstruct images even with no noise. + """ + if isinstance(prompts, str): + prompts = [prompts] + + if isinstance(negative_prompts, str): + negative_prompts = [negative_prompts] + + # Prompts -> text embeds + pos_embeds = self.get_text_embeds(prompts) # [1, 77, 768] + neg_embeds = self.get_text_embeds(negative_prompts) + text_embeds = torch.cat( + [neg_embeds, pos_embeds], dim=0) # [2, 77, 768] + + # image to latent + # interp to 512x512 to be fed into vae. + if isinstance(img, str): + img = TVF.to_tensor(Image.open(img))[None, :3].cuda() + + img_512 = F.interpolate( + img.to(text_embeds.dtype), (512, 512), mode='bilinear', align_corners=False) + # logger.info(img_512.shape, img_512, '\n', img_512.min(), img_512.max(), img_512.mean()) + + # encode image into latents with vae, requires grad! + latents = self.encode_imgs(img_512).repeat( + text_embeds.shape[0] // 2, 1, 1, 1) + # logger.info(latents.shape, latents, '\n', latents.min(), latents.max(), latents.mean()) + + noise = torch.randn_like(latents) + if t > 0: + latents_noise = self.scheduler.add_noise( + latents, noise, torch.tensor(t).to(torch.int32)) + else: + latents_noise = latents + + # Text embeds -> img latents + latents = self.produce_latents(text_embeds, height=height, width=width, latents=latents_noise, + num_inference_steps=num_inference_steps, guidance_scale=guidance_scale) # [1, 4, 64, 64] + + # Img latents -> imgs + imgs = self.decode_latents(latents.to( + text_embeds.dtype)) # [1, 3, 512, 512] + + # Img to Numpy + if to_numpy: + imgs = to_np_img(imgs) + return imgs + + def add_tokens_to_model(self, learned_embeds: Mapping[str, Tensor], override_token: Optional[Union[str, dict]] = None) -> None: + r"""Adds tokens to the tokenizer and text encoder of a model.""" + + # Loop over learned embeddings + new_tokens = [] + for token, embedding in learned_embeds.items(): + embedding = embedding.to( + self.text_encoder.get_input_embeddings().weight.dtype) + if override_token is not None: + token = override_token if isinstance( + override_token, str) else override_token[token] + + # Add the token to the tokenizer + num_added_tokens = self.tokenizer.add_tokens(token) + if num_added_tokens == 0: + raise ValueError((f"The tokenizer already contains the token {token}. Please pass a " + "different `token` that is not already in the tokenizer.")) + + # Resize the token embeddings + self.text_encoder._resize_token_embeddings(len(self.tokenizer)) + + # Get the id for the token and assign the embeds + token_id = self.tokenizer.convert_tokens_to_ids(token) + self.text_encoder.get_input_embeddings( + ).weight.data[token_id] = embedding + new_tokens.append(token) + + logger.info( + f'Added {len(new_tokens)} tokens to tokenizer and text embedding: {new_tokens}') + + def add_tokens_to_model_from_path(self, learned_embeds_path: str, override_token: Optional[Union[str, dict]] = None) -> None: + r"""Loads tokens from a file and adds them to the tokenizer and text encoder of a model.""" + learned_embeds: Mapping[str, Tensor] = torch.load( + learned_embeds_path, map_location='cpu') + self.add_tokens_to_model(learned_embeds, override_token) + + def check_prompt(self, opt): + texts = ['', ', front view', ', side view', ', back view'] + for view_text in texts: + text = opt.text + view_text + logger.info(f'Checking stable diffusion model with prompt: {text}') + # Generate + image_check = self.prompt_to_img( + prompts=[text] * opt.get('prompt_check_nums', 5), guidance_scale=7.5, to_numpy=False, + num_inference_steps=opt.get('num_inference_steps', 50)) + # Save + output_dir_check = Path(opt.workspace) / 'prompt_check' + output_dir_check.mkdir(exist_ok=True, parents=True) + to_pil(image_check).save(output_dir_check / f'generations_{view_text}.png') + (output_dir_check / 'prompt.txt').write_text(text) + + + +if __name__ == '__main__': + + import argparse + import matplotlib.pyplot as plt + from easydict import EasyDict as edict + import glob + + parser = argparse.ArgumentParser() + parser.add_argument('--text', type=str) + parser.add_argument('--negative', default='', type=str) + parser.add_argument('--workspace', default='out/sd', type=str) + parser.add_argument('--image_path', default=None, type=str) + parser.add_argument('--learned_embeds_path', type=str, + default=None, help="path to learned embeds" + ) + parser.add_argument('--sd_version', type=str, default='1.5', + choices=['1.5', '2.0', '2.1'], help="stable diffusion version") + parser.add_argument('--hf_key', type=str, default=None, + help="hugging face Stable diffusion model key") + parser.add_argument('--fp16', action='store_true', + help="use float16 for training") + parser.add_argument('--vram_O', action='store_true', + help="optimization for low VRAM usage") + parser.add_argument('--gudiance_scale', type=float, default=100) + parser.add_argument('-H', type=int, default=512) + parser.add_argument('-W', type=int, default=512) + parser.add_argument('--seed', type=int, default=0) + parser.add_argument('--num_inference_steps', type=int, default=50) + parser.add_argument('--noise_t', type=int, default=50) + parser.add_argument('--prompt_check_nums', type=int, default=5) + opt, unknown = parser.parse_known_args() + + # seed_everything(opt.seed) + device = torch.device('cuda') + opt = edict(vars(opt)) + workspace = opt.workspace + + opt.original_text = opt.text + opt.original_negative = opt.negative + if opt.learned_embeds_path is not None: + # cml: + # python guidance/sd_utils.py --text "A high-resolution DSLR image of " --learned_embeds_path out/learned_embeds/ --workspace out/teddy_bear + # check prompt + if os.path.isdir(opt.learned_embeds_path): + learned_embeds_paths = glob.glob(os.path.join(opt.learned_embeds_path, 'learned_embeds*bin')) + else: + learned_embeds_paths = [opt.learned_embeds_path] + + for learned_embeds_path in learned_embeds_paths: + embed_name = os.path.basename(learned_embeds_path).split('.')[0] + opt.workspace = os.path.join(workspace, embed_name) + sd = StableDiffusion(device, opt.fp16, opt.vram_O, + opt.sd_version, opt.hf_key, + learned_embeds_path=learned_embeds_path + ) + # Add tokenizer + if learned_embeds_path is not None: # add textual inversion tokens to model + opt.text, opt.negative = token_replace( + opt.original_text, opt.original_negative, learned_embeds_path) + logger.info(opt.text, opt.negative) + sd.check_prompt(opt) + else: + #breakpoint() + if opt.image_path is not None: + save_promt = '_'.join(opt.text.split(' ')) + '_' + opt.image_path.split( + '/')[-1].split('.')[0] + '_' + str(opt.noise_t) + '_' + str(opt.num_inference_steps) + imgs = sd.img_to_img([opt.text]*opt.prompt_check_nums, [opt.negative]*opt.prompt_check_nums, opt.H, opt.W, opt.num_inference_steps, + to_numpy=False, img=opt.image_path, t=opt.noise_t, guidance_scale=opt.gudiance_scale) + else: + save_promt = '_'.join(opt.text.split(' ')) + imgs = sd.prompt_to_img([opt.text]*opt.prompt_check_nums, [opt.negative] + * opt.prompt_check_nums, opt.H, opt.W, opt.num_inference_steps, to_numpy=False) + # visualize image + output_dir_check = Path(opt.workspace) + output_dir_check.mkdir(exist_ok=True, parents=True) + + to_pil(imgs).save(output_dir_check / f'{save_promt}.png') diff --git a/guidance/shape_utils.py b/guidance/shape_utils.py new file mode 100644 index 0000000..33e5b1c --- /dev/null +++ b/guidance/shape_utils.py @@ -0,0 +1,81 @@ +from typing import Any, Dict, Optional, Sequence, Tuple, Union +from shap_e.models.transmitter.base import Transmitter +from shap_e.models.query import Query +from shap_e.models.nerstf.renderer import NeRSTFRenderer +from shap_e.util.collections import AttrDict +from shap_e.diffusion.sample import sample_latents +from shap_e.diffusion.gaussian_diffusion import diffusion_from_config +from shap_e.models.download import load_model, load_config +from shap_e.util.image_util import load_image +from shap_e.models.nn.meta import subdict +import torch +import gc + + +camera_to_shapes = [ + torch.tensor([[1, 0, 0], [0, 1, 0], [0, 0, 1]], dtype=torch.float32), + torch.tensor([[1, 0, 0], [0, 0, 1], [0, -1, 0]], dtype=torch.float32), # to bird view + torch.tensor([[0, 1, 0], [0, 0, 1], [-1, 0, 0]], dtype=torch.float32), # to rotaed bird view + torch.tensor([[0, -1, 0], [0, 0, 1], [-1, 0, 0]], dtype=torch.float32), # to rotaed bird view + torch.tensor([[-1, 0, 0], [0, 0, 1], [0, -1, 0]], dtype=torch.float32), # to bird view + ] + + +def get_density( + render, + query: Query, + params: Dict[str, torch.Tensor], + options: AttrDict[str, Any], +) -> torch.Tensor: + assert render.nerstf is not None + return render.nerstf(query, params=subdict(params, "nerstf"), options=options).density + + +@torch.no_grad() +def get_shape_from_image(image_path, pos, + rpst_type='sdf', # or 'density' + get_color=True, + shape_guidance=3, device='cuda'): + xm = load_model('transmitter', device=device) + model = load_model('image300M', device=device) + diffusion = diffusion_from_config(load_config('diffusion')) + latent = sample_latents( + batch_size=1, + model=model, + diffusion=diffusion, + guidance_scale=shape_guidance, + model_kwargs=dict(images=[load_image(image_path)]), + progress=True, + clip_denoised=True, + use_fp16=True, + use_karras=True, + karras_steps=64, + sigma_min=1e-3, + sigma_max=160, + s_churn=0, + )[0] + + params = (xm.encoder if isinstance(xm, Transmitter) else xm).bottleneck_to_params( + latent[None] + ) + + rpsts, colors = [], [] + for camera_to_shape in camera_to_shapes: + query = Query( + position=pos @ camera_to_shape.to(pos.device), + direction=None, + ) + + if rpst_type == 'sdf': + rpst = xm.renderer.get_signed_distance(query, params, AttrDict()) + else: + rpst = get_density(xm.renderer, query, params, AttrDict()) + rpsts.append(rpst.squeeze()) + + if get_color: + color = xm.renderer.get_texture(query, params, AttrDict()) + else: + color = None + colors.append(color) + + return rpsts, colors \ No newline at end of file diff --git a/guidance/zero123_utils.py b/guidance/zero123_utils.py new file mode 100644 index 0000000..28c7513 --- /dev/null +++ b/guidance/zero123_utils.py @@ -0,0 +1,332 @@ +import math +import numpy as np +from omegaconf import OmegaConf +from pathlib import Path + +import torch +import torch.nn as nn +import torch.nn.functional as F +from torch.cuda.amp import custom_bwd, custom_fwd +from torchvision.utils import save_image + +from diffusers import DDIMScheduler + +import sys +from os import path +sys.path.append(path.dirname(path.dirname(path.abspath(__file__)))) + +from ldm.util import instantiate_from_config + +class SpecifyGradient(torch.autograd.Function): + @staticmethod + @custom_fwd + def forward(ctx, input_tensor, gt_grad): + ctx.save_for_backward(gt_grad) + # we return a dummy value 1, which will be scaled by amp's scaler so we get the scale in backward. + return torch.ones([1], device=input_tensor.device, dtype=input_tensor.dtype) + + @staticmethod + @custom_bwd + def backward(ctx, grad_scale): + gt_grad, = ctx.saved_tensors + gt_grad = gt_grad * grad_scale + return gt_grad, None + +# load model +def load_model_from_config(config, ckpt, device, vram_O=False, verbose=False): + + pl_sd = torch.load(ckpt, map_location='cpu') + + if 'global_step' in pl_sd and verbose: + print(f'[INFO] Global Step: {pl_sd["global_step"]}') + + sd = pl_sd['state_dict'] + + model = instantiate_from_config(config.model) + m, u = model.load_state_dict(sd, strict=False) + + if len(m) > 0 and verbose: + print('[INFO] missing keys: \n', m) + if len(u) > 0 and verbose: + print('[INFO] unexpected keys: \n', u) + + # manually load ema and delete it to save GPU memory + if model.use_ema: + if verbose: + print('[INFO] loading EMA...') + model.model_ema.copy_to(model.model) + del model.model_ema + + if vram_O: + # we don't need decoder + del model.first_stage_model.decoder + + torch.cuda.empty_cache() + + model.eval().to(device) + + return model + +class Zero123(nn.Module): + def __init__(self, device, fp16, + config='./pretrained/zero123/sd-objaverse-finetune-c_concat-256.yaml', + ckpt='./pretrained/zero123/105000.ckpt', vram_O=False, t_range=[0.02, 0.98], opt=None): + super().__init__() + + self.device = device + self.fp16 = fp16 + self.vram_O = vram_O + self.t_range = t_range + self.opt = opt + + self.config = OmegaConf.load(config) + self.model = load_model_from_config(self.config, ckpt, device=self.device, vram_O=vram_O) + + # timesteps: use diffuser for convenience... hope it's alright. + self.num_train_timesteps = self.config.model.params.timesteps + + self.scheduler = DDIMScheduler( + self.num_train_timesteps, + self.config.model.params.linear_start, + self.config.model.params.linear_end, + beta_schedule='scaled_linear', + clip_sample=False, + set_alpha_to_one=False, + steps_offset=1, + ) + + self.min_step = int(self.num_train_timesteps * t_range[0]) + self.max_step = int(self.num_train_timesteps * t_range[1]) + self.alphas = self.scheduler.alphas_cumprod.to(self.device) # for convenience + + @torch.no_grad() + def get_img_embeds(self, x): + # x: image tensor [B, 3, 256, 256] in [0, 1] + x = x * 2 - 1 + c = [self.model.get_learned_conditioning(xx.unsqueeze(0)) for xx in x] #.tile(n_samples, 1, 1) + v = [self.model.encode_first_stage(xx.unsqueeze(0)).mode() for xx in x] + return c, v + + def angle_between(self, sph_v1, sph_v2): + def sph2cart(sv): + r, theta, phi = sv[0], sv[1], sv[2] + return torch.tensor([r * torch.sin(theta) * torch.cos(phi), r * torch.sin(theta) * torch.sin(phi), r * torch.cos(theta)]) + def unit_vector(v): + return v / torch.linalg.norm(v) + def angle_between_2_sph(sv1, sv2): + v1, v2 = sph2cart(sv1), sph2cart(sv2) + v1_u, v2_u = unit_vector(v1), unit_vector(v2) + return torch.arccos(torch.clip(torch.dot(v1_u, v2_u), -1.0, 1.0)) + angles = torch.empty(len(sph_v1), len(sph_v2)) + for i, sv1 in enumerate(sph_v1): + for j, sv2 in enumerate(sph_v2): + angles[i][j] = angle_between_2_sph(sv1, sv2) + return angles + + def train_step(self, embeddings, pred_rgb, polar, azimuth, radius, guidance_scale=3, as_latent=False, grad_scale=1, save_guidance_path:Path=None): + # pred_rgb: tensor [1, 3, H, W] in [0, 1] + + # adjust SDS scale based on how far the novel view is from the known view + ref_radii = embeddings['ref_radii'] + ref_polars = embeddings['ref_polars'] + ref_azimuths = embeddings['ref_azimuths'] + v1 = torch.stack([radius + ref_radii[0], torch.deg2rad(polar + ref_polars[0]), torch.deg2rad(azimuth + ref_azimuths[0])], dim=-1) # polar,azimuth,radius are all actually delta wrt default + v2 = torch.stack([torch.tensor(ref_radii), torch.deg2rad(torch.tensor(ref_polars)), torch.deg2rad(torch.tensor(ref_azimuths))], dim=-1) + angles = torch.rad2deg(self.angle_between(v1, v2)).to(self.device) + if self.opt.zero123_grad_scale == 'angle': + grad_scale = (angles.min(dim=1)[0] / (180/len(ref_azimuths))) * grad_scale # rethink 180/len(ref_azimuths) # claforte: try inverting grad_scale or just fixing it to 1.0 + elif self.opt.zero123_grad_scale == 'None': + grad_scale = 1.0 # claforte: I think this might converge faster...? + else: + assert False, f'Unrecognized `zero123_grad_scale`: {self.opt.zero123_grad_scale}' + + if as_latent: + latents = F.interpolate(pred_rgb, (32, 32), mode='bilinear', align_corners=False) * 2 - 1 + else: + pred_rgb_256 = F.interpolate(pred_rgb, (256, 256), mode='bilinear', align_corners=False) + latents = self.encode_imgs(pred_rgb_256) + + t = torch.randint(self.min_step, self.max_step + 1, (latents.shape[0],), dtype=torch.long, device=self.device) + + # Set weights acc to closeness in angle + if len(ref_azimuths) > 1: + inv_angles = 1/angles + inv_angles[inv_angles > 100] = 100 + inv_angles /= inv_angles.max(dim=-1, keepdim=True)[0] + inv_angles[inv_angles < 0.1] = 0 + else: + inv_angles = torch.tensor([1.]).to(self.device) + + # Multiply closeness-weight by user-given weights + zero123_ws = torch.tensor(embeddings['zero123_ws'])[None, :].to(self.device) * inv_angles + zero123_ws /= zero123_ws.max(dim=-1, keepdim=True)[0] + zero123_ws[zero123_ws < 0.1] = 0 + + with torch.no_grad(): + noise = torch.randn_like(latents) + latents_noisy = self.scheduler.add_noise(latents, noise, t) + + x_in = torch.cat([latents_noisy] * 2) + t_in = torch.cat([t] * 2) + + noise_preds = [] + # Loop through each ref image + for (zero123_w, c_crossattn, c_concat, ref_polar, ref_azimuth, ref_radius) in zip(zero123_ws.T, + embeddings['c_crossattn'], embeddings['c_concat'], + ref_polars, ref_azimuths, ref_radii): + # polar,azimuth,radius are all actually delta wrt default + p = polar + ref_polars[0] - ref_polar + a = azimuth + ref_azimuths[0] - ref_azimuth + a[a > 180] -= 360 # range in [-180, 180] + r = radius + ref_radii[0] - ref_radius + # T = torch.tensor([math.radians(p), math.sin(math.radians(-a)), math.cos(math.radians(a)), r]) + # T = T[None, None, :].to(self.device) + T = torch.stack([torch.deg2rad(p), torch.sin(torch.deg2rad(-a)), torch.cos(torch.deg2rad(a)), r], dim=-1)[:, None, :] + cond = {} + clip_emb = self.model.cc_projection(torch.cat([c_crossattn.repeat(len(T), 1, 1), T], dim=-1)) + cond['c_crossattn'] = [torch.cat([torch.zeros_like(clip_emb).to(self.device), clip_emb], dim=0)] + cond['c_concat'] = [torch.cat([torch.zeros_like(c_concat).repeat(len(T), 1, 1, 1).to(self.device), c_concat.repeat(len(T), 1, 1, 1)], dim=0)] + noise_pred = self.model.apply_model(x_in, t_in, cond) + noise_pred_uncond, noise_pred_cond = noise_pred.chunk(2) + noise_pred = noise_pred_uncond + guidance_scale * (noise_pred_cond - noise_pred_uncond) + noise_preds.append(zero123_w[:, None, None, None] * noise_pred) + + noise_pred = torch.stack(noise_preds).sum(dim=0) / zero123_ws.sum(dim=-1)[:, None, None, None] + + w = (1 - self.alphas[t]) + grad = (grad_scale * w)[:, None, None, None] * (noise_pred - noise) + grad = torch.nan_to_num(grad) + + # import kiui + # if not as_latent: + # kiui.vis.plot_image(pred_rgb_256) + # kiui.vis.plot_matrix(latents) + # kiui.vis.plot_matrix(grad) + + # import kiui + # latents = torch.randn((1, 4, 32, 32), device=self.device) + # kiui.lo(latents) + # self.scheduler.set_timesteps(30) + # with torch.no_grad(): + # for i, t in enumerate(self.scheduler.timesteps): + # x_in = torch.cat([latents] * 2) + # t_in = torch.cat([t.view(1)] * 2).to(self.device) + + # noise_pred = self.model.apply_model(x_in, t_in, cond) + # noise_pred_uncond, noise_pred_cond = noise_pred.chunk(2) + # noise_pred = noise_pred_uncond + 3 * (noise_pred_cond - noise_pred_uncond) + + # latents = self.scheduler.step(noise_pred, t, latents)['prev_sample'] + # imgs = self.decode_latents(latents) + # print(polar, azimuth, radius) + # kiui.vis.plot_image(pred_rgb_256, imgs) + + if save_guidance_path: + with torch.no_grad(): + if as_latent: + pred_rgb_256 = self.decode_latents(latents) # claforte: test! + + # visualize predicted denoised image + result_hopefully_less_noisy_image = self.decode_latents(self.model.predict_start_from_noise(latents_noisy, t, noise_pred)) + + # visualize noisier image + result_noisier_image = self.decode_latents(latents_noisy) + + # all 3 input images are [1, 3, H, W], e.g. [1, 3, 512, 512] + viz_images = torch.cat([pred_rgb_256, result_noisier_image, result_hopefully_less_noisy_image],dim=-1) + save_image(viz_images, save_guidance_path) + + # since we omitted an item in grad, we need to use the custom function to specify the gradient + # loss = SpecifyGradient.apply(latents, grad) + latents.backward(gradient=grad, retain_graph=True) + loss = grad.abs().mean().detach() + return loss + + # verification + @torch.no_grad() + def __call__(self, + image, # image tensor [1, 3, H, W] in [0, 1] + polar=0, azimuth=0, radius=0, # new view params + scale=3, ddim_steps=50, ddim_eta=1, h=256, w=256, # diffusion params + c_crossattn=None, c_concat=None, post_process=True, + ): + + if c_crossattn is None: + embeddings = self.get_img_embeds(image) + + T = torch.tensor([math.radians(polar), math.sin(math.radians(azimuth)), math.cos(math.radians(azimuth)), radius]) + T = T[None, None, :].to(self.device) + + cond = {} + clip_emb = self.model.cc_projection(torch.cat([embeddings['c_crossattn'] if c_crossattn is None else c_crossattn, T], dim=-1)) + cond['c_crossattn'] = [torch.cat([torch.zeros_like(clip_emb).to(self.device), clip_emb], dim=0)] + cond['c_concat'] = [torch.cat([torch.zeros_like(embeddings['c_concat']).to(self.device), embeddings['c_concat']], dim=0)] if c_concat is None else [torch.cat([torch.zeros_like(c_concat).to(self.device), c_concat], dim=0)] + + # produce latents loop + latents = torch.randn((1, 4, h // 8, w // 8), device=self.device) + self.scheduler.set_timesteps(ddim_steps) + + for i, t in enumerate(self.scheduler.timesteps): + x_in = torch.cat([latents] * 2) + t_in = torch.cat([t.view(1)] * 2).to(self.device) + + noise_pred = self.model.apply_model(x_in, t_in, cond) + noise_pred_uncond, noise_pred_cond = noise_pred.chunk(2) + noise_pred = noise_pred_uncond + scale * (noise_pred_cond - noise_pred_uncond) + + latents = self.scheduler.step(noise_pred, t, latents, eta=ddim_eta)['prev_sample'] + + imgs = self.decode_latents(latents) + imgs = imgs.cpu().numpy().transpose(0, 2, 3, 1) if post_process else imgs + + return imgs + + def decode_latents(self, latents): + # zs: [B, 4, 32, 32] Latent space image + # with self.model.ema_scope(): + imgs = self.model.decode_first_stage(latents) + imgs = (imgs / 2 + 0.5).clamp(0, 1) + + return imgs # [B, 3, 256, 256] RGB space image + + def encode_imgs(self, imgs): + # imgs: [B, 3, 256, 256] RGB space image + # with self.model.ema_scope(): + imgs = imgs * 2 - 1 + latents = torch.cat([self.model.get_first_stage_encoding(self.model.encode_first_stage(img.unsqueeze(0))) for img in imgs], dim=0) + return latents # [B, 4, 32, 32] Latent space image + + +if __name__ == '__main__': + import cv2 + import argparse + import numpy as np + import matplotlib.pyplot as plt + + parser = argparse.ArgumentParser() + + parser.add_argument('input', type=str) + parser.add_argument('--fp16', action='store_true', help="use float16 for training") # no use now, can only run in fp32 + + parser.add_argument('--polar', type=float, default=0, help='delta polar angle in [-90, 90]') + parser.add_argument('--azimuth', type=float, default=0, help='delta azimuth angle in [-180, 180]') + parser.add_argument('--radius', type=float, default=0, help='delta camera radius multiplier in [-0.5, 0.5]') + + opt = parser.parse_args() + + device = torch.device('cuda') + + print(f'[INFO] loading image from {opt.input} ...') + image = cv2.imread(opt.input, cv2.IMREAD_UNCHANGED) + image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) + image = cv2.resize(image, (256, 256), interpolation=cv2.INTER_AREA) + image = image.astype(np.float32) / 255.0 + image = torch.from_numpy(image).permute(2, 0, 1).unsqueeze(0).contiguous().to(device) + + print(f'[INFO] loading model ...') + zero123 = Zero123(device, opt.fp16, opt=opt) + + print(f'[INFO] running model ...') + outputs = zero123(image, polar=opt.polar, azimuth=opt.azimuth, radius=opt.radius) + plt.imshow(outputs[0]) + plt.show() diff --git a/install.sh b/install.sh new file mode 100644 index 0000000..d3caa1f --- /dev/null +++ b/install.sh @@ -0,0 +1,24 @@ + +# for KAUST cluster +module load cuda/11.7.0 +module load gcc/7.5.0 +module load eigen + +# for aws ubuntu. install eigen +#sudo apt update && sudo apt upgrade +#sudo apt install libeigen3-dev + + # a100: 8.0; v100: 7.0; 2080ti: 7.5; titan xp: 6.1 +export TORCH_CUDA_ARCH_LIST="7.0;7.5;8.0" + +# use python venv +python -m venv venv_magic123 +source venv_magic123/bin/activate + +# use conda +# conda create -n magic123 python=3.10 ipython -y +# conda activate magic123 + +pip3 install torch torchvision +pip3 install -r requirements.txt +bash scripts/install_ext.sh \ No newline at end of file diff --git a/ldm/extras.py b/ldm/extras.py new file mode 100755 index 0000000..62e654b --- /dev/null +++ b/ldm/extras.py @@ -0,0 +1,77 @@ +from pathlib import Path +from omegaconf import OmegaConf +import torch +from ldm.util import instantiate_from_config +import logging +from contextlib import contextmanager + +from contextlib import contextmanager +import logging + +@contextmanager +def all_logging_disabled(highest_level=logging.CRITICAL): + """ + A context manager that will prevent any logging messages + triggered during the body from being processed. + + :param highest_level: the maximum logging level in use. + This would only need to be changed if a custom level greater than CRITICAL + is defined. + + https://gist.github.com/simon-weber/7853144 + """ + # two kind-of hacks here: + # * can't get the highest logging level in effect => delegate to the user + # * can't get the current module-level override => use an undocumented + # (but non-private!) interface + + previous_level = logging.root.manager.disable + + logging.disable(highest_level) + + try: + yield + finally: + logging.disable(previous_level) + +def load_training_dir(train_dir, device, epoch="last"): + """Load a checkpoint and config from training directory""" + train_dir = Path(train_dir) + ckpt = list(train_dir.rglob(f"*{epoch}.ckpt")) + assert len(ckpt) == 1, f"found {len(ckpt)} matching ckpt files" + config = list(train_dir.rglob(f"*-project.yaml")) + assert len(ckpt) > 0, f"didn't find any config in {train_dir}" + if len(config) > 1: + print(f"found {len(config)} matching config files") + config = sorted(config)[-1] + print(f"selecting {config}") + else: + config = config[0] + + + config = OmegaConf.load(config) + return load_model_from_config(config, ckpt[0], device) + +def load_model_from_config(config, ckpt, device="cpu", verbose=False): + """Loads a model from config and a ckpt + if config is a path will use omegaconf to load + """ + if isinstance(config, (str, Path)): + config = OmegaConf.load(config) + + with all_logging_disabled(): + print(f"Loading model from {ckpt}") + pl_sd = torch.load(ckpt, map_location="cpu") + global_step = pl_sd["global_step"] + sd = pl_sd["state_dict"] + model = instantiate_from_config(config.model) + m, u = model.load_state_dict(sd, strict=False) + if len(m) > 0 and verbose: + print("missing keys:") + print(m) + if len(u) > 0 and verbose: + print("unexpected keys:") + model.to(device) + model.eval() + model.cond_stage_model.device = device + return model \ No newline at end of file diff --git a/ldm/guidance.py b/ldm/guidance.py new file mode 100755 index 0000000..53d1a2a --- /dev/null +++ b/ldm/guidance.py @@ -0,0 +1,96 @@ +from typing import List, Tuple +from scipy import interpolate +import numpy as np +import torch +import matplotlib.pyplot as plt +from IPython.display import clear_output +import abc + + +class GuideModel(torch.nn.Module, abc.ABC): + def __init__(self) -> None: + super().__init__() + + @abc.abstractmethod + def preprocess(self, x_img): + pass + + @abc.abstractmethod + def compute_loss(self, inp): + pass + + +class Guider(torch.nn.Module): + def __init__(self, sampler, guide_model, scale=1.0, verbose=False): + """Apply classifier guidance + + Specify a guidance scale as either a scalar + Or a schedule as a list of tuples t = 0->1 and scale, e.g. + [(0, 10), (0.5, 20), (1, 50)] + """ + super().__init__() + self.sampler = sampler + self.index = 0 + self.show = verbose + self.guide_model = guide_model + self.history = [] + + if isinstance(scale, (Tuple, List)): + times = np.array([x[0] for x in scale]) + values = np.array([x[1] for x in scale]) + self.scale_schedule = {"times": times, "values": values} + else: + self.scale_schedule = float(scale) + + self.ddim_timesteps = sampler.ddim_timesteps + self.ddpm_num_timesteps = sampler.ddpm_num_timesteps + + + def get_scales(self): + if isinstance(self.scale_schedule, float): + return len(self.ddim_timesteps)*[self.scale_schedule] + + interpolater = interpolate.interp1d(self.scale_schedule["times"], self.scale_schedule["values"]) + fractional_steps = np.array(self.ddim_timesteps)/self.ddpm_num_timesteps + return interpolater(fractional_steps) + + def modify_score(self, model, e_t, x, t, c): + + # TODO look up index by t + scale = self.get_scales()[self.index] + + if (scale == 0): + return e_t + + sqrt_1ma = self.sampler.ddim_sqrt_one_minus_alphas[self.index].to(x.device) + with torch.enable_grad(): + x_in = x.detach().requires_grad_(True) + pred_x0 = model.predict_start_from_noise(x_in, t=t, noise=e_t) + x_img = model.first_stage_model.decode((1/0.18215)*pred_x0) + + inp = self.guide_model.preprocess(x_img) + loss = self.guide_model.compute_loss(inp) + grads = torch.autograd.grad(loss.sum(), x_in)[0] + correction = grads * scale + + if self.show: + clear_output(wait=True) + print(loss.item(), scale, correction.abs().max().item(), e_t.abs().max().item()) + self.history.append([loss.item(), scale, correction.min().item(), correction.max().item()]) + plt.imshow((inp[0].detach().permute(1,2,0).clamp(-1,1).cpu()+1)/2) + plt.axis('off') + plt.show() + plt.imshow(correction[0][0].detach().cpu()) + plt.axis('off') + plt.show() + + + e_t_mod = e_t - sqrt_1ma*correction + if self.show: + fig, axs = plt.subplots(1, 3) + axs[0].imshow(e_t[0][0].detach().cpu(), vmin=-2, vmax=+2) + axs[1].imshow(e_t_mod[0][0].detach().cpu(), vmin=-2, vmax=+2) + axs[2].imshow(correction[0][0].detach().cpu(), vmin=-2, vmax=+2) + plt.show() + self.index += 1 + return e_t_mod \ No newline at end of file diff --git a/ldm/lr_scheduler.py b/ldm/lr_scheduler.py new file mode 100755 index 0000000..be39da9 --- /dev/null +++ b/ldm/lr_scheduler.py @@ -0,0 +1,98 @@ +import numpy as np + + +class LambdaWarmUpCosineScheduler: + """ + note: use with a base_lr of 1.0 + """ + def __init__(self, warm_up_steps, lr_min, lr_max, lr_start, max_decay_steps, verbosity_interval=0): + self.lr_warm_up_steps = warm_up_steps + self.lr_start = lr_start + self.lr_min = lr_min + self.lr_max = lr_max + self.lr_max_decay_steps = max_decay_steps + self.last_lr = 0. + self.verbosity_interval = verbosity_interval + + def schedule(self, n, **kwargs): + if self.verbosity_interval > 0: + if n % self.verbosity_interval == 0: print(f"current step: {n}, recent lr-multiplier: {self.last_lr}") + if n < self.lr_warm_up_steps: + lr = (self.lr_max - self.lr_start) / self.lr_warm_up_steps * n + self.lr_start + self.last_lr = lr + return lr + else: + t = (n - self.lr_warm_up_steps) / (self.lr_max_decay_steps - self.lr_warm_up_steps) + t = min(t, 1.0) + lr = self.lr_min + 0.5 * (self.lr_max - self.lr_min) * ( + 1 + np.cos(t * np.pi)) + self.last_lr = lr + return lr + + def __call__(self, n, **kwargs): + return self.schedule(n,**kwargs) + + +class LambdaWarmUpCosineScheduler2: + """ + supports repeated iterations, configurable via lists + note: use with a base_lr of 1.0. + """ + def __init__(self, warm_up_steps, f_min, f_max, f_start, cycle_lengths, verbosity_interval=0): + assert len(warm_up_steps) == len(f_min) == len(f_max) == len(f_start) == len(cycle_lengths) + self.lr_warm_up_steps = warm_up_steps + self.f_start = f_start + self.f_min = f_min + self.f_max = f_max + self.cycle_lengths = cycle_lengths + self.cum_cycles = np.cumsum([0] + list(self.cycle_lengths)) + self.last_f = 0. + self.verbosity_interval = verbosity_interval + + def find_in_interval(self, n): + interval = 0 + for cl in self.cum_cycles[1:]: + if n <= cl: + return interval + interval += 1 + + def schedule(self, n, **kwargs): + cycle = self.find_in_interval(n) + n = n - self.cum_cycles[cycle] + if self.verbosity_interval > 0: + if n % self.verbosity_interval == 0: print(f"current step: {n}, recent lr-multiplier: {self.last_f}, " + f"current cycle {cycle}") + if n < self.lr_warm_up_steps[cycle]: + f = (self.f_max[cycle] - self.f_start[cycle]) / self.lr_warm_up_steps[cycle] * n + self.f_start[cycle] + self.last_f = f + return f + else: + t = (n - self.lr_warm_up_steps[cycle]) / (self.cycle_lengths[cycle] - self.lr_warm_up_steps[cycle]) + t = min(t, 1.0) + f = self.f_min[cycle] + 0.5 * (self.f_max[cycle] - self.f_min[cycle]) * ( + 1 + np.cos(t * np.pi)) + self.last_f = f + return f + + def __call__(self, n, **kwargs): + return self.schedule(n, **kwargs) + + +class LambdaLinearScheduler(LambdaWarmUpCosineScheduler2): + + def schedule(self, n, **kwargs): + cycle = self.find_in_interval(n) + n = n - self.cum_cycles[cycle] + if self.verbosity_interval > 0: + if n % self.verbosity_interval == 0: print(f"current step: {n}, recent lr-multiplier: {self.last_f}, " + f"current cycle {cycle}") + + if n < self.lr_warm_up_steps[cycle]: + f = (self.f_max[cycle] - self.f_start[cycle]) / self.lr_warm_up_steps[cycle] * n + self.f_start[cycle] + self.last_f = f + return f + else: + f = self.f_min[cycle] + (self.f_max[cycle] - self.f_min[cycle]) * (self.cycle_lengths[cycle] - n) / (self.cycle_lengths[cycle]) + self.last_f = f + return f + diff --git a/ldm/models/autoencoder.py b/ldm/models/autoencoder.py new file mode 100755 index 0000000..6a9c4f4 --- /dev/null +++ b/ldm/models/autoencoder.py @@ -0,0 +1,443 @@ +import torch +import pytorch_lightning as pl +import torch.nn.functional as F +from contextlib import contextmanager + +from taming.modules.vqvae.quantize import VectorQuantizer2 as VectorQuantizer + +from ldm.modules.diffusionmodules.model import Encoder, Decoder +from ldm.modules.distributions.distributions import DiagonalGaussianDistribution + +from ldm.util import instantiate_from_config + + +class VQModel(pl.LightningModule): + def __init__(self, + ddconfig, + lossconfig, + n_embed, + embed_dim, + ckpt_path=None, + ignore_keys=[], + image_key="image", + colorize_nlabels=None, + monitor=None, + batch_resize_range=None, + scheduler_config=None, + lr_g_factor=1.0, + remap=None, + sane_index_shape=False, # tell vector quantizer to return indices as bhw + use_ema=False + ): + super().__init__() + self.embed_dim = embed_dim + self.n_embed = n_embed + self.image_key = image_key + self.encoder = Encoder(**ddconfig) + self.decoder = Decoder(**ddconfig) + self.loss = instantiate_from_config(lossconfig) + self.quantize = VectorQuantizer(n_embed, embed_dim, beta=0.25, + remap=remap, + sane_index_shape=sane_index_shape) + self.quant_conv = torch.nn.Conv2d(ddconfig["z_channels"], embed_dim, 1) + self.post_quant_conv = torch.nn.Conv2d(embed_dim, ddconfig["z_channels"], 1) + if colorize_nlabels is not None: + assert type(colorize_nlabels)==int + self.register_buffer("colorize", torch.randn(3, colorize_nlabels, 1, 1)) + if monitor is not None: + self.monitor = monitor + self.batch_resize_range = batch_resize_range + if self.batch_resize_range is not None: + print(f"{self.__class__.__name__}: Using per-batch resizing in range {batch_resize_range}.") + + self.use_ema = use_ema + if self.use_ema: + self.model_ema = LitEma(self) + print(f"Keeping EMAs of {len(list(self.model_ema.buffers()))}.") + + if ckpt_path is not None: + self.init_from_ckpt(ckpt_path, ignore_keys=ignore_keys) + self.scheduler_config = scheduler_config + self.lr_g_factor = lr_g_factor + + @contextmanager + def ema_scope(self, context=None): + if self.use_ema: + self.model_ema.store(self.parameters()) + self.model_ema.copy_to(self) + if context is not None: + print(f"{context}: Switched to EMA weights") + try: + yield None + finally: + if self.use_ema: + self.model_ema.restore(self.parameters()) + if context is not None: + print(f"{context}: Restored training weights") + + def init_from_ckpt(self, path, ignore_keys=list()): + sd = torch.load(path, map_location="cpu")["state_dict"] + keys = list(sd.keys()) + for k in keys: + for ik in ignore_keys: + if k.startswith(ik): + print("Deleting key {} from state_dict.".format(k)) + del sd[k] + missing, unexpected = self.load_state_dict(sd, strict=False) + print(f"Restored from {path} with {len(missing)} missing and {len(unexpected)} unexpected keys") + if len(missing) > 0: + print(f"Missing Keys: {missing}") + print(f"Unexpected Keys: {unexpected}") + + def on_train_batch_end(self, *args, **kwargs): + if self.use_ema: + self.model_ema(self) + + def encode(self, x): + h = self.encoder(x) + h = self.quant_conv(h) + quant, emb_loss, info = self.quantize(h) + return quant, emb_loss, info + + def encode_to_prequant(self, x): + h = self.encoder(x) + h = self.quant_conv(h) + return h + + def decode(self, quant): + quant = self.post_quant_conv(quant) + dec = self.decoder(quant) + return dec + + def decode_code(self, code_b): + quant_b = self.quantize.embed_code(code_b) + dec = self.decode(quant_b) + return dec + + def forward(self, input, return_pred_indices=False): + quant, diff, (_,_,ind) = self.encode(input) + dec = self.decode(quant) + if return_pred_indices: + return dec, diff, ind + return dec, diff + + def get_input(self, batch, k): + x = batch[k] + if len(x.shape) == 3: + x = x[..., None] + x = x.permute(0, 3, 1, 2).to(memory_format=torch.contiguous_format).float() + if self.batch_resize_range is not None: + lower_size = self.batch_resize_range[0] + upper_size = self.batch_resize_range[1] + if self.global_step <= 4: + # do the first few batches with max size to avoid later oom + new_resize = upper_size + else: + new_resize = np.random.choice(np.arange(lower_size, upper_size+16, 16)) + if new_resize != x.shape[2]: + x = F.interpolate(x, size=new_resize, mode="bicubic") + x = x.detach() + return x + + def training_step(self, batch, batch_idx, optimizer_idx): + # https://github.com/pytorch/pytorch/issues/37142 + # try not to fool the heuristics + x = self.get_input(batch, self.image_key) + xrec, qloss, ind = self(x, return_pred_indices=True) + + if optimizer_idx == 0: + # autoencode + aeloss, log_dict_ae = self.loss(qloss, x, xrec, optimizer_idx, self.global_step, + last_layer=self.get_last_layer(), split="train", + predicted_indices=ind) + + self.log_dict(log_dict_ae, prog_bar=False, logger=True, on_step=True, on_epoch=True) + return aeloss + + if optimizer_idx == 1: + # discriminator + discloss, log_dict_disc = self.loss(qloss, x, xrec, optimizer_idx, self.global_step, + last_layer=self.get_last_layer(), split="train") + self.log_dict(log_dict_disc, prog_bar=False, logger=True, on_step=True, on_epoch=True) + return discloss + + def validation_step(self, batch, batch_idx): + log_dict = self._validation_step(batch, batch_idx) + with self.ema_scope(): + log_dict_ema = self._validation_step(batch, batch_idx, suffix="_ema") + return log_dict + + def _validation_step(self, batch, batch_idx, suffix=""): + x = self.get_input(batch, self.image_key) + xrec, qloss, ind = self(x, return_pred_indices=True) + aeloss, log_dict_ae = self.loss(qloss, x, xrec, 0, + self.global_step, + last_layer=self.get_last_layer(), + split="val"+suffix, + predicted_indices=ind + ) + + discloss, log_dict_disc = self.loss(qloss, x, xrec, 1, + self.global_step, + last_layer=self.get_last_layer(), + split="val"+suffix, + predicted_indices=ind + ) + rec_loss = log_dict_ae[f"val{suffix}/rec_loss"] + self.log(f"val{suffix}/rec_loss", rec_loss, + prog_bar=True, logger=True, on_step=False, on_epoch=True, sync_dist=True) + self.log(f"val{suffix}/aeloss", aeloss, + prog_bar=True, logger=True, on_step=False, on_epoch=True, sync_dist=True) + if version.parse(pl.__version__) >= version.parse('1.4.0'): + del log_dict_ae[f"val{suffix}/rec_loss"] + self.log_dict(log_dict_ae) + self.log_dict(log_dict_disc) + return self.log_dict + + def configure_optimizers(self): + lr_d = self.learning_rate + lr_g = self.lr_g_factor*self.learning_rate + print("lr_d", lr_d) + print("lr_g", lr_g) + opt_ae = torch.optim.Adam(list(self.encoder.parameters())+ + list(self.decoder.parameters())+ + list(self.quantize.parameters())+ + list(self.quant_conv.parameters())+ + list(self.post_quant_conv.parameters()), + lr=lr_g, betas=(0.5, 0.9)) + opt_disc = torch.optim.Adam(self.loss.discriminator.parameters(), + lr=lr_d, betas=(0.5, 0.9)) + + if self.scheduler_config is not None: + scheduler = instantiate_from_config(self.scheduler_config) + + print("Setting up LambdaLR scheduler...") + scheduler = [ + { + 'scheduler': LambdaLR(opt_ae, lr_lambda=scheduler.schedule), + 'interval': 'step', + 'frequency': 1 + }, + { + 'scheduler': LambdaLR(opt_disc, lr_lambda=scheduler.schedule), + 'interval': 'step', + 'frequency': 1 + }, + ] + return [opt_ae, opt_disc], scheduler + return [opt_ae, opt_disc], [] + + def get_last_layer(self): + return self.decoder.conv_out.weight + + def log_images(self, batch, only_inputs=False, plot_ema=False, **kwargs): + log = dict() + x = self.get_input(batch, self.image_key) + x = x.to(self.device) + if only_inputs: + log["inputs"] = x + return log + xrec, _ = self(x) + if x.shape[1] > 3: + # colorize with random projection + assert xrec.shape[1] > 3 + x = self.to_rgb(x) + xrec = self.to_rgb(xrec) + log["inputs"] = x + log["reconstructions"] = xrec + if plot_ema: + with self.ema_scope(): + xrec_ema, _ = self(x) + if x.shape[1] > 3: xrec_ema = self.to_rgb(xrec_ema) + log["reconstructions_ema"] = xrec_ema + return log + + def to_rgb(self, x): + assert self.image_key == "segmentation" + if not hasattr(self, "colorize"): + self.register_buffer("colorize", torch.randn(3, x.shape[1], 1, 1).to(x)) + x = F.conv2d(x, weight=self.colorize) + x = 2.*(x-x.min())/(x.max()-x.min()) - 1. + return x + + +class VQModelInterface(VQModel): + def __init__(self, embed_dim, *args, **kwargs): + super().__init__(embed_dim=embed_dim, *args, **kwargs) + self.embed_dim = embed_dim + + def encode(self, x): + h = self.encoder(x) + h = self.quant_conv(h) + return h + + def decode(self, h, force_not_quantize=False): + # also go through quantization layer + if not force_not_quantize: + quant, emb_loss, info = self.quantize(h) + else: + quant = h + quant = self.post_quant_conv(quant) + dec = self.decoder(quant) + return dec + + +class AutoencoderKL(pl.LightningModule): + def __init__(self, + ddconfig, + lossconfig, + embed_dim, + ckpt_path=None, + ignore_keys=[], + image_key="image", + colorize_nlabels=None, + monitor=None, + ): + super().__init__() + self.image_key = image_key + self.encoder = Encoder(**ddconfig) + self.decoder = Decoder(**ddconfig) + self.loss = instantiate_from_config(lossconfig) + assert ddconfig["double_z"] + self.quant_conv = torch.nn.Conv2d(2*ddconfig["z_channels"], 2*embed_dim, 1) + self.post_quant_conv = torch.nn.Conv2d(embed_dim, ddconfig["z_channels"], 1) + self.embed_dim = embed_dim + if colorize_nlabels is not None: + assert type(colorize_nlabels)==int + self.register_buffer("colorize", torch.randn(3, colorize_nlabels, 1, 1)) + if monitor is not None: + self.monitor = monitor + if ckpt_path is not None: + self.init_from_ckpt(ckpt_path, ignore_keys=ignore_keys) + + def init_from_ckpt(self, path, ignore_keys=list()): + sd = torch.load(path, map_location="cpu")["state_dict"] + keys = list(sd.keys()) + for k in keys: + for ik in ignore_keys: + if k.startswith(ik): + print("Deleting key {} from state_dict.".format(k)) + del sd[k] + self.load_state_dict(sd, strict=False) + print(f"Restored from {path}") + + def encode(self, x): + h = self.encoder(x) + moments = self.quant_conv(h) + posterior = DiagonalGaussianDistribution(moments) + return posterior + + def decode(self, z): + z = self.post_quant_conv(z) + dec = self.decoder(z) + return dec + + def forward(self, input, sample_posterior=True): + posterior = self.encode(input) + if sample_posterior: + z = posterior.sample() + else: + z = posterior.mode() + dec = self.decode(z) + return dec, posterior + + def get_input(self, batch, k): + x = batch[k] + if len(x.shape) == 3: + x = x[..., None] + x = x.permute(0, 3, 1, 2).to(memory_format=torch.contiguous_format).float() + return x + + def training_step(self, batch, batch_idx, optimizer_idx): + inputs = self.get_input(batch, self.image_key) + reconstructions, posterior = self(inputs) + + if optimizer_idx == 0: + # train encoder+decoder+logvar + aeloss, log_dict_ae = self.loss(inputs, reconstructions, posterior, optimizer_idx, self.global_step, + last_layer=self.get_last_layer(), split="train") + self.log("aeloss", aeloss, prog_bar=True, logger=True, on_step=True, on_epoch=True) + self.log_dict(log_dict_ae, prog_bar=False, logger=True, on_step=True, on_epoch=False) + return aeloss + + if optimizer_idx == 1: + # train the discriminator + discloss, log_dict_disc = self.loss(inputs, reconstructions, posterior, optimizer_idx, self.global_step, + last_layer=self.get_last_layer(), split="train") + + self.log("discloss", discloss, prog_bar=True, logger=True, on_step=True, on_epoch=True) + self.log_dict(log_dict_disc, prog_bar=False, logger=True, on_step=True, on_epoch=False) + return discloss + + def validation_step(self, batch, batch_idx): + inputs = self.get_input(batch, self.image_key) + reconstructions, posterior = self(inputs) + aeloss, log_dict_ae = self.loss(inputs, reconstructions, posterior, 0, self.global_step, + last_layer=self.get_last_layer(), split="val") + + discloss, log_dict_disc = self.loss(inputs, reconstructions, posterior, 1, self.global_step, + last_layer=self.get_last_layer(), split="val") + + self.log("val/rec_loss", log_dict_ae["val/rec_loss"]) + self.log_dict(log_dict_ae) + self.log_dict(log_dict_disc) + return self.log_dict + + def configure_optimizers(self): + lr = self.learning_rate + opt_ae = torch.optim.Adam(list(self.encoder.parameters())+ + list(self.decoder.parameters())+ + list(self.quant_conv.parameters())+ + list(self.post_quant_conv.parameters()), + lr=lr, betas=(0.5, 0.9)) + opt_disc = torch.optim.Adam(self.loss.discriminator.parameters(), + lr=lr, betas=(0.5, 0.9)) + return [opt_ae, opt_disc], [] + + def get_last_layer(self): + return self.decoder.conv_out.weight + + @torch.no_grad() + def log_images(self, batch, only_inputs=False, **kwargs): + log = dict() + x = self.get_input(batch, self.image_key) + x = x.to(self.device) + if not only_inputs: + xrec, posterior = self(x) + if x.shape[1] > 3: + # colorize with random projection + assert xrec.shape[1] > 3 + x = self.to_rgb(x) + xrec = self.to_rgb(xrec) + log["samples"] = self.decode(torch.randn_like(posterior.sample())) + log["reconstructions"] = xrec + log["inputs"] = x + return log + + def to_rgb(self, x): + assert self.image_key == "segmentation" + if not hasattr(self, "colorize"): + self.register_buffer("colorize", torch.randn(3, x.shape[1], 1, 1).to(x)) + x = F.conv2d(x, weight=self.colorize) + x = 2.*(x-x.min())/(x.max()-x.min()) - 1. + return x + + +class IdentityFirstStage(torch.nn.Module): + def __init__(self, *args, vq_interface=False, **kwargs): + self.vq_interface = vq_interface # TODO: Should be true by default but check to not break older stuff + super().__init__() + + def encode(self, x, *args, **kwargs): + return x + + def decode(self, x, *args, **kwargs): + return x + + def quantize(self, x, *args, **kwargs): + if self.vq_interface: + return x, None, [None, None, None] + return x + + def forward(self, x, *args, **kwargs): + return x diff --git a/ldm/models/diffusion/__init__.py b/ldm/models/diffusion/__init__.py new file mode 100755 index 0000000..e69de29 diff --git a/ldm/models/diffusion/classifier.py b/ldm/models/diffusion/classifier.py new file mode 100755 index 0000000..67e98b9 --- /dev/null +++ b/ldm/models/diffusion/classifier.py @@ -0,0 +1,267 @@ +import os +import torch +import pytorch_lightning as pl +from omegaconf import OmegaConf +from torch.nn import functional as F +from torch.optim import AdamW +from torch.optim.lr_scheduler import LambdaLR +from copy import deepcopy +from einops import rearrange +from glob import glob +from natsort import natsorted + +from ldm.modules.diffusionmodules.openaimodel import EncoderUNetModel, UNetModel +from ldm.util import log_txt_as_img, default, ismap, instantiate_from_config + +__models__ = { + 'class_label': EncoderUNetModel, + 'segmentation': UNetModel +} + + +def disabled_train(self, mode=True): + """Overwrite model.train with this function to make sure train/eval mode + does not change anymore.""" + return self + + +class NoisyLatentImageClassifier(pl.LightningModule): + + def __init__(self, + diffusion_path, + num_classes, + ckpt_path=None, + pool='attention', + label_key=None, + diffusion_ckpt_path=None, + scheduler_config=None, + weight_decay=1.e-2, + log_steps=10, + monitor='val/loss', + *args, + **kwargs): + super().__init__(*args, **kwargs) + self.num_classes = num_classes + # get latest config of diffusion model + diffusion_config = natsorted(glob(os.path.join(diffusion_path, 'configs', '*-project.yaml')))[-1] + self.diffusion_config = OmegaConf.load(diffusion_config).model + self.diffusion_config.params.ckpt_path = diffusion_ckpt_path + self.load_diffusion() + + self.monitor = monitor + self.numd = self.diffusion_model.first_stage_model.encoder.num_resolutions - 1 + self.log_time_interval = self.diffusion_model.num_timesteps // log_steps + self.log_steps = log_steps + + self.label_key = label_key if not hasattr(self.diffusion_model, 'cond_stage_key') \ + else self.diffusion_model.cond_stage_key + + assert self.label_key is not None, 'label_key neither in diffusion model nor in model.params' + + if self.label_key not in __models__: + raise NotImplementedError() + + self.load_classifier(ckpt_path, pool) + + self.scheduler_config = scheduler_config + self.use_scheduler = self.scheduler_config is not None + self.weight_decay = weight_decay + + def init_from_ckpt(self, path, ignore_keys=list(), only_model=False): + sd = torch.load(path, map_location="cpu") + if "state_dict" in list(sd.keys()): + sd = sd["state_dict"] + keys = list(sd.keys()) + for k in keys: + for ik in ignore_keys: + if k.startswith(ik): + print("Deleting key {} from state_dict.".format(k)) + del sd[k] + missing, unexpected = self.load_state_dict(sd, strict=False) if not only_model else self.model.load_state_dict( + sd, strict=False) + print(f"Restored from {path} with {len(missing)} missing and {len(unexpected)} unexpected keys") + if len(missing) > 0: + print(f"Missing Keys: {missing}") + if len(unexpected) > 0: + print(f"Unexpected Keys: {unexpected}") + + def load_diffusion(self): + model = instantiate_from_config(self.diffusion_config) + self.diffusion_model = model.eval() + self.diffusion_model.train = disabled_train + for param in self.diffusion_model.parameters(): + param.requires_grad = False + + def load_classifier(self, ckpt_path, pool): + model_config = deepcopy(self.diffusion_config.params.unet_config.params) + model_config.in_channels = self.diffusion_config.params.unet_config.params.out_channels + model_config.out_channels = self.num_classes + if self.label_key == 'class_label': + model_config.pool = pool + + self.model = __models__[self.label_key](**model_config) + if ckpt_path is not None: + print('#####################################################################') + print(f'load from ckpt "{ckpt_path}"') + print('#####################################################################') + self.init_from_ckpt(ckpt_path) + + @torch.no_grad() + def get_x_noisy(self, x, t, noise=None): + noise = default(noise, lambda: torch.randn_like(x)) + continuous_sqrt_alpha_cumprod = None + if self.diffusion_model.use_continuous_noise: + continuous_sqrt_alpha_cumprod = self.diffusion_model.sample_continuous_noise_level(x.shape[0], t + 1) + # todo: make sure t+1 is correct here + + return self.diffusion_model.q_sample(x_start=x, t=t, noise=noise, + continuous_sqrt_alpha_cumprod=continuous_sqrt_alpha_cumprod) + + def forward(self, x_noisy, t, *args, **kwargs): + return self.model(x_noisy, t) + + @torch.no_grad() + def get_input(self, batch, k): + x = batch[k] + if len(x.shape) == 3: + x = x[..., None] + x = rearrange(x, 'b h w c -> b c h w') + x = x.to(memory_format=torch.contiguous_format).float() + return x + + @torch.no_grad() + def get_conditioning(self, batch, k=None): + if k is None: + k = self.label_key + assert k is not None, 'Needs to provide label key' + + targets = batch[k].to(self.device) + + if self.label_key == 'segmentation': + targets = rearrange(targets, 'b h w c -> b c h w') + for down in range(self.numd): + h, w = targets.shape[-2:] + targets = F.interpolate(targets, size=(h // 2, w // 2), mode='nearest') + + # targets = rearrange(targets,'b c h w -> b h w c') + + return targets + + def compute_top_k(self, logits, labels, k, reduction="mean"): + _, top_ks = torch.topk(logits, k, dim=1) + if reduction == "mean": + return (top_ks == labels[:, None]).float().sum(dim=-1).mean().item() + elif reduction == "none": + return (top_ks == labels[:, None]).float().sum(dim=-1) + + def on_train_epoch_start(self): + # save some memory + self.diffusion_model.model.to('cpu') + + @torch.no_grad() + def write_logs(self, loss, logits, targets): + log_prefix = 'train' if self.training else 'val' + log = {} + log[f"{log_prefix}/loss"] = loss.mean() + log[f"{log_prefix}/acc@1"] = self.compute_top_k( + logits, targets, k=1, reduction="mean" + ) + log[f"{log_prefix}/acc@5"] = self.compute_top_k( + logits, targets, k=5, reduction="mean" + ) + + self.log_dict(log, prog_bar=False, logger=True, on_step=self.training, on_epoch=True) + self.log('loss', log[f"{log_prefix}/loss"], prog_bar=True, logger=False) + self.log('global_step', self.global_step, logger=False, on_epoch=False, prog_bar=True) + lr = self.optimizers().param_groups[0]['lr'] + self.log('lr_abs', lr, on_step=True, logger=True, on_epoch=False, prog_bar=True) + + def shared_step(self, batch, t=None): + x, *_ = self.diffusion_model.get_input(batch, k=self.diffusion_model.first_stage_key) + targets = self.get_conditioning(batch) + if targets.dim() == 4: + targets = targets.argmax(dim=1) + if t is None: + t = torch.randint(0, self.diffusion_model.num_timesteps, (x.shape[0],), device=self.device).long() + else: + t = torch.full(size=(x.shape[0],), fill_value=t, device=self.device).long() + x_noisy = self.get_x_noisy(x, t) + logits = self(x_noisy, t) + + loss = F.cross_entropy(logits, targets, reduction='none') + + self.write_logs(loss.detach(), logits.detach(), targets.detach()) + + loss = loss.mean() + return loss, logits, x_noisy, targets + + def training_step(self, batch, batch_idx): + loss, *_ = self.shared_step(batch) + return loss + + def reset_noise_accs(self): + self.noisy_acc = {t: {'acc@1': [], 'acc@5': []} for t in + range(0, self.diffusion_model.num_timesteps, self.diffusion_model.log_every_t)} + + def on_validation_start(self): + self.reset_noise_accs() + + @torch.no_grad() + def validation_step(self, batch, batch_idx): + loss, *_ = self.shared_step(batch) + + for t in self.noisy_acc: + _, logits, _, targets = self.shared_step(batch, t) + self.noisy_acc[t]['acc@1'].append(self.compute_top_k(logits, targets, k=1, reduction='mean')) + self.noisy_acc[t]['acc@5'].append(self.compute_top_k(logits, targets, k=5, reduction='mean')) + + return loss + + def configure_optimizers(self): + optimizer = AdamW(self.model.parameters(), lr=self.learning_rate, weight_decay=self.weight_decay) + + if self.use_scheduler: + scheduler = instantiate_from_config(self.scheduler_config) + + print("Setting up LambdaLR scheduler...") + scheduler = [ + { + 'scheduler': LambdaLR(optimizer, lr_lambda=scheduler.schedule), + 'interval': 'step', + 'frequency': 1 + }] + return [optimizer], scheduler + + return optimizer + + @torch.no_grad() + def log_images(self, batch, N=8, *args, **kwargs): + log = dict() + x = self.get_input(batch, self.diffusion_model.first_stage_key) + log['inputs'] = x + + y = self.get_conditioning(batch) + + if self.label_key == 'class_label': + y = log_txt_as_img((x.shape[2], x.shape[3]), batch["human_label"]) + log['labels'] = y + + if ismap(y): + log['labels'] = self.diffusion_model.to_rgb(y) + + for step in range(self.log_steps): + current_time = step * self.log_time_interval + + _, logits, x_noisy, _ = self.shared_step(batch, t=current_time) + + log[f'inputs@t{current_time}'] = x_noisy + + pred = F.one_hot(logits.argmax(dim=1), num_classes=self.num_classes) + pred = rearrange(pred, 'b h w c -> b c h w') + + log[f'pred@t{current_time}'] = self.diffusion_model.to_rgb(pred) + + for key in log: + log[key] = log[key][:N] + + return log diff --git a/ldm/models/diffusion/ddim.py b/ldm/models/diffusion/ddim.py new file mode 100755 index 0000000..0683d16 --- /dev/null +++ b/ldm/models/diffusion/ddim.py @@ -0,0 +1,328 @@ +"""SAMPLING ONLY.""" + +import torch +import numpy as np +from tqdm import tqdm +from functools import partial +from einops import rearrange + +from ldm.modules.diffusionmodules.util import make_ddim_sampling_parameters, make_ddim_timesteps, noise_like, extract_into_tensor +from ldm.models.diffusion.sampling_util import renorm_thresholding, norm_thresholding, spatial_norm_thresholding + + +class DDIMSampler(object): + def __init__(self, model, schedule="linear", **kwargs): + super().__init__() + self.model = model + self.ddpm_num_timesteps = model.num_timesteps + self.schedule = schedule + + def to(self, device): + """Same as to in torch module + Don't really underestand why this isn't a module in the first place""" + for k, v in self.__dict__.items(): + if isinstance(v, torch.Tensor): + new_v = getattr(self, k).to(device) + setattr(self, k, new_v) + + + def register_buffer(self, name, attr): + if type(attr) == torch.Tensor: + if attr.device != torch.device("cuda"): + attr = attr.to(torch.device("cuda")) + setattr(self, name, attr) + + def make_schedule(self, ddim_num_steps, ddim_discretize="uniform", ddim_eta=0., verbose=True): + self.ddim_timesteps = make_ddim_timesteps(ddim_discr_method=ddim_discretize, num_ddim_timesteps=ddim_num_steps, + num_ddpm_timesteps=self.ddpm_num_timesteps,verbose=verbose) + alphas_cumprod = self.model.alphas_cumprod + assert alphas_cumprod.shape[0] == self.ddpm_num_timesteps, 'alphas have to be defined for each timestep' + to_torch = lambda x: x.clone().detach().to(torch.float32).to(self.model.device) + + self.register_buffer('betas', to_torch(self.model.betas)) + self.register_buffer('alphas_cumprod', to_torch(alphas_cumprod)) + self.register_buffer('alphas_cumprod_prev', to_torch(self.model.alphas_cumprod_prev)) + + # calculations for diffusion q(x_t | x_{t-1}) and others + self.register_buffer('sqrt_alphas_cumprod', to_torch(np.sqrt(alphas_cumprod.cpu()))) + self.register_buffer('sqrt_one_minus_alphas_cumprod', to_torch(np.sqrt(1. - alphas_cumprod.cpu()))) + self.register_buffer('log_one_minus_alphas_cumprod', to_torch(np.log(1. - alphas_cumprod.cpu()))) + self.register_buffer('sqrt_recip_alphas_cumprod', to_torch(np.sqrt(1. / alphas_cumprod.cpu()))) + self.register_buffer('sqrt_recipm1_alphas_cumprod', to_torch(np.sqrt(1. / alphas_cumprod.cpu() - 1))) + + # ddim sampling parameters + ddim_sigmas, ddim_alphas, ddim_alphas_prev = make_ddim_sampling_parameters(alphacums=alphas_cumprod.cpu(), + ddim_timesteps=self.ddim_timesteps, + eta=ddim_eta,verbose=verbose) + self.register_buffer('ddim_sigmas', ddim_sigmas) + self.register_buffer('ddim_alphas', ddim_alphas) + self.register_buffer('ddim_alphas_prev', ddim_alphas_prev) + self.register_buffer('ddim_sqrt_one_minus_alphas', np.sqrt(1. - ddim_alphas)) + sigmas_for_original_sampling_steps = ddim_eta * torch.sqrt( + (1 - self.alphas_cumprod_prev) / (1 - self.alphas_cumprod) * ( + 1 - self.alphas_cumprod / self.alphas_cumprod_prev)) + self.register_buffer('ddim_sigmas_for_original_num_steps', sigmas_for_original_sampling_steps) + + @torch.no_grad() + def sample(self, + S, + batch_size, + shape, + conditioning=None, + callback=None, + normals_sequence=None, + img_callback=None, + quantize_x0=False, + eta=0., + mask=None, + x0=None, + temperature=1., + noise_dropout=0., + score_corrector=None, + corrector_kwargs=None, + verbose=True, + x_T=None, + log_every_t=100, + unconditional_guidance_scale=1., + unconditional_conditioning=None, # this has to come in the same format as the conditioning, # e.g. as encoded tokens, ... + dynamic_threshold=None, + **kwargs + ): + if conditioning is not None: + if isinstance(conditioning, dict): + ctmp = conditioning[list(conditioning.keys())[0]] + while isinstance(ctmp, list): ctmp = ctmp[0] + cbs = ctmp.shape[0] + if cbs != batch_size: + print(f"Warning: Got {cbs} conditionings but batch-size is {batch_size}") + + else: + if conditioning.shape[0] != batch_size: + print(f"Warning: Got {conditioning.shape[0]} conditionings but batch-size is {batch_size}") + + self.make_schedule(ddim_num_steps=S, ddim_eta=eta, verbose=verbose) + # sampling + C, H, W = shape + size = (batch_size, C, H, W) + # print(f'Data shape for DDIM sampling is {size}, eta {eta}') + + samples, intermediates = self.ddim_sampling(conditioning, size, + callback=callback, + img_callback=img_callback, + quantize_denoised=quantize_x0, + mask=mask, x0=x0, + ddim_use_original_steps=False, + noise_dropout=noise_dropout, + temperature=temperature, + score_corrector=score_corrector, + corrector_kwargs=corrector_kwargs, + x_T=x_T, + log_every_t=log_every_t, + unconditional_guidance_scale=unconditional_guidance_scale, + unconditional_conditioning=unconditional_conditioning, + dynamic_threshold=dynamic_threshold, + ) + return samples, intermediates + + @torch.no_grad() + def ddim_sampling(self, cond, shape, + x_T=None, ddim_use_original_steps=False, + callback=None, timesteps=None, quantize_denoised=False, + mask=None, x0=None, img_callback=None, log_every_t=100, + temperature=1., noise_dropout=0., score_corrector=None, corrector_kwargs=None, + unconditional_guidance_scale=1., unconditional_conditioning=None, dynamic_threshold=None, + t_start=-1): + device = self.model.betas.device + b = shape[0] + if x_T is None: + img = torch.randn(shape, device=device) + else: + img = x_T + + if timesteps is None: + timesteps = self.ddpm_num_timesteps if ddim_use_original_steps else self.ddim_timesteps + elif timesteps is not None and not ddim_use_original_steps: + subset_end = int(min(timesteps / self.ddim_timesteps.shape[0], 1) * self.ddim_timesteps.shape[0]) - 1 + timesteps = self.ddim_timesteps[:subset_end] + + timesteps = timesteps[:t_start] + + intermediates = {'x_inter': [img], 'pred_x0': [img]} + time_range = reversed(range(0,timesteps)) if ddim_use_original_steps else np.flip(timesteps) + total_steps = timesteps if ddim_use_original_steps else timesteps.shape[0] + # print(f"Running DDIM Sampling with {total_steps} timesteps") + + iterator = tqdm(time_range, desc='DDIM Sampler', total=total_steps) + + for i, step in enumerate(iterator): + index = total_steps - i - 1 + ts = torch.full((b,), step, device=device, dtype=torch.long) + + if mask is not None: + assert x0 is not None + img_orig = self.model.q_sample(x0, ts) # TODO: deterministic forward pass? + img = img_orig * mask + (1. - mask) * img + + outs = self.p_sample_ddim(img, cond, ts, index=index, use_original_steps=ddim_use_original_steps, + quantize_denoised=quantize_denoised, temperature=temperature, + noise_dropout=noise_dropout, score_corrector=score_corrector, + corrector_kwargs=corrector_kwargs, + unconditional_guidance_scale=unconditional_guidance_scale, + unconditional_conditioning=unconditional_conditioning, + dynamic_threshold=dynamic_threshold) + img, pred_x0 = outs + if callback: + img = callback(i, img, pred_x0) + if img_callback: + img_callback(pred_x0, i) + + if index % log_every_t == 0 or index == total_steps - 1: + intermediates['x_inter'].append(img) + intermediates['pred_x0'].append(pred_x0) + + return img, intermediates + + @torch.no_grad() + def p_sample_ddim(self, x, c, t, index, repeat_noise=False, use_original_steps=False, quantize_denoised=False, + temperature=1., noise_dropout=0., score_corrector=None, corrector_kwargs=None, + unconditional_guidance_scale=1., unconditional_conditioning=None, + dynamic_threshold=None): + b, *_, device = *x.shape, x.device + + if unconditional_conditioning is None or unconditional_guidance_scale == 1.: + e_t = self.model.apply_model(x, t, c) + else: + x_in = torch.cat([x] * 2) + t_in = torch.cat([t] * 2) + if isinstance(c, dict): + assert isinstance(unconditional_conditioning, dict) + c_in = dict() + for k in c: + if isinstance(c[k], list): + c_in[k] = [torch.cat([ + unconditional_conditioning[k][i], + c[k][i]]) for i in range(len(c[k]))] + else: + c_in[k] = torch.cat([ + unconditional_conditioning[k], + c[k]]) + else: + c_in = torch.cat([unconditional_conditioning, c]) + e_t_uncond, e_t = self.model.apply_model(x_in, t_in, c_in).chunk(2) + e_t = e_t_uncond + unconditional_guidance_scale * (e_t - e_t_uncond) + + if score_corrector is not None: + assert self.model.parameterization == "eps" + e_t = score_corrector.modify_score(self.model, e_t, x, t, c, **corrector_kwargs) + + alphas = self.model.alphas_cumprod if use_original_steps else self.ddim_alphas + alphas_prev = self.model.alphas_cumprod_prev if use_original_steps else self.ddim_alphas_prev + sqrt_one_minus_alphas = self.model.sqrt_one_minus_alphas_cumprod if use_original_steps else self.ddim_sqrt_one_minus_alphas + sigmas = self.model.ddim_sigmas_for_original_num_steps if use_original_steps else self.ddim_sigmas + # select parameters corresponding to the currently considered timestep + a_t = torch.full((b, 1, 1, 1), alphas[index], device=device) + a_prev = torch.full((b, 1, 1, 1), alphas_prev[index], device=device) + sigma_t = torch.full((b, 1, 1, 1), sigmas[index], device=device) + sqrt_one_minus_at = torch.full((b, 1, 1, 1), sqrt_one_minus_alphas[index],device=device) + + # current prediction for x_0 + pred_x0 = (x - sqrt_one_minus_at * e_t) / a_t.sqrt() + + print(t, sqrt_one_minus_at, a_t) + + if quantize_denoised: + pred_x0, _, *_ = self.model.first_stage_model.quantize(pred_x0) + + if dynamic_threshold is not None: + pred_x0 = norm_thresholding(pred_x0, dynamic_threshold) + + # direction pointing to x_t + dir_xt = (1. - a_prev - sigma_t**2).sqrt() * e_t + noise = sigma_t * noise_like(x.shape, device, repeat_noise) * temperature + if noise_dropout > 0.: + noise = torch.nn.functional.dropout(noise, p=noise_dropout) + x_prev = a_prev.sqrt() * pred_x0 + dir_xt + noise + return x_prev, pred_x0 + + @torch.no_grad() + def encode(self, x0, c, t_enc, use_original_steps=False, return_intermediates=None, + unconditional_guidance_scale=1.0, unconditional_conditioning=None): + num_reference_steps = self.ddpm_num_timesteps if use_original_steps else self.ddim_timesteps.shape[0] + + assert t_enc <= num_reference_steps + num_steps = t_enc + + if use_original_steps: + alphas_next = self.alphas_cumprod[:num_steps] + alphas = self.alphas_cumprod_prev[:num_steps] + else: + alphas_next = self.ddim_alphas[:num_steps] + alphas = torch.tensor(self.ddim_alphas_prev[:num_steps]) + + x_next = x0 + intermediates = [] + inter_steps = [] + for i in tqdm(range(num_steps), desc='Encoding Image'): + t = torch.full((x0.shape[0],), i, device=self.model.device, dtype=torch.long) + if unconditional_guidance_scale == 1.: + noise_pred = self.model.apply_model(x_next, t, c) + else: + assert unconditional_conditioning is not None + e_t_uncond, noise_pred = torch.chunk( + self.model.apply_model(torch.cat((x_next, x_next)), torch.cat((t, t)), + torch.cat((unconditional_conditioning, c))), 2) + noise_pred = e_t_uncond + unconditional_guidance_scale * (noise_pred - e_t_uncond) + + xt_weighted = (alphas_next[i] / alphas[i]).sqrt() * x_next + weighted_noise_pred = alphas_next[i].sqrt() * ( + (1 / alphas_next[i] - 1).sqrt() - (1 / alphas[i] - 1).sqrt()) * noise_pred + x_next = xt_weighted + weighted_noise_pred + if return_intermediates and i % ( + num_steps // return_intermediates) == 0 and i < num_steps - 1: + intermediates.append(x_next) + inter_steps.append(i) + elif return_intermediates and i >= num_steps - 2: + intermediates.append(x_next) + inter_steps.append(i) + + out = {'x_encoded': x_next, 'intermediate_steps': inter_steps} + if return_intermediates: + out.update({'intermediates': intermediates}) + return x_next, out + + @torch.no_grad() + def stochastic_encode(self, x0, t, use_original_steps=False, noise=None): + # fast, but does not allow for exact reconstruction + # t serves as an index to gather the correct alphas + if use_original_steps: + sqrt_alphas_cumprod = self.sqrt_alphas_cumprod + sqrt_one_minus_alphas_cumprod = self.sqrt_one_minus_alphas_cumprod + else: + sqrt_alphas_cumprod = torch.sqrt(self.ddim_alphas) + sqrt_one_minus_alphas_cumprod = self.ddim_sqrt_one_minus_alphas + + if noise is None: + noise = torch.randn_like(x0) + return (extract_into_tensor(sqrt_alphas_cumprod, t, x0.shape) * x0 + + extract_into_tensor(sqrt_one_minus_alphas_cumprod, t, x0.shape) * noise) + + @torch.no_grad() + def decode(self, x_latent, cond, t_start, unconditional_guidance_scale=1.0, unconditional_conditioning=None, + use_original_steps=False): + + timesteps = np.arange(self.ddpm_num_timesteps) if use_original_steps else self.ddim_timesteps + timesteps = timesteps[:t_start] + + time_range = np.flip(timesteps) + total_steps = timesteps.shape[0] + # print(f"Running DDIM Sampling with {total_steps} timesteps") + + iterator = tqdm(time_range, desc='Decoding image', total=total_steps) + x_dec = x_latent + for i, step in enumerate(iterator): + index = total_steps - i - 1 + ts = torch.full((x_latent.shape[0],), step, device=x_latent.device, dtype=torch.long) + x_dec, _ = self.p_sample_ddim(x_dec, cond, ts, index=index, use_original_steps=use_original_steps, + unconditional_guidance_scale=unconditional_guidance_scale, + unconditional_conditioning=unconditional_conditioning) + return x_dec \ No newline at end of file diff --git a/ldm/models/diffusion/ddpm.py b/ldm/models/diffusion/ddpm.py new file mode 100755 index 0000000..3fcb7ad --- /dev/null +++ b/ldm/models/diffusion/ddpm.py @@ -0,0 +1,1994 @@ +""" +wild mixture of +https://github.com/lucidrains/denoising-diffusion-pytorch/blob/7706bdfc6f527f58d33f84b7b522e61e6e3164b3/denoising_diffusion_pytorch/denoising_diffusion_pytorch.py +https://github.com/openai/improved-diffusion/blob/e94489283bb876ac1477d5dd7709bbbd2d9902ce/improved_diffusion/gaussian_diffusion.py +https://github.com/CompVis/taming-transformers +-- merci +""" + +import torch +import torch.nn as nn +import numpy as np +import pytorch_lightning as pl +from torch.optim.lr_scheduler import LambdaLR +from einops import rearrange, repeat +from contextlib import contextmanager, nullcontext +from functools import partial +import itertools +from tqdm import tqdm +from torchvision.utils import make_grid +from pytorch_lightning.utilities.rank_zero import rank_zero_only +from omegaconf import ListConfig + +from ldm.util import log_txt_as_img, exists, default, ismap, isimage, mean_flat, count_params, instantiate_from_config +from ldm.modules.ema import LitEma +from ldm.modules.distributions.distributions import normal_kl, DiagonalGaussianDistribution +from ldm.models.autoencoder import VQModelInterface, IdentityFirstStage, AutoencoderKL +from ldm.modules.diffusionmodules.util import make_beta_schedule, extract_into_tensor, noise_like +from ldm.models.diffusion.ddim import DDIMSampler +from ldm.modules.attention import CrossAttention + + +__conditioning_keys__ = {'concat': 'c_concat', + 'crossattn': 'c_crossattn', + 'adm': 'y'} + + +def disabled_train(self, mode=True): + """Overwrite model.train with this function to make sure train/eval mode + does not change anymore.""" + return self + + +def uniform_on_device(r1, r2, shape, device): + return (r1 - r2) * torch.rand(*shape, device=device) + r2 + + +class DDPM(pl.LightningModule): + # classic DDPM with Gaussian diffusion, in image space + def __init__(self, + unet_config, + timesteps=1000, + beta_schedule="linear", + loss_type="l2", + ckpt_path=None, + ignore_keys=[], + load_only_unet=False, + monitor="val/loss", + use_ema=True, + first_stage_key="image", + image_size=256, + channels=3, + log_every_t=100, + clip_denoised=True, + linear_start=1e-4, + linear_end=2e-2, + cosine_s=8e-3, + given_betas=None, + original_elbo_weight=0., + v_posterior=0., # weight for choosing posterior variance as sigma = (1-v) * beta_tilde + v * beta + l_simple_weight=1., + conditioning_key=None, + parameterization="eps", # all assuming fixed variance schedules + scheduler_config=None, + use_positional_encodings=False, + learn_logvar=False, + logvar_init=0., + make_it_fit=False, + ucg_training=None, + ): + super().__init__() + assert parameterization in ["eps", "x0"], 'currently only supporting "eps" and "x0"' + self.parameterization = parameterization + print(f"{self.__class__.__name__}: Running in {self.parameterization}-prediction mode") + self.cond_stage_model = None + self.clip_denoised = clip_denoised + self.log_every_t = log_every_t + self.first_stage_key = first_stage_key + self.image_size = image_size # try conv? + self.channels = channels + self.use_positional_encodings = use_positional_encodings + self.model = DiffusionWrapper(unet_config, conditioning_key) + count_params(self.model, verbose=True) + self.use_ema = use_ema + if self.use_ema: + self.model_ema = LitEma(self.model) + print(f"Keeping EMAs of {len(list(self.model_ema.buffers()))}.") + + self.use_scheduler = scheduler_config is not None + if self.use_scheduler: + self.scheduler_config = scheduler_config + + self.v_posterior = v_posterior + self.original_elbo_weight = original_elbo_weight + self.l_simple_weight = l_simple_weight + + if monitor is not None: + self.monitor = monitor + self.make_it_fit = make_it_fit + if ckpt_path is not None: + self.init_from_ckpt(ckpt_path, ignore_keys=ignore_keys, only_model=load_only_unet) + + self.register_schedule(given_betas=given_betas, beta_schedule=beta_schedule, timesteps=timesteps, + linear_start=linear_start, linear_end=linear_end, cosine_s=cosine_s) + + self.loss_type = loss_type + + self.learn_logvar = learn_logvar + self.logvar = torch.full(fill_value=logvar_init, size=(self.num_timesteps,)) + if self.learn_logvar: + self.logvar = nn.Parameter(self.logvar, requires_grad=True) + + self.ucg_training = ucg_training or dict() + if self.ucg_training: + self.ucg_prng = np.random.RandomState() + + def register_schedule(self, given_betas=None, beta_schedule="linear", timesteps=1000, + linear_start=1e-4, linear_end=2e-2, cosine_s=8e-3): + if exists(given_betas): + betas = given_betas + else: + betas = make_beta_schedule(beta_schedule, timesteps, linear_start=linear_start, linear_end=linear_end, + cosine_s=cosine_s) + alphas = 1. - betas + alphas_cumprod = np.cumprod(alphas, axis=0) + alphas_cumprod_prev = np.append(1., alphas_cumprod[:-1]) + + timesteps, = betas.shape + self.num_timesteps = int(timesteps) + self.linear_start = linear_start + self.linear_end = linear_end + assert alphas_cumprod.shape[0] == self.num_timesteps, 'alphas have to be defined for each timestep' + + to_torch = partial(torch.tensor, dtype=torch.float32) + + self.register_buffer('betas', to_torch(betas)) + self.register_buffer('alphas_cumprod', to_torch(alphas_cumprod)) + self.register_buffer('alphas_cumprod_prev', to_torch(alphas_cumprod_prev)) + + # calculations for diffusion q(x_t | x_{t-1}) and others + self.register_buffer('sqrt_alphas_cumprod', to_torch(np.sqrt(alphas_cumprod))) + self.register_buffer('sqrt_one_minus_alphas_cumprod', to_torch(np.sqrt(1. - alphas_cumprod))) + self.register_buffer('log_one_minus_alphas_cumprod', to_torch(np.log(1. - alphas_cumprod))) + self.register_buffer('sqrt_recip_alphas_cumprod', to_torch(np.sqrt(1. / alphas_cumprod))) + self.register_buffer('sqrt_recipm1_alphas_cumprod', to_torch(np.sqrt(1. / alphas_cumprod - 1))) + + # calculations for posterior q(x_{t-1} | x_t, x_0) + posterior_variance = (1 - self.v_posterior) * betas * (1. - alphas_cumprod_prev) / ( + 1. - alphas_cumprod) + self.v_posterior * betas + # above: equal to 1. / (1. / (1. - alpha_cumprod_tm1) + alpha_t / beta_t) + self.register_buffer('posterior_variance', to_torch(posterior_variance)) + # below: log calculation clipped because the posterior variance is 0 at the beginning of the diffusion chain + self.register_buffer('posterior_log_variance_clipped', to_torch(np.log(np.maximum(posterior_variance, 1e-20)))) + self.register_buffer('posterior_mean_coef1', to_torch( + betas * np.sqrt(alphas_cumprod_prev) / (1. - alphas_cumprod))) + self.register_buffer('posterior_mean_coef2', to_torch( + (1. - alphas_cumprod_prev) * np.sqrt(alphas) / (1. - alphas_cumprod))) + + if self.parameterization == "eps": + lvlb_weights = self.betas ** 2 / ( + 2 * self.posterior_variance * to_torch(alphas) * (1 - self.alphas_cumprod)) + elif self.parameterization == "x0": + lvlb_weights = 0.5 * np.sqrt(torch.Tensor(alphas_cumprod)) / (2. * 1 - torch.Tensor(alphas_cumprod)) + else: + raise NotImplementedError("mu not supported") + # TODO how to choose this term + lvlb_weights[0] = lvlb_weights[1] + self.register_buffer('lvlb_weights', lvlb_weights, persistent=False) + assert not torch.isnan(self.lvlb_weights).all() + + @contextmanager + def ema_scope(self, context=None): + if self.use_ema: + self.model_ema.store(self.model.parameters()) + self.model_ema.copy_to(self.model) + if context is not None: + print(f"{context}: Switched to EMA weights") + try: + yield None + finally: + if self.use_ema: + self.model_ema.restore(self.model.parameters()) + if context is not None: + print(f"{context}: Restored training weights") + + @torch.no_grad() + def init_from_ckpt(self, path, ignore_keys=list(), only_model=False): + sd = torch.load(path, map_location="cpu") + if "state_dict" in list(sd.keys()): + sd = sd["state_dict"] + keys = list(sd.keys()) + + if self.make_it_fit: + n_params = len([name for name, _ in + itertools.chain(self.named_parameters(), + self.named_buffers())]) + for name, param in tqdm( + itertools.chain(self.named_parameters(), + self.named_buffers()), + desc="Fitting old weights to new weights", + total=n_params + ): + if not name in sd: + continue + old_shape = sd[name].shape + new_shape = param.shape + assert len(old_shape)==len(new_shape) + if len(new_shape) > 2: + # we only modify first two axes + assert new_shape[2:] == old_shape[2:] + # assumes first axis corresponds to output dim + if not new_shape == old_shape: + new_param = param.clone() + old_param = sd[name] + if len(new_shape) == 1: + for i in range(new_param.shape[0]): + new_param[i] = old_param[i % old_shape[0]] + elif len(new_shape) >= 2: + for i in range(new_param.shape[0]): + for j in range(new_param.shape[1]): + new_param[i, j] = old_param[i % old_shape[0], j % old_shape[1]] + + n_used_old = torch.ones(old_shape[1]) + for j in range(new_param.shape[1]): + n_used_old[j % old_shape[1]] += 1 + n_used_new = torch.zeros(new_shape[1]) + for j in range(new_param.shape[1]): + n_used_new[j] = n_used_old[j % old_shape[1]] + + n_used_new = n_used_new[None, :] + while len(n_used_new.shape) < len(new_shape): + n_used_new = n_used_new.unsqueeze(-1) + new_param /= n_used_new + + sd[name] = new_param + + missing, unexpected = self.load_state_dict(sd, strict=False) if not only_model else self.model.load_state_dict( + sd, strict=False) + print(f"Restored from {path} with {len(missing)} missing and {len(unexpected)} unexpected keys") + if len(missing) > 0: + print(f"Missing Keys: {missing}") + if len(unexpected) > 0: + print(f"Unexpected Keys: {unexpected}") + + def q_mean_variance(self, x_start, t): + """ + Get the distribution q(x_t | x_0). + :param x_start: the [N x C x ...] tensor of noiseless inputs. + :param t: the number of diffusion steps (minus 1). Here, 0 means one step. + :return: A tuple (mean, variance, log_variance), all of x_start's shape. + """ + mean = (extract_into_tensor(self.sqrt_alphas_cumprod, t, x_start.shape) * x_start) + variance = extract_into_tensor(1.0 - self.alphas_cumprod, t, x_start.shape) + log_variance = extract_into_tensor(self.log_one_minus_alphas_cumprod, t, x_start.shape) + return mean, variance, log_variance + + def predict_start_from_noise(self, x_t, t, noise): + return ( + extract_into_tensor(self.sqrt_recip_alphas_cumprod, t, x_t.shape) * x_t - + extract_into_tensor(self.sqrt_recipm1_alphas_cumprod, t, x_t.shape) * noise + ) + + def q_posterior(self, x_start, x_t, t): + posterior_mean = ( + extract_into_tensor(self.posterior_mean_coef1, t, x_t.shape) * x_start + + extract_into_tensor(self.posterior_mean_coef2, t, x_t.shape) * x_t + ) + posterior_variance = extract_into_tensor(self.posterior_variance, t, x_t.shape) + posterior_log_variance_clipped = extract_into_tensor(self.posterior_log_variance_clipped, t, x_t.shape) + return posterior_mean, posterior_variance, posterior_log_variance_clipped + + def p_mean_variance(self, x, t, clip_denoised: bool): + model_out = self.model(x, t) + if self.parameterization == "eps": + x_recon = self.predict_start_from_noise(x, t=t, noise=model_out) + elif self.parameterization == "x0": + x_recon = model_out + if clip_denoised: + x_recon.clamp_(-1., 1.) + + model_mean, posterior_variance, posterior_log_variance = self.q_posterior(x_start=x_recon, x_t=x, t=t) + return model_mean, posterior_variance, posterior_log_variance + + @torch.no_grad() + def p_sample(self, x, t, clip_denoised=True, repeat_noise=False): + b, *_, device = *x.shape, x.device + model_mean, _, model_log_variance = self.p_mean_variance(x=x, t=t, clip_denoised=clip_denoised) + noise = noise_like(x.shape, device, repeat_noise) + # no noise when t == 0 + nonzero_mask = (1 - (t == 0).float()).reshape(b, *((1,) * (len(x.shape) - 1))) + return model_mean + nonzero_mask * (0.5 * model_log_variance).exp() * noise + + @torch.no_grad() + def p_sample_loop(self, shape, return_intermediates=False): + device = self.betas.device + b = shape[0] + img = torch.randn(shape, device=device) + intermediates = [img] + for i in tqdm(reversed(range(0, self.num_timesteps)), desc='Sampling t', total=self.num_timesteps): + img = self.p_sample(img, torch.full((b,), i, device=device, dtype=torch.long), + clip_denoised=self.clip_denoised) + if i % self.log_every_t == 0 or i == self.num_timesteps - 1: + intermediates.append(img) + if return_intermediates: + return img, intermediates + return img + + @torch.no_grad() + def sample(self, batch_size=16, return_intermediates=False): + image_size = self.image_size + channels = self.channels + return self.p_sample_loop((batch_size, channels, image_size, image_size), + return_intermediates=return_intermediates) + + def q_sample(self, x_start, t, noise=None): + noise = default(noise, lambda: torch.randn_like(x_start)) + return (extract_into_tensor(self.sqrt_alphas_cumprod, t, x_start.shape) * x_start + + extract_into_tensor(self.sqrt_one_minus_alphas_cumprod, t, x_start.shape) * noise) + + def get_loss(self, pred, target, mean=True): + if self.loss_type == 'l1': + loss = (target - pred).abs() + if mean: + loss = loss.mean() + elif self.loss_type == 'l2': + if mean: + loss = torch.nn.functional.mse_loss(target, pred) + else: + loss = torch.nn.functional.mse_loss(target, pred, reduction='none') + else: + raise NotImplementedError("unknown loss type '{loss_type}'") + + return loss + + def p_losses(self, x_start, t, noise=None): + noise = default(noise, lambda: torch.randn_like(x_start)) + x_noisy = self.q_sample(x_start=x_start, t=t, noise=noise) + model_out = self.model(x_noisy, t) + + loss_dict = {} + if self.parameterization == "eps": + target = noise + elif self.parameterization == "x0": + target = x_start + else: + raise NotImplementedError(f"Paramterization {self.parameterization} not yet supported") + + loss = self.get_loss(model_out, target, mean=False).mean(dim=[1, 2, 3]) + + log_prefix = 'train' if self.training else 'val' + + loss_dict.update({f'{log_prefix}/loss_simple': loss.mean()}) + loss_simple = loss.mean() * self.l_simple_weight + + loss_vlb = (self.lvlb_weights[t] * loss).mean() + loss_dict.update({f'{log_prefix}/loss_vlb': loss_vlb}) + + loss = loss_simple + self.original_elbo_weight * loss_vlb + + loss_dict.update({f'{log_prefix}/loss': loss}) + + return loss, loss_dict + + def forward(self, x, *args, **kwargs): + # b, c, h, w, device, img_size, = *x.shape, x.device, self.image_size + # assert h == img_size and w == img_size, f'height and width of image must be {img_size}' + t = torch.randint(0, self.num_timesteps, (x.shape[0],), device=self.device).long() + return self.p_losses(x, t, *args, **kwargs) + + def get_input(self, batch, k): + x = batch[k] + if len(x.shape) == 3: + x = x[..., None] + x = rearrange(x, 'b h w c -> b c h w') + x = x.to(memory_format=torch.contiguous_format).float() + return x + + def shared_step(self, batch): + x = self.get_input(batch, self.first_stage_key) + loss, loss_dict = self(x) + return loss, loss_dict + + def training_step(self, batch, batch_idx): + for k in self.ucg_training: + p = self.ucg_training[k]["p"] + val = self.ucg_training[k]["val"] + if val is None: + val = "" + for i in range(len(batch[k])): + if self.ucg_prng.choice(2, p=[1-p, p]): + batch[k][i] = val + + loss, loss_dict = self.shared_step(batch) + + self.log_dict(loss_dict, prog_bar=True, + logger=True, on_step=True, on_epoch=True) + + self.log("global_step", self.global_step, + prog_bar=True, logger=True, on_step=True, on_epoch=False) + + if self.use_scheduler: + lr = self.optimizers().param_groups[0]['lr'] + self.log('lr_abs', lr, prog_bar=True, logger=True, on_step=True, on_epoch=False) + + return loss + + @torch.no_grad() + def validation_step(self, batch, batch_idx): + _, loss_dict_no_ema = self.shared_step(batch) + with self.ema_scope(): + _, loss_dict_ema = self.shared_step(batch) + loss_dict_ema = {key + '_ema': loss_dict_ema[key] for key in loss_dict_ema} + self.log_dict(loss_dict_no_ema, prog_bar=False, logger=True, on_step=False, on_epoch=True) + self.log_dict(loss_dict_ema, prog_bar=False, logger=True, on_step=False, on_epoch=True) + + def on_train_batch_end(self, *args, **kwargs): + if self.use_ema: + self.model_ema(self.model) + + def _get_rows_from_list(self, samples): + n_imgs_per_row = len(samples) + denoise_grid = rearrange(samples, 'n b c h w -> b n c h w') + denoise_grid = rearrange(denoise_grid, 'b n c h w -> (b n) c h w') + denoise_grid = make_grid(denoise_grid, nrow=n_imgs_per_row) + return denoise_grid + + @torch.no_grad() + def log_images(self, batch, N=8, n_row=2, sample=True, return_keys=None, **kwargs): + log = dict() + x = self.get_input(batch, self.first_stage_key) + N = min(x.shape[0], N) + n_row = min(x.shape[0], n_row) + x = x.to(self.device)[:N] + log["inputs"] = x + + # get diffusion row + diffusion_row = list() + x_start = x[:n_row] + + for t in range(self.num_timesteps): + if t % self.log_every_t == 0 or t == self.num_timesteps - 1: + t = repeat(torch.tensor([t]), '1 -> b', b=n_row) + t = t.to(self.device).long() + noise = torch.randn_like(x_start) + x_noisy = self.q_sample(x_start=x_start, t=t, noise=noise) + diffusion_row.append(x_noisy) + + log["diffusion_row"] = self._get_rows_from_list(diffusion_row) + + if sample: + # get denoise row + with self.ema_scope("Plotting"): + samples, denoise_row = self.sample(batch_size=N, return_intermediates=True) + + log["samples"] = samples + log["denoise_row"] = self._get_rows_from_list(denoise_row) + + if return_keys: + if np.intersect1d(list(log.keys()), return_keys).shape[0] == 0: + return log + else: + return {key: log[key] for key in return_keys} + return log + + def configure_optimizers(self): + lr = self.learning_rate + params = list(self.model.parameters()) + if self.learn_logvar: + params = params + [self.logvar] + opt = torch.optim.AdamW(params, lr=lr) + return opt + + +class LatentDiffusion(DDPM): + """main class""" + def __init__(self, + first_stage_config, + cond_stage_config, + num_timesteps_cond=None, + cond_stage_key="image", + cond_stage_trainable=False, + concat_mode=True, + cond_stage_forward=None, + conditioning_key=None, + scale_factor=1.0, + scale_by_std=False, + unet_trainable=True, + *args, **kwargs): + self.num_timesteps_cond = default(num_timesteps_cond, 1) + self.scale_by_std = scale_by_std + assert self.num_timesteps_cond <= kwargs['timesteps'] + # for backwards compatibility after implementation of DiffusionWrapper + if conditioning_key is None: + conditioning_key = 'concat' if concat_mode else 'crossattn' + if cond_stage_config == '__is_unconditional__': + conditioning_key = None + ckpt_path = kwargs.pop("ckpt_path", None) + ignore_keys = kwargs.pop("ignore_keys", []) + super().__init__(conditioning_key=conditioning_key, *args, **kwargs) + self.concat_mode = concat_mode + self.cond_stage_trainable = cond_stage_trainable + self.unet_trainable = unet_trainable + self.cond_stage_key = cond_stage_key + try: + self.num_downs = len(first_stage_config.params.ddconfig.ch_mult) - 1 + except: + self.num_downs = 0 + if not scale_by_std: + self.scale_factor = scale_factor + else: + self.register_buffer('scale_factor', torch.tensor(scale_factor)) + self.instantiate_first_stage(first_stage_config) + self.instantiate_cond_stage(cond_stage_config) + self.cond_stage_forward = cond_stage_forward + + # construct linear projection layer for concatenating image CLIP embedding and RT + self.cc_projection = nn.Linear(772, 768) + nn.init.eye_(list(self.cc_projection.parameters())[0][:768, :768]) + nn.init.zeros_(list(self.cc_projection.parameters())[1]) + self.cc_projection.requires_grad_(True) + + self.clip_denoised = False + self.bbox_tokenizer = None + + self.restarted_from_ckpt = False + if ckpt_path is not None: + self.init_from_ckpt(ckpt_path, ignore_keys) + self.restarted_from_ckpt = True + + def make_cond_schedule(self, ): + self.cond_ids = torch.full(size=(self.num_timesteps,), fill_value=self.num_timesteps - 1, dtype=torch.long) + ids = torch.round(torch.linspace(0, self.num_timesteps - 1, self.num_timesteps_cond)).long() + self.cond_ids[:self.num_timesteps_cond] = ids + + @rank_zero_only + @torch.no_grad() + def on_train_batch_start(self, batch, batch_idx, dataloader_idx): + # only for very first batch + if self.scale_by_std and self.current_epoch == 0 and self.global_step == 0 and batch_idx == 0 and not self.restarted_from_ckpt: + assert self.scale_factor == 1., 'rather not use custom rescaling and std-rescaling simultaneously' + # set rescale weight to 1./std of encodings + print("### USING STD-RESCALING ###") + x = super().get_input(batch, self.first_stage_key) + x = x.to(self.device) + encoder_posterior = self.encode_first_stage(x) + z = self.get_first_stage_encoding(encoder_posterior).detach() + del self.scale_factor + self.register_buffer('scale_factor', 1. / z.flatten().std()) + print(f"setting self.scale_factor to {self.scale_factor}") + print("### USING STD-RESCALING ###") + + def register_schedule(self, + given_betas=None, beta_schedule="linear", timesteps=1000, + linear_start=1e-4, linear_end=2e-2, cosine_s=8e-3): + super().register_schedule(given_betas, beta_schedule, timesteps, linear_start, linear_end, cosine_s) + + self.shorten_cond_schedule = self.num_timesteps_cond > 1 + if self.shorten_cond_schedule: + self.make_cond_schedule() + + def instantiate_first_stage(self, config): + model = instantiate_from_config(config) + self.first_stage_model = model.eval() + self.first_stage_model.train = disabled_train + for param in self.first_stage_model.parameters(): + param.requires_grad = False + + def instantiate_cond_stage(self, config): + if not self.cond_stage_trainable: + if config == "__is_first_stage__": + print("Using first stage also as cond stage.") + self.cond_stage_model = self.first_stage_model + elif config == "__is_unconditional__": + print(f"Training {self.__class__.__name__} as an unconditional model.") + self.cond_stage_model = None + # self.be_unconditional = True + else: + model = instantiate_from_config(config) + self.cond_stage_model = model.eval() + self.cond_stage_model.train = disabled_train + for param in self.cond_stage_model.parameters(): + param.requires_grad = False + else: + assert config != '__is_first_stage__' + assert config != '__is_unconditional__' + model = instantiate_from_config(config) + self.cond_stage_model = model + + def _get_denoise_row_from_list(self, samples, desc='', force_no_decoder_quantization=False): + denoise_row = [] + for zd in tqdm(samples, desc=desc): + denoise_row.append(self.decode_first_stage(zd.to(self.device), + force_not_quantize=force_no_decoder_quantization)) + n_imgs_per_row = len(denoise_row) + denoise_row = torch.stack(denoise_row) # n_log_step, n_row, C, H, W + denoise_grid = rearrange(denoise_row, 'n b c h w -> b n c h w') + denoise_grid = rearrange(denoise_grid, 'b n c h w -> (b n) c h w') + denoise_grid = make_grid(denoise_grid, nrow=n_imgs_per_row) + return denoise_grid + + def get_first_stage_encoding(self, encoder_posterior): + if isinstance(encoder_posterior, DiagonalGaussianDistribution): + z = encoder_posterior.sample() + elif isinstance(encoder_posterior, torch.Tensor): + z = encoder_posterior + else: + raise NotImplementedError(f"encoder_posterior of type '{type(encoder_posterior)}' not yet implemented") + return self.scale_factor * z + + def get_learned_conditioning(self, c): + if self.cond_stage_forward is None: + if hasattr(self.cond_stage_model, 'encode') and callable(self.cond_stage_model.encode): + c = self.cond_stage_model.encode(c) + if isinstance(c, DiagonalGaussianDistribution): + c = c.mode() + else: + c = self.cond_stage_model(c) + else: + assert hasattr(self.cond_stage_model, self.cond_stage_forward) + c = getattr(self.cond_stage_model, self.cond_stage_forward)(c) + return c + + def meshgrid(self, h, w): + y = torch.arange(0, h).view(h, 1, 1).repeat(1, w, 1) + x = torch.arange(0, w).view(1, w, 1).repeat(h, 1, 1) + + arr = torch.cat([y, x], dim=-1) + return arr + + def delta_border(self, h, w): + """ + :param h: height + :param w: width + :return: normalized distance to image border, + wtith min distance = 0 at border and max dist = 0.5 at image center + """ + lower_right_corner = torch.tensor([h - 1, w - 1]).view(1, 1, 2) + arr = self.meshgrid(h, w) / lower_right_corner + dist_left_up = torch.min(arr, dim=-1, keepdims=True)[0] + dist_right_down = torch.min(1 - arr, dim=-1, keepdims=True)[0] + edge_dist = torch.min(torch.cat([dist_left_up, dist_right_down], dim=-1), dim=-1)[0] + return edge_dist + + def get_weighting(self, h, w, Ly, Lx, device): + weighting = self.delta_border(h, w) + weighting = torch.clip(weighting, self.split_input_params["clip_min_weight"], + self.split_input_params["clip_max_weight"], ) + weighting = weighting.view(1, h * w, 1).repeat(1, 1, Ly * Lx).to(device) + + if self.split_input_params["tie_braker"]: + L_weighting = self.delta_border(Ly, Lx) + L_weighting = torch.clip(L_weighting, + self.split_input_params["clip_min_tie_weight"], + self.split_input_params["clip_max_tie_weight"]) + + L_weighting = L_weighting.view(1, 1, Ly * Lx).to(device) + weighting = weighting * L_weighting + return weighting + + def get_fold_unfold(self, x, kernel_size, stride, uf=1, df=1): # todo load once not every time, shorten code + """ + :param x: img of size (bs, c, h, w) + :return: n img crops of size (n, bs, c, kernel_size[0], kernel_size[1]) + """ + bs, nc, h, w = x.shape + + # number of crops in image + Ly = (h - kernel_size[0]) // stride[0] + 1 + Lx = (w - kernel_size[1]) // stride[1] + 1 + + if uf == 1 and df == 1: + fold_params = dict(kernel_size=kernel_size, dilation=1, padding=0, stride=stride) + unfold = torch.nn.Unfold(**fold_params) + + fold = torch.nn.Fold(output_size=x.shape[2:], **fold_params) + + weighting = self.get_weighting(kernel_size[0], kernel_size[1], Ly, Lx, x.device).to(x.dtype) + normalization = fold(weighting).view(1, 1, h, w) # normalizes the overlap + weighting = weighting.view((1, 1, kernel_size[0], kernel_size[1], Ly * Lx)) + + elif uf > 1 and df == 1: + fold_params = dict(kernel_size=kernel_size, dilation=1, padding=0, stride=stride) + unfold = torch.nn.Unfold(**fold_params) + + fold_params2 = dict(kernel_size=(kernel_size[0] * uf, kernel_size[0] * uf), + dilation=1, padding=0, + stride=(stride[0] * uf, stride[1] * uf)) + fold = torch.nn.Fold(output_size=(x.shape[2] * uf, x.shape[3] * uf), **fold_params2) + + weighting = self.get_weighting(kernel_size[0] * uf, kernel_size[1] * uf, Ly, Lx, x.device).to(x.dtype) + normalization = fold(weighting).view(1, 1, h * uf, w * uf) # normalizes the overlap + weighting = weighting.view((1, 1, kernel_size[0] * uf, kernel_size[1] * uf, Ly * Lx)) + + elif df > 1 and uf == 1: + fold_params = dict(kernel_size=kernel_size, dilation=1, padding=0, stride=stride) + unfold = torch.nn.Unfold(**fold_params) + + fold_params2 = dict(kernel_size=(kernel_size[0] // df, kernel_size[0] // df), + dilation=1, padding=0, + stride=(stride[0] // df, stride[1] // df)) + fold = torch.nn.Fold(output_size=(x.shape[2] // df, x.shape[3] // df), **fold_params2) + + weighting = self.get_weighting(kernel_size[0] // df, kernel_size[1] // df, Ly, Lx, x.device).to(x.dtype) + normalization = fold(weighting).view(1, 1, h // df, w // df) # normalizes the overlap + weighting = weighting.view((1, 1, kernel_size[0] // df, kernel_size[1] // df, Ly * Lx)) + + else: + raise NotImplementedError + + return fold, unfold, normalization, weighting + + + @torch.no_grad() + def get_input(self, batch, k, return_first_stage_outputs=False, force_c_encode=False, + cond_key=None, return_original_cond=False, bs=None, uncond=0.05): + x = super().get_input(batch, k) + T = batch['T'].to(memory_format=torch.contiguous_format).float() + + if bs is not None: + x = x[:bs] + T = T[:bs].to(self.device) + + x = x.to(self.device) + encoder_posterior = self.encode_first_stage(x) + z = self.get_first_stage_encoding(encoder_posterior).detach() + cond_key = cond_key or self.cond_stage_key + xc = super().get_input(batch, cond_key).to(self.device) + if bs is not None: + xc = xc[:bs] + cond = {} + + # To support classifier-free guidance, randomly drop out only text conditioning 5%, only image conditioning 5%, and both 5%. + random = torch.rand(x.size(0), device=x.device) + prompt_mask = rearrange(random < 2 * uncond, "n -> n 1 1") + input_mask = 1 - rearrange((random >= uncond).float() * (random < 3 * uncond).float(), "n -> n 1 1 1") + null_prompt = self.get_learned_conditioning([""]) + + # z.shape: [8, 4, 64, 64]; c.shape: [8, 1, 768] + # print('=========== xc shape ===========', xc.shape) + with torch.enable_grad(): + clip_emb = self.get_learned_conditioning(xc).detach() + null_prompt = self.get_learned_conditioning([""]).detach() + cond["c_crossattn"] = [self.cc_projection(torch.cat([torch.where(prompt_mask, null_prompt, clip_emb), T[:, None, :]], dim=-1))] + cond["c_concat"] = [input_mask * self.encode_first_stage((xc.to(self.device))).mode().detach()] + out = [z, cond] + if return_first_stage_outputs: + xrec = self.decode_first_stage(z) + out.extend([x, xrec]) + if return_original_cond: + out.append(xc) + return out + + # @torch.no_grad() + def decode_first_stage(self, z, predict_cids=False, force_not_quantize=False): + if predict_cids: + if z.dim() == 4: + z = torch.argmax(z.exp(), dim=1).long() + z = self.first_stage_model.quantize.get_codebook_entry(z, shape=None) + z = rearrange(z, 'b h w c -> b c h w').contiguous() + + z = 1. / self.scale_factor * z + + if hasattr(self, "split_input_params"): + if self.split_input_params["patch_distributed_vq"]: + ks = self.split_input_params["ks"] # eg. (128, 128) + stride = self.split_input_params["stride"] # eg. (64, 64) + uf = self.split_input_params["vqf"] + bs, nc, h, w = z.shape + if ks[0] > h or ks[1] > w: + ks = (min(ks[0], h), min(ks[1], w)) + print("reducing Kernel") + + if stride[0] > h or stride[1] > w: + stride = (min(stride[0], h), min(stride[1], w)) + print("reducing stride") + + fold, unfold, normalization, weighting = self.get_fold_unfold(z, ks, stride, uf=uf) + + z = unfold(z) # (bn, nc * prod(**ks), L) + # 1. Reshape to img shape + z = z.view((z.shape[0], -1, ks[0], ks[1], z.shape[-1])) # (bn, nc, ks[0], ks[1], L ) + + # 2. apply model loop over last dim + if isinstance(self.first_stage_model, VQModelInterface): + output_list = [self.first_stage_model.decode(z[:, :, :, :, i], + force_not_quantize=predict_cids or force_not_quantize) + for i in range(z.shape[-1])] + else: + + output_list = [self.first_stage_model.decode(z[:, :, :, :, i]) + for i in range(z.shape[-1])] + + o = torch.stack(output_list, axis=-1) # # (bn, nc, ks[0], ks[1], L) + o = o * weighting + # Reverse 1. reshape to img shape + o = o.view((o.shape[0], -1, o.shape[-1])) # (bn, nc * ks[0] * ks[1], L) + # stitch crops together + decoded = fold(o) + decoded = decoded / normalization # norm is shape (1, 1, h, w) + return decoded + else: + if isinstance(self.first_stage_model, VQModelInterface): + return self.first_stage_model.decode(z, force_not_quantize=predict_cids or force_not_quantize) + else: + return self.first_stage_model.decode(z) + + else: + if isinstance(self.first_stage_model, VQModelInterface): + return self.first_stage_model.decode(z, force_not_quantize=predict_cids or force_not_quantize) + else: + return self.first_stage_model.decode(z) + + # @torch.no_grad() # wasted two hours to find this bug... why no grad here! + def encode_first_stage(self, x): + if hasattr(self, "split_input_params"): + if self.split_input_params["patch_distributed_vq"]: + ks = self.split_input_params["ks"] # eg. (128, 128) + stride = self.split_input_params["stride"] # eg. (64, 64) + df = self.split_input_params["vqf"] + self.split_input_params['original_image_size'] = x.shape[-2:] + bs, nc, h, w = x.shape + if ks[0] > h or ks[1] > w: + ks = (min(ks[0], h), min(ks[1], w)) + print("reducing Kernel") + + if stride[0] > h or stride[1] > w: + stride = (min(stride[0], h), min(stride[1], w)) + print("reducing stride") + + fold, unfold, normalization, weighting = self.get_fold_unfold(x, ks, stride, df=df) + z = unfold(x) # (bn, nc * prod(**ks), L) + # Reshape to img shape + z = z.view((z.shape[0], -1, ks[0], ks[1], z.shape[-1])) # (bn, nc, ks[0], ks[1], L ) + + output_list = [self.first_stage_model.encode(z[:, :, :, :, i]) + for i in range(z.shape[-1])] + + o = torch.stack(output_list, axis=-1) + o = o * weighting + + # Reverse reshape to img shape + o = o.view((o.shape[0], -1, o.shape[-1])) # (bn, nc * ks[0] * ks[1], L) + # stitch crops together + decoded = fold(o) + decoded = decoded / normalization + return decoded + + else: + return self.first_stage_model.encode(x) + else: + return self.first_stage_model.encode(x) + + def shared_step(self, batch, **kwargs): + x, c = self.get_input(batch, self.first_stage_key) + loss = self(x, c) + return loss + + def forward(self, x, c, *args, **kwargs): + t = torch.randint(0, self.num_timesteps, (x.shape[0],), device=self.device).long() + if self.model.conditioning_key is not None: + assert c is not None + # if self.cond_stage_trainable: + # c = self.get_learned_conditioning(c) + if self.shorten_cond_schedule: # TODO: drop this option + tc = self.cond_ids[t].to(self.device) + c = self.q_sample(x_start=c, t=tc, noise=torch.randn_like(c.float())) + return self.p_losses(x, c, t, *args, **kwargs) + + def _rescale_annotations(self, bboxes, crop_coordinates): # TODO: move to dataset + def rescale_bbox(bbox): + x0 = clamp((bbox[0] - crop_coordinates[0]) / crop_coordinates[2]) + y0 = clamp((bbox[1] - crop_coordinates[1]) / crop_coordinates[3]) + w = min(bbox[2] / crop_coordinates[2], 1 - x0) + h = min(bbox[3] / crop_coordinates[3], 1 - y0) + return x0, y0, w, h + + return [rescale_bbox(b) for b in bboxes] + + def apply_model(self, x_noisy, t, cond, return_ids=False): + + if isinstance(cond, dict): + # hybrid case, cond is exptected to be a dict + pass + else: + if not isinstance(cond, list): + cond = [cond] + key = 'c_concat' if self.model.conditioning_key == 'concat' else 'c_crossattn' + cond = {key: cond} + + if hasattr(self, "split_input_params"): + assert len(cond) == 1 # todo can only deal with one conditioning atm + assert not return_ids + ks = self.split_input_params["ks"] # eg. (128, 128) + stride = self.split_input_params["stride"] # eg. (64, 64) + + h, w = x_noisy.shape[-2:] + + fold, unfold, normalization, weighting = self.get_fold_unfold(x_noisy, ks, stride) + + z = unfold(x_noisy) # (bn, nc * prod(**ks), L) + # Reshape to img shape + z = z.view((z.shape[0], -1, ks[0], ks[1], z.shape[-1])) # (bn, nc, ks[0], ks[1], L ) + z_list = [z[:, :, :, :, i] for i in range(z.shape[-1])] + + if self.cond_stage_key in ["image", "LR_image", "segmentation", + 'bbox_img'] and self.model.conditioning_key: # todo check for completeness + c_key = next(iter(cond.keys())) # get key + c = next(iter(cond.values())) # get value + assert (len(c) == 1) # todo extend to list with more than one elem + c = c[0] # get element + + c = unfold(c) + c = c.view((c.shape[0], -1, ks[0], ks[1], c.shape[-1])) # (bn, nc, ks[0], ks[1], L ) + + cond_list = [{c_key: [c[:, :, :, :, i]]} for i in range(c.shape[-1])] + + elif self.cond_stage_key == 'coordinates_bbox': + assert 'original_image_size' in self.split_input_params, 'BoudingBoxRescaling is missing original_image_size' + + # assuming padding of unfold is always 0 and its dilation is always 1 + n_patches_per_row = int((w - ks[0]) / stride[0] + 1) + full_img_h, full_img_w = self.split_input_params['original_image_size'] + # as we are operating on latents, we need the factor from the original image size to the + # spatial latent size to properly rescale the crops for regenerating the bbox annotations + num_downs = self.first_stage_model.encoder.num_resolutions - 1 + rescale_latent = 2 ** (num_downs) + + # get top left postions of patches as conforming for the bbbox tokenizer, therefore we + # need to rescale the tl patch coordinates to be in between (0,1) + tl_patch_coordinates = [(rescale_latent * stride[0] * (patch_nr % n_patches_per_row) / full_img_w, + rescale_latent * stride[1] * (patch_nr // n_patches_per_row) / full_img_h) + for patch_nr in range(z.shape[-1])] + + # patch_limits are tl_coord, width and height coordinates as (x_tl, y_tl, h, w) + patch_limits = [(x_tl, y_tl, + rescale_latent * ks[0] / full_img_w, + rescale_latent * ks[1] / full_img_h) for x_tl, y_tl in tl_patch_coordinates] + # patch_values = [(np.arange(x_tl,min(x_tl+ks, 1.)),np.arange(y_tl,min(y_tl+ks, 1.))) for x_tl, y_tl in tl_patch_coordinates] + + # tokenize crop coordinates for the bounding boxes of the respective patches + patch_limits_tknzd = [torch.LongTensor(self.bbox_tokenizer._crop_encoder(bbox))[None].to(self.device) + for bbox in patch_limits] # list of length l with tensors of shape (1, 2) + # cut tknzd crop position from conditioning + assert isinstance(cond, dict), 'cond must be dict to be fed into model' + cut_cond = cond['c_crossattn'][0][..., :-2].to(self.device) + + adapted_cond = torch.stack([torch.cat([cut_cond, p], dim=1) for p in patch_limits_tknzd]) + adapted_cond = rearrange(adapted_cond, 'l b n -> (l b) n') + adapted_cond = self.get_learned_conditioning(adapted_cond) + adapted_cond = rearrange(adapted_cond, '(l b) n d -> l b n d', l=z.shape[-1]) + + cond_list = [{'c_crossattn': [e]} for e in adapted_cond] + + else: + cond_list = [cond for i in range(z.shape[-1])] # Todo make this more efficient + + # apply model by loop over crops + output_list = [self.model(z_list[i], t, **cond_list[i]) for i in range(z.shape[-1])] + assert not isinstance(output_list[0], + tuple) # todo cant deal with multiple model outputs check this never happens + + o = torch.stack(output_list, axis=-1) + o = o * weighting + # Reverse reshape to img shape + o = o.view((o.shape[0], -1, o.shape[-1])) # (bn, nc * ks[0] * ks[1], L) + # stitch crops together + x_recon = fold(o) / normalization + + else: + x_recon = self.model(x_noisy, t, **cond) + + if isinstance(x_recon, tuple) and not return_ids: + return x_recon[0] + else: + return x_recon + + def _predict_eps_from_xstart(self, x_t, t, pred_xstart): + return (extract_into_tensor(self.sqrt_recip_alphas_cumprod, t, x_t.shape) * x_t - pred_xstart) / \ + extract_into_tensor(self.sqrt_recipm1_alphas_cumprod, t, x_t.shape) + + def _prior_bpd(self, x_start): + """ + Get the prior KL term for the variational lower-bound, measured in + bits-per-dim. + This term can't be optimized, as it only depends on the encoder. + :param x_start: the [N x C x ...] tensor of inputs. + :return: a batch of [N] KL values (in bits), one per batch element. + """ + batch_size = x_start.shape[0] + t = torch.tensor([self.num_timesteps - 1] * batch_size, device=x_start.device) + qt_mean, _, qt_log_variance = self.q_mean_variance(x_start, t) + kl_prior = normal_kl(mean1=qt_mean, logvar1=qt_log_variance, mean2=0.0, logvar2=0.0) + return mean_flat(kl_prior) / np.log(2.0) + + def p_losses(self, x_start, cond, t, noise=None): + noise = default(noise, lambda: torch.randn_like(x_start)) + x_noisy = self.q_sample(x_start=x_start, t=t, noise=noise) + model_output = self.apply_model(x_noisy, t, cond) + + loss_dict = {} + prefix = 'train' if self.training else 'val' + + if self.parameterization == "x0": + target = x_start + elif self.parameterization == "eps": + target = noise + else: + raise NotImplementedError() + + loss_simple = self.get_loss(model_output, target, mean=False).mean([1, 2, 3]) + loss_dict.update({f'{prefix}/loss_simple': loss_simple.mean()}) + + logvar_t = self.logvar[t].to(self.device) + loss = loss_simple / torch.exp(logvar_t) + logvar_t + # loss = loss_simple / torch.exp(self.logvar) + self.logvar + if self.learn_logvar: + loss_dict.update({f'{prefix}/loss_gamma': loss.mean()}) + loss_dict.update({'logvar': self.logvar.data.mean()}) + + loss = self.l_simple_weight * loss.mean() + + loss_vlb = self.get_loss(model_output, target, mean=False).mean(dim=(1, 2, 3)) + loss_vlb = (self.lvlb_weights[t] * loss_vlb).mean() + loss_dict.update({f'{prefix}/loss_vlb': loss_vlb}) + loss += (self.original_elbo_weight * loss_vlb) + loss_dict.update({f'{prefix}/loss': loss}) + + return loss, loss_dict + + def p_mean_variance(self, x, c, t, clip_denoised: bool, return_codebook_ids=False, quantize_denoised=False, + return_x0=False, score_corrector=None, corrector_kwargs=None): + t_in = t + model_out = self.apply_model(x, t_in, c, return_ids=return_codebook_ids) + + if score_corrector is not None: + assert self.parameterization == "eps" + model_out = score_corrector.modify_score(self, model_out, x, t, c, **corrector_kwargs) + + if return_codebook_ids: + model_out, logits = model_out + + if self.parameterization == "eps": + x_recon = self.predict_start_from_noise(x, t=t, noise=model_out) + elif self.parameterization == "x0": + x_recon = model_out + else: + raise NotImplementedError() + + if clip_denoised: + x_recon.clamp_(-1., 1.) + if quantize_denoised: + x_recon, _, [_, _, indices] = self.first_stage_model.quantize(x_recon) + model_mean, posterior_variance, posterior_log_variance = self.q_posterior(x_start=x_recon, x_t=x, t=t) + if return_codebook_ids: + return model_mean, posterior_variance, posterior_log_variance, logits + elif return_x0: + return model_mean, posterior_variance, posterior_log_variance, x_recon + else: + return model_mean, posterior_variance, posterior_log_variance + + @torch.no_grad() + def p_sample(self, x, c, t, clip_denoised=False, repeat_noise=False, + return_codebook_ids=False, quantize_denoised=False, return_x0=False, + temperature=1., noise_dropout=0., score_corrector=None, corrector_kwargs=None): + b, *_, device = *x.shape, x.device + outputs = self.p_mean_variance(x=x, c=c, t=t, clip_denoised=clip_denoised, + return_codebook_ids=return_codebook_ids, + quantize_denoised=quantize_denoised, + return_x0=return_x0, + score_corrector=score_corrector, corrector_kwargs=corrector_kwargs) + if return_codebook_ids: + raise DeprecationWarning("Support dropped.") + model_mean, _, model_log_variance, logits = outputs + elif return_x0: + model_mean, _, model_log_variance, x0 = outputs + else: + model_mean, _, model_log_variance = outputs + + noise = noise_like(x.shape, device, repeat_noise) * temperature + if noise_dropout > 0.: + noise = torch.nn.functional.dropout(noise, p=noise_dropout) + # no noise when t == 0 + nonzero_mask = (1 - (t == 0).float()).reshape(b, *((1,) * (len(x.shape) - 1))) + + if return_codebook_ids: + return model_mean + nonzero_mask * (0.5 * model_log_variance).exp() * noise, logits.argmax(dim=1) + if return_x0: + return model_mean + nonzero_mask * (0.5 * model_log_variance).exp() * noise, x0 + else: + return model_mean + nonzero_mask * (0.5 * model_log_variance).exp() * noise + + @torch.no_grad() + def progressive_denoising(self, cond, shape, verbose=True, callback=None, quantize_denoised=False, + img_callback=None, mask=None, x0=None, temperature=1., noise_dropout=0., + score_corrector=None, corrector_kwargs=None, batch_size=None, x_T=None, start_T=None, + log_every_t=None): + if not log_every_t: + log_every_t = self.log_every_t + timesteps = self.num_timesteps + if batch_size is not None: + b = batch_size if batch_size is not None else shape[0] + shape = [batch_size] + list(shape) + else: + b = batch_size = shape[0] + if x_T is None: + img = torch.randn(shape, device=self.device) + else: + img = x_T + intermediates = [] + if cond is not None: + if isinstance(cond, dict): + cond = {key: cond[key][:batch_size] if not isinstance(cond[key], list) else + list(map(lambda x: x[:batch_size], cond[key])) for key in cond} + else: + cond = [c[:batch_size] for c in cond] if isinstance(cond, list) else cond[:batch_size] + + if start_T is not None: + timesteps = min(timesteps, start_T) + iterator = tqdm(reversed(range(0, timesteps)), desc='Progressive Generation', + total=timesteps) if verbose else reversed( + range(0, timesteps)) + if type(temperature) == float: + temperature = [temperature] * timesteps + + for i in iterator: + ts = torch.full((b,), i, device=self.device, dtype=torch.long) + if self.shorten_cond_schedule: + assert self.model.conditioning_key != 'hybrid' + tc = self.cond_ids[ts].to(cond.device) + cond = self.q_sample(x_start=cond, t=tc, noise=torch.randn_like(cond)) + + img, x0_partial = self.p_sample(img, cond, ts, + clip_denoised=self.clip_denoised, + quantize_denoised=quantize_denoised, return_x0=True, + temperature=temperature[i], noise_dropout=noise_dropout, + score_corrector=score_corrector, corrector_kwargs=corrector_kwargs) + if mask is not None: + assert x0 is not None + img_orig = self.q_sample(x0, ts) + img = img_orig * mask + (1. - mask) * img + + if i % log_every_t == 0 or i == timesteps - 1: + intermediates.append(x0_partial) + if callback: callback(i) + if img_callback: img_callback(img, i) + return img, intermediates + + @torch.no_grad() + def p_sample_loop(self, cond, shape, return_intermediates=False, + x_T=None, verbose=True, callback=None, timesteps=None, quantize_denoised=False, + mask=None, x0=None, img_callback=None, start_T=None, + log_every_t=None): + + if not log_every_t: + log_every_t = self.log_every_t + device = self.betas.device + b = shape[0] + if x_T is None: + img = torch.randn(shape, device=device) + else: + img = x_T + + intermediates = [img] + if timesteps is None: + timesteps = self.num_timesteps + + if start_T is not None: + timesteps = min(timesteps, start_T) + iterator = tqdm(reversed(range(0, timesteps)), desc='Sampling t', total=timesteps) if verbose else reversed( + range(0, timesteps)) + + if mask is not None: + assert x0 is not None + assert x0.shape[2:3] == mask.shape[2:3] # spatial size has to match + + for i in iterator: + ts = torch.full((b,), i, device=device, dtype=torch.long) + if self.shorten_cond_schedule: + assert self.model.conditioning_key != 'hybrid' + tc = self.cond_ids[ts].to(cond.device) + cond = self.q_sample(x_start=cond, t=tc, noise=torch.randn_like(cond)) + + img = self.p_sample(img, cond, ts, + clip_denoised=self.clip_denoised, + quantize_denoised=quantize_denoised) + if mask is not None: + img_orig = self.q_sample(x0, ts) + img = img_orig * mask + (1. - mask) * img + + if i % log_every_t == 0 or i == timesteps - 1: + intermediates.append(img) + if callback: callback(i) + if img_callback: img_callback(img, i) + + if return_intermediates: + return img, intermediates + return img + + @torch.no_grad() + def sample(self, cond, batch_size=16, return_intermediates=False, x_T=None, + verbose=True, timesteps=None, quantize_denoised=False, + mask=None, x0=None, shape=None,**kwargs): + if shape is None: + shape = (batch_size, self.channels, self.image_size, self.image_size) + if cond is not None: + if isinstance(cond, dict): + cond = {key: cond[key][:batch_size] if not isinstance(cond[key], list) else + list(map(lambda x: x[:batch_size], cond[key])) for key in cond} + else: + cond = [c[:batch_size] for c in cond] if isinstance(cond, list) else cond[:batch_size] + return self.p_sample_loop(cond, + shape, + return_intermediates=return_intermediates, x_T=x_T, + verbose=verbose, timesteps=timesteps, quantize_denoised=quantize_denoised, + mask=mask, x0=x0) + + @torch.no_grad() + def sample_log(self, cond, batch_size, ddim, ddim_steps, **kwargs): + if ddim: + ddim_sampler = DDIMSampler(self) + shape = (self.channels, self.image_size, self.image_size) + samples, intermediates = ddim_sampler.sample(ddim_steps, batch_size, + shape, cond, verbose=False, **kwargs) + + else: + samples, intermediates = self.sample(cond=cond, batch_size=batch_size, + return_intermediates=True, **kwargs) + + return samples, intermediates + + @torch.no_grad() + def get_unconditional_conditioning(self, batch_size, null_label=None, image_size=512): + if null_label is not None: + xc = null_label + if isinstance(xc, ListConfig): + xc = list(xc) + if isinstance(xc, dict) or isinstance(xc, list): + c = self.get_learned_conditioning(xc) + else: + if hasattr(xc, "to"): + xc = xc.to(self.device) + c = self.get_learned_conditioning(xc) + else: + # todo: get null label from cond_stage_model + raise NotImplementedError() + c = repeat(c, '1 ... -> b ...', b=batch_size).to(self.device) + cond = {} + cond["c_crossattn"] = [c] + cond["c_concat"] = [torch.zeros([batch_size, 4, image_size // 8, image_size // 8]).to(self.device)] + return cond + + @torch.no_grad() + def log_images(self, batch, N=8, n_row=4, sample=True, ddim_steps=200, ddim_eta=1., return_keys=None, + quantize_denoised=True, inpaint=True, plot_denoise_rows=False, plot_progressive_rows=True, + plot_diffusion_rows=True, unconditional_guidance_scale=1., unconditional_guidance_label=None, + use_ema_scope=True, + **kwargs): + ema_scope = self.ema_scope if use_ema_scope else nullcontext + use_ddim = ddim_steps is not None + + log = dict() + z, c, x, xrec, xc = self.get_input(batch, self.first_stage_key, + return_first_stage_outputs=True, + force_c_encode=True, + return_original_cond=True, + bs=N) + N = min(x.shape[0], N) + n_row = min(x.shape[0], n_row) + log["inputs"] = x + log["reconstruction"] = xrec + if self.model.conditioning_key is not None: + if hasattr(self.cond_stage_model, "decode"): + xc = self.cond_stage_model.decode(c) + log["conditioning"] = xc + elif self.cond_stage_key in ["caption", "txt"]: + xc = log_txt_as_img((x.shape[2], x.shape[3]), batch[self.cond_stage_key], size=x.shape[2]//25) + log["conditioning"] = xc + elif self.cond_stage_key == 'class_label': + xc = log_txt_as_img((x.shape[2], x.shape[3]), batch["human_label"], size=x.shape[2]//25) + log['conditioning'] = xc + elif isimage(xc): + log["conditioning"] = xc + if ismap(xc): + log["original_conditioning"] = self.to_rgb(xc) + + if plot_diffusion_rows: + # get diffusion row + diffusion_row = list() + z_start = z[:n_row] + for t in range(self.num_timesteps): + if t % self.log_every_t == 0 or t == self.num_timesteps - 1: + t = repeat(torch.tensor([t]), '1 -> b', b=n_row) + t = t.to(self.device).long() + noise = torch.randn_like(z_start) + z_noisy = self.q_sample(x_start=z_start, t=t, noise=noise) + diffusion_row.append(self.decode_first_stage(z_noisy)) + + diffusion_row = torch.stack(diffusion_row) # n_log_step, n_row, C, H, W + diffusion_grid = rearrange(diffusion_row, 'n b c h w -> b n c h w') + diffusion_grid = rearrange(diffusion_grid, 'b n c h w -> (b n) c h w') + diffusion_grid = make_grid(diffusion_grid, nrow=diffusion_row.shape[0]) + log["diffusion_row"] = diffusion_grid + + if sample: + # get denoise row + with ema_scope("Sampling"): + samples, z_denoise_row = self.sample_log(cond=c,batch_size=N,ddim=use_ddim, + ddim_steps=ddim_steps,eta=ddim_eta) + # samples, z_denoise_row = self.sample(cond=c, batch_size=N, return_intermediates=True) + x_samples = self.decode_first_stage(samples) + log["samples"] = x_samples + if plot_denoise_rows: + denoise_grid = self._get_denoise_row_from_list(z_denoise_row) + log["denoise_row"] = denoise_grid + + if quantize_denoised and not isinstance(self.first_stage_model, AutoencoderKL) and not isinstance( + self.first_stage_model, IdentityFirstStage): + # also display when quantizing x0 while sampling + with ema_scope("Plotting Quantized Denoised"): + samples, z_denoise_row = self.sample_log(cond=c,batch_size=N,ddim=use_ddim, + ddim_steps=ddim_steps,eta=ddim_eta, + quantize_denoised=True) + # samples, z_denoise_row = self.sample(cond=c, batch_size=N, return_intermediates=True, + # quantize_denoised=True) + x_samples = self.decode_first_stage(samples.to(self.device)) + log["samples_x0_quantized"] = x_samples + + if unconditional_guidance_scale > 1.0: + uc = self.get_unconditional_conditioning(N, unconditional_guidance_label, image_size=x.shape[-1]) + # uc = torch.zeros_like(c) + with ema_scope("Sampling with classifier-free guidance"): + samples_cfg, _ = self.sample_log(cond=c, batch_size=N, ddim=use_ddim, + ddim_steps=ddim_steps, eta=ddim_eta, + unconditional_guidance_scale=unconditional_guidance_scale, + unconditional_conditioning=uc, + ) + x_samples_cfg = self.decode_first_stage(samples_cfg) + log[f"samples_cfg_scale_{unconditional_guidance_scale:.2f}"] = x_samples_cfg + + if inpaint: + # make a simple center square + b, h, w = z.shape[0], z.shape[2], z.shape[3] + mask = torch.ones(N, h, w).to(self.device) + # zeros will be filled in + mask[:, h // 4:3 * h // 4, w // 4:3 * w // 4] = 0. + mask = mask[:, None, ...] + with ema_scope("Plotting Inpaint"): + + samples, _ = self.sample_log(cond=c,batch_size=N,ddim=use_ddim, eta=ddim_eta, + ddim_steps=ddim_steps, x0=z[:N], mask=mask) + x_samples = self.decode_first_stage(samples.to(self.device)) + log["samples_inpainting"] = x_samples + log["mask"] = mask + + # outpaint + mask = 1. - mask + with ema_scope("Plotting Outpaint"): + samples, _ = self.sample_log(cond=c, batch_size=N, ddim=use_ddim,eta=ddim_eta, + ddim_steps=ddim_steps, x0=z[:N], mask=mask) + x_samples = self.decode_first_stage(samples.to(self.device)) + log["samples_outpainting"] = x_samples + + if plot_progressive_rows: + with ema_scope("Plotting Progressives"): + img, progressives = self.progressive_denoising(c, + shape=(self.channels, self.image_size, self.image_size), + batch_size=N) + prog_row = self._get_denoise_row_from_list(progressives, desc="Progressive Generation") + log["progressive_row"] = prog_row + + if return_keys: + if np.intersect1d(list(log.keys()), return_keys).shape[0] == 0: + return log + else: + return {key: log[key] for key in return_keys} + return log + + def configure_optimizers(self): + lr = self.learning_rate + params = [] + if self.unet_trainable == "attn": + print("Training only unet attention layers") + for n, m in self.model.named_modules(): + if isinstance(m, CrossAttention) and n.endswith('attn2'): + params.extend(m.parameters()) + if self.unet_trainable == "conv_in": + print("Training only unet input conv layers") + params = list(self.model.diffusion_model.input_blocks[0][0].parameters()) + elif self.unet_trainable is True or self.unet_trainable == "all": + print("Training the full unet") + params = list(self.model.parameters()) + else: + raise ValueError(f"Unrecognised setting for unet_trainable: {self.unet_trainable}") + + if self.cond_stage_trainable: + print(f"{self.__class__.__name__}: Also optimizing conditioner params!") + params = params + list(self.cond_stage_model.parameters()) + if self.learn_logvar: + print('Diffusion model optimizing logvar') + params.append(self.logvar) + + if self.cc_projection is not None: + params = params + list(self.cc_projection.parameters()) + print('========== optimizing for cc projection weight ==========') + + opt = torch.optim.AdamW([{"params": self.model.parameters(), "lr": lr}, + {"params": self.cc_projection.parameters(), "lr": 10. * lr}], lr=lr) + if self.use_scheduler: + assert 'target' in self.scheduler_config + scheduler = instantiate_from_config(self.scheduler_config) + + print("Setting up LambdaLR scheduler...") + scheduler = [ + { + 'scheduler': LambdaLR(opt, lr_lambda=scheduler.schedule), + 'interval': 'step', + 'frequency': 1 + }] + return [opt], scheduler + return opt + + @torch.no_grad() + def to_rgb(self, x): + x = x.float() + if not hasattr(self, "colorize"): + self.colorize = torch.randn(3, x.shape[1], 1, 1).to(x) + x = nn.functional.conv2d(x, weight=self.colorize) + x = 2. * (x - x.min()) / (x.max() - x.min()) - 1. + return x + + +class DiffusionWrapper(pl.LightningModule): + def __init__(self, diff_model_config, conditioning_key): + super().__init__() + self.diffusion_model = instantiate_from_config(diff_model_config) + self.conditioning_key = conditioning_key + assert self.conditioning_key in [None, 'concat', 'crossattn', 'hybrid', 'adm', 'hybrid-adm'] + + def forward(self, x, t, c_concat: list = None, c_crossattn: list = None, c_adm=None): + if self.conditioning_key is None: + out = self.diffusion_model(x, t) + elif self.conditioning_key == 'concat': + xc = torch.cat([x] + c_concat, dim=1) + out = self.diffusion_model(xc, t) + elif self.conditioning_key == 'crossattn': + # c_crossattn dimension: torch.Size([8, 1, 768]) 1 + # cc dimension: torch.Size([8, 1, 768] + cc = torch.cat(c_crossattn, 1) + out = self.diffusion_model(x, t, context=cc) + elif self.conditioning_key == 'hybrid': + xc = torch.cat([x] + c_concat, dim=1) + cc = torch.cat(c_crossattn, 1) + out = self.diffusion_model(xc, t, context=cc) + elif self.conditioning_key == 'hybrid-adm': + assert c_adm is not None + xc = torch.cat([x] + c_concat, dim=1) + cc = torch.cat(c_crossattn, 1) + out = self.diffusion_model(xc, t, context=cc, y=c_adm) + elif self.conditioning_key == 'adm': + cc = c_crossattn[0] + out = self.diffusion_model(x, t, y=cc) + else: + raise NotImplementedError() + + return out + + +class LatentUpscaleDiffusion(LatentDiffusion): + def __init__(self, *args, low_scale_config, low_scale_key="LR", **kwargs): + super().__init__(*args, **kwargs) + # assumes that neither the cond_stage nor the low_scale_model contain trainable params + assert not self.cond_stage_trainable + self.instantiate_low_stage(low_scale_config) + self.low_scale_key = low_scale_key + + def instantiate_low_stage(self, config): + model = instantiate_from_config(config) + self.low_scale_model = model.eval() + self.low_scale_model.train = disabled_train + for param in self.low_scale_model.parameters(): + param.requires_grad = False + + @torch.no_grad() + def get_input(self, batch, k, cond_key=None, bs=None, log_mode=False): + if not log_mode: + z, c = super().get_input(batch, k, force_c_encode=True, bs=bs) + else: + z, c, x, xrec, xc = super().get_input(batch, self.first_stage_key, return_first_stage_outputs=True, + force_c_encode=True, return_original_cond=True, bs=bs) + x_low = batch[self.low_scale_key][:bs] + x_low = rearrange(x_low, 'b h w c -> b c h w') + x_low = x_low.to(memory_format=torch.contiguous_format).float() + zx, noise_level = self.low_scale_model(x_low) + all_conds = {"c_concat": [zx], "c_crossattn": [c], "c_adm": noise_level} + #import pudb; pu.db + if log_mode: + # TODO: maybe disable if too expensive + interpretability = False + if interpretability: + zx = zx[:, :, ::2, ::2] + x_low_rec = self.low_scale_model.decode(zx) + return z, all_conds, x, xrec, xc, x_low, x_low_rec, noise_level + return z, all_conds + + @torch.no_grad() + def log_images(self, batch, N=8, n_row=4, sample=True, ddim_steps=200, ddim_eta=1., return_keys=None, + plot_denoise_rows=False, plot_progressive_rows=True, plot_diffusion_rows=True, + unconditional_guidance_scale=1., unconditional_guidance_label=None, use_ema_scope=True, + **kwargs): + ema_scope = self.ema_scope if use_ema_scope else nullcontext + use_ddim = ddim_steps is not None + + log = dict() + z, c, x, xrec, xc, x_low, x_low_rec, noise_level = self.get_input(batch, self.first_stage_key, bs=N, + log_mode=True) + N = min(x.shape[0], N) + n_row = min(x.shape[0], n_row) + log["inputs"] = x + log["reconstruction"] = xrec + log["x_lr"] = x_low + log[f"x_lr_rec_@noise_levels{'-'.join(map(lambda x: str(x), list(noise_level.cpu().numpy())))}"] = x_low_rec + if self.model.conditioning_key is not None: + if hasattr(self.cond_stage_model, "decode"): + xc = self.cond_stage_model.decode(c) + log["conditioning"] = xc + elif self.cond_stage_key in ["caption", "txt"]: + xc = log_txt_as_img((x.shape[2], x.shape[3]), batch[self.cond_stage_key], size=x.shape[2]//25) + log["conditioning"] = xc + elif self.cond_stage_key == 'class_label': + xc = log_txt_as_img((x.shape[2], x.shape[3]), batch["human_label"], size=x.shape[2]//25) + log['conditioning'] = xc + elif isimage(xc): + log["conditioning"] = xc + if ismap(xc): + log["original_conditioning"] = self.to_rgb(xc) + + if plot_diffusion_rows: + # get diffusion row + diffusion_row = list() + z_start = z[:n_row] + for t in range(self.num_timesteps): + if t % self.log_every_t == 0 or t == self.num_timesteps - 1: + t = repeat(torch.tensor([t]), '1 -> b', b=n_row) + t = t.to(self.device).long() + noise = torch.randn_like(z_start) + z_noisy = self.q_sample(x_start=z_start, t=t, noise=noise) + diffusion_row.append(self.decode_first_stage(z_noisy)) + + diffusion_row = torch.stack(diffusion_row) # n_log_step, n_row, C, H, W + diffusion_grid = rearrange(diffusion_row, 'n b c h w -> b n c h w') + diffusion_grid = rearrange(diffusion_grid, 'b n c h w -> (b n) c h w') + diffusion_grid = make_grid(diffusion_grid, nrow=diffusion_row.shape[0]) + log["diffusion_row"] = diffusion_grid + + if sample: + # get denoise row + with ema_scope("Sampling"): + samples, z_denoise_row = self.sample_log(cond=c, batch_size=N, ddim=use_ddim, + ddim_steps=ddim_steps, eta=ddim_eta) + # samples, z_denoise_row = self.sample(cond=c, batch_size=N, return_intermediates=True) + x_samples = self.decode_first_stage(samples) + log["samples"] = x_samples + if plot_denoise_rows: + denoise_grid = self._get_denoise_row_from_list(z_denoise_row) + log["denoise_row"] = denoise_grid + + if unconditional_guidance_scale > 1.0: + uc_tmp = self.get_unconditional_conditioning(N, unconditional_guidance_label) + # TODO explore better "unconditional" choices for the other keys + # maybe guide away from empty text label and highest noise level and maximally degraded zx? + uc = dict() + for k in c: + if k == "c_crossattn": + assert isinstance(c[k], list) and len(c[k]) == 1 + uc[k] = [uc_tmp] + elif k == "c_adm": # todo: only run with text-based guidance? + assert isinstance(c[k], torch.Tensor) + uc[k] = torch.ones_like(c[k]) * self.low_scale_model.max_noise_level + elif isinstance(c[k], list): + uc[k] = [c[k][i] for i in range(len(c[k]))] + else: + uc[k] = c[k] + + with ema_scope("Sampling with classifier-free guidance"): + samples_cfg, _ = self.sample_log(cond=c, batch_size=N, ddim=use_ddim, + ddim_steps=ddim_steps, eta=ddim_eta, + unconditional_guidance_scale=unconditional_guidance_scale, + unconditional_conditioning=uc, + ) + x_samples_cfg = self.decode_first_stage(samples_cfg) + log[f"samples_cfg_scale_{unconditional_guidance_scale:.2f}"] = x_samples_cfg + + if plot_progressive_rows: + with ema_scope("Plotting Progressives"): + img, progressives = self.progressive_denoising(c, + shape=(self.channels, self.image_size, self.image_size), + batch_size=N) + prog_row = self._get_denoise_row_from_list(progressives, desc="Progressive Generation") + log["progressive_row"] = prog_row + + return log + + +class LatentInpaintDiffusion(LatentDiffusion): + """ + can either run as pure inpainting model (only concat mode) or with mixed conditionings, + e.g. mask as concat and text via cross-attn. + To disable finetuning mode, set finetune_keys to None + """ + def __init__(self, + finetune_keys=("model.diffusion_model.input_blocks.0.0.weight", + "model_ema.diffusion_modelinput_blocks00weight" + ), + concat_keys=("mask", "masked_image"), + masked_image_key="masked_image", + keep_finetune_dims=4, # if model was trained without concat mode before and we would like to keep these channels + c_concat_log_start=None, # to log reconstruction of c_concat codes + c_concat_log_end=None, + *args, **kwargs + ): + ckpt_path = kwargs.pop("ckpt_path", None) + ignore_keys = kwargs.pop("ignore_keys", list()) + super().__init__(*args, **kwargs) + self.masked_image_key = masked_image_key + assert self.masked_image_key in concat_keys + self.finetune_keys = finetune_keys + self.concat_keys = concat_keys + self.keep_dims = keep_finetune_dims + self.c_concat_log_start = c_concat_log_start + self.c_concat_log_end = c_concat_log_end + if exists(self.finetune_keys): assert exists(ckpt_path), 'can only finetune from a given checkpoint' + if exists(ckpt_path): + self.init_from_ckpt(ckpt_path, ignore_keys) + + def init_from_ckpt(self, path, ignore_keys=list(), only_model=False): + sd = torch.load(path, map_location="cpu") + if "state_dict" in list(sd.keys()): + sd = sd["state_dict"] + keys = list(sd.keys()) + for k in keys: + for ik in ignore_keys: + if k.startswith(ik): + print("Deleting key {} from state_dict.".format(k)) + del sd[k] + + # make it explicit, finetune by including extra input channels + if exists(self.finetune_keys) and k in self.finetune_keys: + new_entry = None + for name, param in self.named_parameters(): + if name in self.finetune_keys: + print(f"modifying key '{name}' and keeping its original {self.keep_dims} (channels) dimensions only") + new_entry = torch.zeros_like(param) # zero init + assert exists(new_entry), 'did not find matching parameter to modify' + new_entry[:, :self.keep_dims, ...] = sd[k] + sd[k] = new_entry + + missing, unexpected = self.load_state_dict(sd, strict=False) if not only_model else self.model.load_state_dict(sd, strict=False) + print(f"Restored from {path} with {len(missing)} missing and {len(unexpected)} unexpected keys") + if len(missing) > 0: + print(f"Missing Keys: {missing}") + if len(unexpected) > 0: + print(f"Unexpected Keys: {unexpected}") + + @torch.no_grad() + def get_input(self, batch, k, cond_key=None, bs=None, return_first_stage_outputs=False): + # note: restricted to non-trainable encoders currently + assert not self.cond_stage_trainable, 'trainable cond stages not yet supported for inpainting' + z, c, x, xrec, xc = super().get_input(batch, self.first_stage_key, return_first_stage_outputs=True, + force_c_encode=True, return_original_cond=True, bs=bs) + + assert exists(self.concat_keys) + c_cat = list() + for ck in self.concat_keys: + cc = rearrange(batch[ck], 'b h w c -> b c h w').to(memory_format=torch.contiguous_format).float() + if bs is not None: + cc = cc[:bs] + cc = cc.to(self.device) + bchw = z.shape + if ck != self.masked_image_key: + cc = torch.nn.functional.interpolate(cc, size=bchw[-2:]) + else: + cc = self.get_first_stage_encoding(self.encode_first_stage(cc)) + c_cat.append(cc) + c_cat = torch.cat(c_cat, dim=1) + all_conds = {"c_concat": [c_cat], "c_crossattn": [c]} + if return_first_stage_outputs: + return z, all_conds, x, xrec, xc + return z, all_conds + + @torch.no_grad() + def log_images(self, batch, N=8, n_row=4, sample=True, ddim_steps=200, ddim_eta=1., return_keys=None, + quantize_denoised=True, inpaint=True, plot_denoise_rows=False, plot_progressive_rows=True, + plot_diffusion_rows=True, unconditional_guidance_scale=1., unconditional_guidance_label=None, + use_ema_scope=True, + **kwargs): + ema_scope = self.ema_scope if use_ema_scope else nullcontext + use_ddim = ddim_steps is not None + + log = dict() + z, c, x, xrec, xc = self.get_input(batch, self.first_stage_key, bs=N, return_first_stage_outputs=True) + c_cat, c = c["c_concat"][0], c["c_crossattn"][0] + N = min(x.shape[0], N) + n_row = min(x.shape[0], n_row) + log["inputs"] = x + log["reconstruction"] = xrec + if self.model.conditioning_key is not None: + if hasattr(self.cond_stage_model, "decode"): + xc = self.cond_stage_model.decode(c) + log["conditioning"] = xc + elif self.cond_stage_key in ["caption", "txt"]: + xc = log_txt_as_img((x.shape[2], x.shape[3]), batch[self.cond_stage_key], size=x.shape[2] // 25) + log["conditioning"] = xc + elif self.cond_stage_key == 'class_label': + xc = log_txt_as_img((x.shape[2], x.shape[3]), batch["human_label"], size=x.shape[2] // 25) + log['conditioning'] = xc + elif isimage(xc): + log["conditioning"] = xc + if ismap(xc): + log["original_conditioning"] = self.to_rgb(xc) + + if not (self.c_concat_log_start is None and self.c_concat_log_end is None): + log["c_concat_decoded"] = self.decode_first_stage(c_cat[:,self.c_concat_log_start:self.c_concat_log_end]) + + if plot_diffusion_rows: + # get diffusion row + diffusion_row = list() + z_start = z[:n_row] + for t in range(self.num_timesteps): + if t % self.log_every_t == 0 or t == self.num_timesteps - 1: + t = repeat(torch.tensor([t]), '1 -> b', b=n_row) + t = t.to(self.device).long() + noise = torch.randn_like(z_start) + z_noisy = self.q_sample(x_start=z_start, t=t, noise=noise) + diffusion_row.append(self.decode_first_stage(z_noisy)) + + diffusion_row = torch.stack(diffusion_row) # n_log_step, n_row, C, H, W + diffusion_grid = rearrange(diffusion_row, 'n b c h w -> b n c h w') + diffusion_grid = rearrange(diffusion_grid, 'b n c h w -> (b n) c h w') + diffusion_grid = make_grid(diffusion_grid, nrow=diffusion_row.shape[0]) + log["diffusion_row"] = diffusion_grid + + if sample: + # get denoise row + with ema_scope("Sampling"): + samples, z_denoise_row = self.sample_log(cond={"c_concat": [c_cat], "c_crossattn": [c]}, + batch_size=N, ddim=use_ddim, + ddim_steps=ddim_steps, eta=ddim_eta) + # samples, z_denoise_row = self.sample(cond=c, batch_size=N, return_intermediates=True) + x_samples = self.decode_first_stage(samples) + log["samples"] = x_samples + if plot_denoise_rows: + denoise_grid = self._get_denoise_row_from_list(z_denoise_row) + log["denoise_row"] = denoise_grid + + if unconditional_guidance_scale > 1.0: + uc_cross = self.get_unconditional_conditioning(N, unconditional_guidance_label) + uc_cat = c_cat + uc_full = {"c_concat": [uc_cat], "c_crossattn": [uc_cross]} + with ema_scope("Sampling with classifier-free guidance"): + samples_cfg, _ = self.sample_log(cond={"c_concat": [c_cat], "c_crossattn": [c]}, + batch_size=N, ddim=use_ddim, + ddim_steps=ddim_steps, eta=ddim_eta, + unconditional_guidance_scale=unconditional_guidance_scale, + unconditional_conditioning=uc_full, + ) + x_samples_cfg = self.decode_first_stage(samples_cfg) + log[f"samples_cfg_scale_{unconditional_guidance_scale:.2f}"] = x_samples_cfg + + log["masked_image"] = rearrange(batch["masked_image"], + 'b h w c -> b c h w').to(memory_format=torch.contiguous_format).float() + return log + + +class Layout2ImgDiffusion(LatentDiffusion): + # TODO: move all layout-specific hacks to this class + def __init__(self, cond_stage_key, *args, **kwargs): + assert cond_stage_key == 'coordinates_bbox', 'Layout2ImgDiffusion only for cond_stage_key="coordinates_bbox"' + super().__init__(cond_stage_key=cond_stage_key, *args, **kwargs) + + def log_images(self, batch, N=8, *args, **kwargs): + logs = super().log_images(batch=batch, N=N, *args, **kwargs) + + key = 'train' if self.training else 'validation' + dset = self.trainer.datamodule.datasets[key] + mapper = dset.conditional_builders[self.cond_stage_key] + + bbox_imgs = [] + map_fn = lambda catno: dset.get_textual_label(dset.get_category_id(catno)) + for tknzd_bbox in batch[self.cond_stage_key][:N]: + bboximg = mapper.plot(tknzd_bbox.detach().cpu(), map_fn, (256, 256)) + bbox_imgs.append(bboximg) + + cond_img = torch.stack(bbox_imgs, dim=0) + logs['bbox_image'] = cond_img + return logs + + +class SimpleUpscaleDiffusion(LatentDiffusion): + def __init__(self, *args, low_scale_key="LR", **kwargs): + super().__init__(*args, **kwargs) + # assumes that neither the cond_stage nor the low_scale_model contain trainable params + assert not self.cond_stage_trainable + self.low_scale_key = low_scale_key + + @torch.no_grad() + def get_input(self, batch, k, cond_key=None, bs=None, log_mode=False): + if not log_mode: + z, c = super().get_input(batch, k, force_c_encode=True, bs=bs) + else: + z, c, x, xrec, xc = super().get_input(batch, self.first_stage_key, return_first_stage_outputs=True, + force_c_encode=True, return_original_cond=True, bs=bs) + x_low = batch[self.low_scale_key][:bs] + x_low = rearrange(x_low, 'b h w c -> b c h w') + x_low = x_low.to(memory_format=torch.contiguous_format).float() + + encoder_posterior = self.encode_first_stage(x_low) + zx = self.get_first_stage_encoding(encoder_posterior).detach() + all_conds = {"c_concat": [zx], "c_crossattn": [c]} + + if log_mode: + # TODO: maybe disable if too expensive + interpretability = False + if interpretability: + zx = zx[:, :, ::2, ::2] + return z, all_conds, x, xrec, xc, x_low + return z, all_conds + + @torch.no_grad() + def log_images(self, batch, N=8, n_row=4, sample=True, ddim_steps=200, ddim_eta=1., return_keys=None, + plot_denoise_rows=False, plot_progressive_rows=True, plot_diffusion_rows=True, + unconditional_guidance_scale=1., unconditional_guidance_label=None, use_ema_scope=True, + **kwargs): + ema_scope = self.ema_scope if use_ema_scope else nullcontext + use_ddim = ddim_steps is not None + + log = dict() + z, c, x, xrec, xc, x_low = self.get_input(batch, self.first_stage_key, bs=N, log_mode=True) + N = min(x.shape[0], N) + n_row = min(x.shape[0], n_row) + log["inputs"] = x + log["reconstruction"] = xrec + log["x_lr"] = x_low + + if self.model.conditioning_key is not None: + if hasattr(self.cond_stage_model, "decode"): + xc = self.cond_stage_model.decode(c) + log["conditioning"] = xc + elif self.cond_stage_key in ["caption", "txt"]: + xc = log_txt_as_img((x.shape[2], x.shape[3]), batch[self.cond_stage_key], size=x.shape[2]//25) + log["conditioning"] = xc + elif self.cond_stage_key == 'class_label': + xc = log_txt_as_img((x.shape[2], x.shape[3]), batch["human_label"], size=x.shape[2]//25) + log['conditioning'] = xc + elif isimage(xc): + log["conditioning"] = xc + if ismap(xc): + log["original_conditioning"] = self.to_rgb(xc) + + if sample: + # get denoise row + with ema_scope("Sampling"): + samples, z_denoise_row = self.sample_log(cond=c, batch_size=N, ddim=use_ddim, + ddim_steps=ddim_steps, eta=ddim_eta) + # samples, z_denoise_row = self.sample(cond=c, batch_size=N, return_intermediates=True) + x_samples = self.decode_first_stage(samples) + log["samples"] = x_samples + + if unconditional_guidance_scale > 1.0: + uc_tmp = self.get_unconditional_conditioning(N, unconditional_guidance_label) + uc = dict() + for k in c: + if k == "c_crossattn": + assert isinstance(c[k], list) and len(c[k]) == 1 + uc[k] = [uc_tmp] + elif isinstance(c[k], list): + uc[k] = [c[k][i] for i in range(len(c[k]))] + else: + uc[k] = c[k] + + with ema_scope("Sampling with classifier-free guidance"): + samples_cfg, _ = self.sample_log(cond=c, batch_size=N, ddim=use_ddim, + ddim_steps=ddim_steps, eta=ddim_eta, + unconditional_guidance_scale=unconditional_guidance_scale, + unconditional_conditioning=uc, + ) + x_samples_cfg = self.decode_first_stage(samples_cfg) + log[f"samples_cfg_scale_{unconditional_guidance_scale:.2f}"] = x_samples_cfg + return log + +class MultiCatFrameDiffusion(LatentDiffusion): + def __init__(self, *args, low_scale_key="LR", **kwargs): + super().__init__(*args, **kwargs) + # assumes that neither the cond_stage nor the low_scale_model contain trainable params + assert not self.cond_stage_trainable + self.low_scale_key = low_scale_key + + @torch.no_grad() + def get_input(self, batch, k, cond_key=None, bs=None, log_mode=False): + n = 2 + if not log_mode: + z, c = super().get_input(batch, k, force_c_encode=True, bs=bs) + else: + z, c, x, xrec, xc = super().get_input(batch, self.first_stage_key, return_first_stage_outputs=True, + force_c_encode=True, return_original_cond=True, bs=bs) + cat_conds = batch[self.low_scale_key][:bs] + cats = [] + for i in range(n): + x_low = cat_conds[:,:,:,3*i:3*(i+1)] + x_low = rearrange(x_low, 'b h w c -> b c h w') + x_low = x_low.to(memory_format=torch.contiguous_format).float() + encoder_posterior = self.encode_first_stage(x_low) + zx = self.get_first_stage_encoding(encoder_posterior).detach() + cats.append(zx) + + all_conds = {"c_concat": [torch.cat(cats, dim=1)], "c_crossattn": [c]} + + if log_mode: + # TODO: maybe disable if too expensive + interpretability = False + if interpretability: + zx = zx[:, :, ::2, ::2] + return z, all_conds, x, xrec, xc, x_low + return z, all_conds + + @torch.no_grad() + def log_images(self, batch, N=8, n_row=4, sample=True, ddim_steps=200, ddim_eta=1., return_keys=None, + plot_denoise_rows=False, plot_progressive_rows=True, plot_diffusion_rows=True, + unconditional_guidance_scale=1., unconditional_guidance_label=None, use_ema_scope=True, + **kwargs): + ema_scope = self.ema_scope if use_ema_scope else nullcontext + use_ddim = ddim_steps is not None + + log = dict() + z, c, x, xrec, xc, x_low = self.get_input(batch, self.first_stage_key, bs=N, log_mode=True) + N = min(x.shape[0], N) + n_row = min(x.shape[0], n_row) + log["inputs"] = x + log["reconstruction"] = xrec + log["x_lr"] = x_low + + if self.model.conditioning_key is not None: + if hasattr(self.cond_stage_model, "decode"): + xc = self.cond_stage_model.decode(c) + log["conditioning"] = xc + elif self.cond_stage_key in ["caption", "txt"]: + xc = log_txt_as_img((x.shape[2], x.shape[3]), batch[self.cond_stage_key], size=x.shape[2]//25) + log["conditioning"] = xc + elif self.cond_stage_key == 'class_label': + xc = log_txt_as_img((x.shape[2], x.shape[3]), batch["human_label"], size=x.shape[2]//25) + log['conditioning'] = xc + elif isimage(xc): + log["conditioning"] = xc + if ismap(xc): + log["original_conditioning"] = self.to_rgb(xc) + + if sample: + # get denoise row + with ema_scope("Sampling"): + samples, z_denoise_row = self.sample_log(cond=c, batch_size=N, ddim=use_ddim, + ddim_steps=ddim_steps, eta=ddim_eta) + # samples, z_denoise_row = self.sample(cond=c, batch_size=N, return_intermediates=True) + x_samples = self.decode_first_stage(samples) + log["samples"] = x_samples + + if unconditional_guidance_scale > 1.0: + uc_tmp = self.get_unconditional_conditioning(N, unconditional_guidance_label) + uc = dict() + for k in c: + if k == "c_crossattn": + assert isinstance(c[k], list) and len(c[k]) == 1 + uc[k] = [uc_tmp] + elif isinstance(c[k], list): + uc[k] = [c[k][i] for i in range(len(c[k]))] + else: + uc[k] = c[k] + + with ema_scope("Sampling with classifier-free guidance"): + samples_cfg, _ = self.sample_log(cond=c, batch_size=N, ddim=use_ddim, + ddim_steps=ddim_steps, eta=ddim_eta, + unconditional_guidance_scale=unconditional_guidance_scale, + unconditional_conditioning=uc, + ) + x_samples_cfg = self.decode_first_stage(samples_cfg) + log[f"samples_cfg_scale_{unconditional_guidance_scale:.2f}"] = x_samples_cfg + return log diff --git a/ldm/models/diffusion/plms.py b/ldm/models/diffusion/plms.py new file mode 100755 index 0000000..080edee --- /dev/null +++ b/ldm/models/diffusion/plms.py @@ -0,0 +1,259 @@ +"""SAMPLING ONLY.""" + +import torch +import numpy as np +from tqdm import tqdm +from functools import partial + +from ldm.modules.diffusionmodules.util import make_ddim_sampling_parameters, make_ddim_timesteps, noise_like +from ldm.models.diffusion.sampling_util import norm_thresholding + + +class PLMSSampler(object): + def __init__(self, model, schedule="linear", **kwargs): + super().__init__() + self.model = model + self.ddpm_num_timesteps = model.num_timesteps + self.schedule = schedule + + def register_buffer(self, name, attr): + if type(attr) == torch.Tensor: + if attr.device != torch.device("cuda"): + attr = attr.to(torch.device("cuda")) + setattr(self, name, attr) + + def make_schedule(self, ddim_num_steps, ddim_discretize="uniform", ddim_eta=0., verbose=True): + if ddim_eta != 0: + raise ValueError('ddim_eta must be 0 for PLMS') + self.ddim_timesteps = make_ddim_timesteps(ddim_discr_method=ddim_discretize, num_ddim_timesteps=ddim_num_steps, + num_ddpm_timesteps=self.ddpm_num_timesteps,verbose=verbose) + alphas_cumprod = self.model.alphas_cumprod + assert alphas_cumprod.shape[0] == self.ddpm_num_timesteps, 'alphas have to be defined for each timestep' + to_torch = lambda x: x.clone().detach().to(torch.float32).to(self.model.device) + + self.register_buffer('betas', to_torch(self.model.betas)) + self.register_buffer('alphas_cumprod', to_torch(alphas_cumprod)) + self.register_buffer('alphas_cumprod_prev', to_torch(self.model.alphas_cumprod_prev)) + + # calculations for diffusion q(x_t | x_{t-1}) and others + self.register_buffer('sqrt_alphas_cumprod', to_torch(np.sqrt(alphas_cumprod.cpu()))) + self.register_buffer('sqrt_one_minus_alphas_cumprod', to_torch(np.sqrt(1. - alphas_cumprod.cpu()))) + self.register_buffer('log_one_minus_alphas_cumprod', to_torch(np.log(1. - alphas_cumprod.cpu()))) + self.register_buffer('sqrt_recip_alphas_cumprod', to_torch(np.sqrt(1. / alphas_cumprod.cpu()))) + self.register_buffer('sqrt_recipm1_alphas_cumprod', to_torch(np.sqrt(1. / alphas_cumprod.cpu() - 1))) + + # ddim sampling parameters + ddim_sigmas, ddim_alphas, ddim_alphas_prev = make_ddim_sampling_parameters(alphacums=alphas_cumprod.cpu(), + ddim_timesteps=self.ddim_timesteps, + eta=ddim_eta,verbose=verbose) + self.register_buffer('ddim_sigmas', ddim_sigmas) + self.register_buffer('ddim_alphas', ddim_alphas) + self.register_buffer('ddim_alphas_prev', ddim_alphas_prev) + self.register_buffer('ddim_sqrt_one_minus_alphas', np.sqrt(1. - ddim_alphas)) + sigmas_for_original_sampling_steps = ddim_eta * torch.sqrt( + (1 - self.alphas_cumprod_prev) / (1 - self.alphas_cumprod) * ( + 1 - self.alphas_cumprod / self.alphas_cumprod_prev)) + self.register_buffer('ddim_sigmas_for_original_num_steps', sigmas_for_original_sampling_steps) + + @torch.no_grad() + def sample(self, + S, + batch_size, + shape, + conditioning=None, + callback=None, + normals_sequence=None, + img_callback=None, + quantize_x0=False, + eta=0., + mask=None, + x0=None, + temperature=1., + noise_dropout=0., + score_corrector=None, + corrector_kwargs=None, + verbose=True, + x_T=None, + log_every_t=100, + unconditional_guidance_scale=1., + unconditional_conditioning=None, + # this has to come in the same format as the conditioning, # e.g. as encoded tokens, ... + dynamic_threshold=None, + **kwargs + ): + if conditioning is not None: + if isinstance(conditioning, dict): + ctmp = conditioning[list(conditioning.keys())[0]] + while isinstance(ctmp, list): ctmp = ctmp[0] + cbs = ctmp.shape[0] + if cbs != batch_size: + print(f"Warning: Got {cbs} conditionings but batch-size is {batch_size}") + else: + if conditioning.shape[0] != batch_size: + print(f"Warning: Got {conditioning.shape[0]} conditionings but batch-size is {batch_size}") + + self.make_schedule(ddim_num_steps=S, ddim_eta=eta, verbose=verbose) + # sampling + C, H, W = shape + size = (batch_size, C, H, W) + print(f'Data shape for PLMS sampling is {size}') + + samples, intermediates = self.plms_sampling(conditioning, size, + callback=callback, + img_callback=img_callback, + quantize_denoised=quantize_x0, + mask=mask, x0=x0, + ddim_use_original_steps=False, + noise_dropout=noise_dropout, + temperature=temperature, + score_corrector=score_corrector, + corrector_kwargs=corrector_kwargs, + x_T=x_T, + log_every_t=log_every_t, + unconditional_guidance_scale=unconditional_guidance_scale, + unconditional_conditioning=unconditional_conditioning, + dynamic_threshold=dynamic_threshold, + ) + return samples, intermediates + + @torch.no_grad() + def plms_sampling(self, cond, shape, + x_T=None, ddim_use_original_steps=False, + callback=None, timesteps=None, quantize_denoised=False, + mask=None, x0=None, img_callback=None, log_every_t=100, + temperature=1., noise_dropout=0., score_corrector=None, corrector_kwargs=None, + unconditional_guidance_scale=1., unconditional_conditioning=None, + dynamic_threshold=None): + device = self.model.betas.device + b = shape[0] + if x_T is None: + img = torch.randn(shape, device=device) + else: + img = x_T + + if timesteps is None: + timesteps = self.ddpm_num_timesteps if ddim_use_original_steps else self.ddim_timesteps + elif timesteps is not None and not ddim_use_original_steps: + subset_end = int(min(timesteps / self.ddim_timesteps.shape[0], 1) * self.ddim_timesteps.shape[0]) - 1 + timesteps = self.ddim_timesteps[:subset_end] + + intermediates = {'x_inter': [img], 'pred_x0': [img]} + time_range = list(reversed(range(0,timesteps))) if ddim_use_original_steps else np.flip(timesteps) + total_steps = timesteps if ddim_use_original_steps else timesteps.shape[0] + print(f"Running PLMS Sampling with {total_steps} timesteps") + + iterator = tqdm(time_range, desc='PLMS Sampler', total=total_steps) + old_eps = [] + + for i, step in enumerate(iterator): + index = total_steps - i - 1 + ts = torch.full((b,), step, device=device, dtype=torch.long) + ts_next = torch.full((b,), time_range[min(i + 1, len(time_range) - 1)], device=device, dtype=torch.long) + + if mask is not None: + assert x0 is not None + img_orig = self.model.q_sample(x0, ts) # TODO: deterministic forward pass? + img = img_orig * mask + (1. - mask) * img + + outs = self.p_sample_plms(img, cond, ts, index=index, use_original_steps=ddim_use_original_steps, + quantize_denoised=quantize_denoised, temperature=temperature, + noise_dropout=noise_dropout, score_corrector=score_corrector, + corrector_kwargs=corrector_kwargs, + unconditional_guidance_scale=unconditional_guidance_scale, + unconditional_conditioning=unconditional_conditioning, + old_eps=old_eps, t_next=ts_next, + dynamic_threshold=dynamic_threshold) + img, pred_x0, e_t = outs + old_eps.append(e_t) + if len(old_eps) >= 4: + old_eps.pop(0) + if callback: callback(i) + if img_callback: img_callback(pred_x0, i) + + if index % log_every_t == 0 or index == total_steps - 1: + intermediates['x_inter'].append(img) + intermediates['pred_x0'].append(pred_x0) + + return img, intermediates + + @torch.no_grad() + def p_sample_plms(self, x, c, t, index, repeat_noise=False, use_original_steps=False, quantize_denoised=False, + temperature=1., noise_dropout=0., score_corrector=None, corrector_kwargs=None, + unconditional_guidance_scale=1., unconditional_conditioning=None, old_eps=None, t_next=None, + dynamic_threshold=None): + b, *_, device = *x.shape, x.device + + def get_model_output(x, t): + if unconditional_conditioning is None or unconditional_guidance_scale == 1.: + e_t = self.model.apply_model(x, t, c) + else: + x_in = torch.cat([x] * 2) + t_in = torch.cat([t] * 2) + if isinstance(c, dict): + assert isinstance(unconditional_conditioning, dict) + c_in = dict() + for k in c: + if isinstance(c[k], list): + c_in[k] = [torch.cat([ + unconditional_conditioning[k][i], + c[k][i]]) for i in range(len(c[k]))] + else: + c_in[k] = torch.cat([ + unconditional_conditioning[k], + c[k]]) + else: + c_in = torch.cat([unconditional_conditioning, c]) + e_t_uncond, e_t = self.model.apply_model(x_in, t_in, c_in).chunk(2) + e_t = e_t_uncond + unconditional_guidance_scale * (e_t - e_t_uncond) + + if score_corrector is not None: + assert self.model.parameterization == "eps" + e_t = score_corrector.modify_score(self.model, e_t, x, t, c, **corrector_kwargs) + + return e_t + + alphas = self.model.alphas_cumprod if use_original_steps else self.ddim_alphas + alphas_prev = self.model.alphas_cumprod_prev if use_original_steps else self.ddim_alphas_prev + sqrt_one_minus_alphas = self.model.sqrt_one_minus_alphas_cumprod if use_original_steps else self.ddim_sqrt_one_minus_alphas + sigmas = self.model.ddim_sigmas_for_original_num_steps if use_original_steps else self.ddim_sigmas + + def get_x_prev_and_pred_x0(e_t, index): + # select parameters corresponding to the currently considered timestep + a_t = torch.full((b, 1, 1, 1), alphas[index], device=device) + a_prev = torch.full((b, 1, 1, 1), alphas_prev[index], device=device) + sigma_t = torch.full((b, 1, 1, 1), sigmas[index], device=device) + sqrt_one_minus_at = torch.full((b, 1, 1, 1), sqrt_one_minus_alphas[index],device=device) + + # current prediction for x_0 + pred_x0 = (x - sqrt_one_minus_at * e_t) / a_t.sqrt() + if quantize_denoised: + pred_x0, _, *_ = self.model.first_stage_model.quantize(pred_x0) + if dynamic_threshold is not None: + pred_x0 = norm_thresholding(pred_x0, dynamic_threshold) + # direction pointing to x_t + dir_xt = (1. - a_prev - sigma_t**2).sqrt() * e_t + noise = sigma_t * noise_like(x.shape, device, repeat_noise) * temperature + if noise_dropout > 0.: + noise = torch.nn.functional.dropout(noise, p=noise_dropout) + x_prev = a_prev.sqrt() * pred_x0 + dir_xt + noise + return x_prev, pred_x0 + + e_t = get_model_output(x, t) + if len(old_eps) == 0: + # Pseudo Improved Euler (2nd order) + x_prev, pred_x0 = get_x_prev_and_pred_x0(e_t, index) + e_t_next = get_model_output(x_prev, t_next) + e_t_prime = (e_t + e_t_next) / 2 + elif len(old_eps) == 1: + # 2nd order Pseudo Linear Multistep (Adams-Bashforth) + e_t_prime = (3 * e_t - old_eps[-1]) / 2 + elif len(old_eps) == 2: + # 3nd order Pseudo Linear Multistep (Adams-Bashforth) + e_t_prime = (23 * e_t - 16 * old_eps[-1] + 5 * old_eps[-2]) / 12 + elif len(old_eps) >= 3: + # 4nd order Pseudo Linear Multistep (Adams-Bashforth) + e_t_prime = (55 * e_t - 59 * old_eps[-1] + 37 * old_eps[-2] - 9 * old_eps[-3]) / 24 + + x_prev, pred_x0 = get_x_prev_and_pred_x0(e_t_prime, index) + + return x_prev, pred_x0, e_t diff --git a/ldm/models/diffusion/sampling_util.py b/ldm/models/diffusion/sampling_util.py new file mode 100755 index 0000000..a0ae00f --- /dev/null +++ b/ldm/models/diffusion/sampling_util.py @@ -0,0 +1,50 @@ +import torch +import numpy as np + + +def append_dims(x, target_dims): + """Appends dimensions to the end of a tensor until it has target_dims dimensions. + From https://github.com/crowsonkb/k-diffusion/blob/master/k_diffusion/utils.py""" + dims_to_append = target_dims - x.ndim + if dims_to_append < 0: + raise ValueError(f'input has {x.ndim} dims but target_dims is {target_dims}, which is less') + return x[(...,) + (None,) * dims_to_append] + + +def renorm_thresholding(x0, value): + # renorm + pred_max = x0.max() + pred_min = x0.min() + pred_x0 = (x0 - pred_min) / (pred_max - pred_min) # 0 ... 1 + pred_x0 = 2 * pred_x0 - 1. # -1 ... 1 + + s = torch.quantile( + rearrange(pred_x0, 'b ... -> b (...)').abs(), + value, + dim=-1 + ) + s.clamp_(min=1.0) + s = s.view(-1, *((1,) * (pred_x0.ndim - 1))) + + # clip by threshold + # pred_x0 = pred_x0.clamp(-s, s) / s # needs newer pytorch # TODO bring back to pure-gpu with min/max + + # temporary hack: numpy on cpu + pred_x0 = np.clip(pred_x0.cpu().numpy(), -s.cpu().numpy(), s.cpu().numpy()) / s.cpu().numpy() + pred_x0 = torch.tensor(pred_x0).to(self.model.device) + + # re.renorm + pred_x0 = (pred_x0 + 1.) / 2. # 0 ... 1 + pred_x0 = (pred_max - pred_min) * pred_x0 + pred_min # orig range + return pred_x0 + + +def norm_thresholding(x0, value): + s = append_dims(x0.pow(2).flatten(1).mean(1).sqrt().clamp(min=value), x0.ndim) + return x0 * (value / s) + + +def spatial_norm_thresholding(x0, value): + # b c h w + s = x0.pow(2).mean(1, keepdim=True).sqrt().clamp(min=value) + return x0 * (value / s) \ No newline at end of file diff --git a/ldm/modules/attention.py b/ldm/modules/attention.py new file mode 100755 index 0000000..124effb --- /dev/null +++ b/ldm/modules/attention.py @@ -0,0 +1,266 @@ +from inspect import isfunction +import math +import torch +import torch.nn.functional as F +from torch import nn, einsum +from einops import rearrange, repeat + +from ldm.modules.diffusionmodules.util import checkpoint + + +def exists(val): + return val is not None + + +def uniq(arr): + return{el: True for el in arr}.keys() + + +def default(val, d): + if exists(val): + return val + return d() if isfunction(d) else d + + +def max_neg_value(t): + return -torch.finfo(t.dtype).max + + +def init_(tensor): + dim = tensor.shape[-1] + std = 1 / math.sqrt(dim) + tensor.uniform_(-std, std) + return tensor + + +# feedforward +class GEGLU(nn.Module): + def __init__(self, dim_in, dim_out): + super().__init__() + self.proj = nn.Linear(dim_in, dim_out * 2) + + def forward(self, x): + x, gate = self.proj(x).chunk(2, dim=-1) + return x * F.gelu(gate) + + +class FeedForward(nn.Module): + def __init__(self, dim, dim_out=None, mult=4, glu=False, dropout=0.): + super().__init__() + inner_dim = int(dim * mult) + dim_out = default(dim_out, dim) + project_in = nn.Sequential( + nn.Linear(dim, inner_dim), + nn.GELU() + ) if not glu else GEGLU(dim, inner_dim) + + self.net = nn.Sequential( + project_in, + nn.Dropout(dropout), + nn.Linear(inner_dim, dim_out) + ) + + def forward(self, x): + return self.net(x) + + +def zero_module(module): + """ + Zero out the parameters of a module and return it. + """ + for p in module.parameters(): + p.detach().zero_() + return module + + +def Normalize(in_channels): + return torch.nn.GroupNorm(num_groups=32, num_channels=in_channels, eps=1e-6, affine=True) + + +class LinearAttention(nn.Module): + def __init__(self, dim, heads=4, dim_head=32): + super().__init__() + self.heads = heads + hidden_dim = dim_head * heads + self.to_qkv = nn.Conv2d(dim, hidden_dim * 3, 1, bias = False) + self.to_out = nn.Conv2d(hidden_dim, dim, 1) + + def forward(self, x): + b, c, h, w = x.shape + qkv = self.to_qkv(x) + q, k, v = rearrange(qkv, 'b (qkv heads c) h w -> qkv b heads c (h w)', heads = self.heads, qkv=3) + k = k.softmax(dim=-1) + context = torch.einsum('bhdn,bhen->bhde', k, v) + out = torch.einsum('bhde,bhdn->bhen', context, q) + out = rearrange(out, 'b heads c (h w) -> b (heads c) h w', heads=self.heads, h=h, w=w) + return self.to_out(out) + + +class SpatialSelfAttention(nn.Module): + def __init__(self, in_channels): + super().__init__() + self.in_channels = in_channels + + self.norm = Normalize(in_channels) + self.q = torch.nn.Conv2d(in_channels, + in_channels, + kernel_size=1, + stride=1, + padding=0) + self.k = torch.nn.Conv2d(in_channels, + in_channels, + kernel_size=1, + stride=1, + padding=0) + self.v = torch.nn.Conv2d(in_channels, + in_channels, + kernel_size=1, + stride=1, + padding=0) + self.proj_out = torch.nn.Conv2d(in_channels, + in_channels, + kernel_size=1, + stride=1, + padding=0) + + def forward(self, x): + h_ = x + h_ = self.norm(h_) + q = self.q(h_) + k = self.k(h_) + v = self.v(h_) + + # compute attention + b,c,h,w = q.shape + q = rearrange(q, 'b c h w -> b (h w) c') + k = rearrange(k, 'b c h w -> b c (h w)') + w_ = torch.einsum('bij,bjk->bik', q, k) + + w_ = w_ * (int(c)**(-0.5)) + w_ = torch.nn.functional.softmax(w_, dim=2) + + # attend to values + v = rearrange(v, 'b c h w -> b c (h w)') + w_ = rearrange(w_, 'b i j -> b j i') + h_ = torch.einsum('bij,bjk->bik', v, w_) + h_ = rearrange(h_, 'b c (h w) -> b c h w', h=h) + h_ = self.proj_out(h_) + + return x+h_ + + +class CrossAttention(nn.Module): + def __init__(self, query_dim, context_dim=None, heads=8, dim_head=64, dropout=0.): + super().__init__() + inner_dim = dim_head * heads + context_dim = default(context_dim, query_dim) + + self.scale = dim_head ** -0.5 + self.heads = heads + + self.to_q = nn.Linear(query_dim, inner_dim, bias=False) + self.to_k = nn.Linear(context_dim, inner_dim, bias=False) + self.to_v = nn.Linear(context_dim, inner_dim, bias=False) + + self.to_out = nn.Sequential( + nn.Linear(inner_dim, query_dim), + nn.Dropout(dropout) + ) + + def forward(self, x, context=None, mask=None): + h = self.heads + + q = self.to_q(x) + context = default(context, x) + k = self.to_k(context) + v = self.to_v(context) + + q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> (b h) n d', h=h), (q, k, v)) + + sim = einsum('b i d, b j d -> b i j', q, k) * self.scale + + if exists(mask): + mask = rearrange(mask, 'b ... -> b (...)') + max_neg_value = -torch.finfo(sim.dtype).max + mask = repeat(mask, 'b j -> (b h) () j', h=h) + sim.masked_fill_(~mask, max_neg_value) + + # attention, what we cannot get enough of + attn = sim.softmax(dim=-1) + + out = einsum('b i j, b j d -> b i d', attn, v) + out = rearrange(out, '(b h) n d -> b n (h d)', h=h) + return self.to_out(out) + + +class BasicTransformerBlock(nn.Module): + def __init__(self, dim, n_heads, d_head, dropout=0., context_dim=None, gated_ff=True, checkpoint=True, + disable_self_attn=False): + super().__init__() + self.disable_self_attn = disable_self_attn + self.attn1 = CrossAttention(query_dim=dim, heads=n_heads, dim_head=d_head, dropout=dropout, + context_dim=context_dim if self.disable_self_attn else None) # is a self-attention if not self.disable_self_attn + self.ff = FeedForward(dim, dropout=dropout, glu=gated_ff) + self.attn2 = CrossAttention(query_dim=dim, context_dim=context_dim, + heads=n_heads, dim_head=d_head, dropout=dropout) # is self-attn if context is none + self.norm1 = nn.LayerNorm(dim) + self.norm2 = nn.LayerNorm(dim) + self.norm3 = nn.LayerNorm(dim) + self.checkpoint = checkpoint + + def forward(self, x, context=None): + return checkpoint(self._forward, (x, context), self.parameters(), self.checkpoint) + + def _forward(self, x, context=None): + x = self.attn1(self.norm1(x), context=context if self.disable_self_attn else None) + x + x = self.attn2(self.norm2(x), context=context) + x + x = self.ff(self.norm3(x)) + x + return x + + +class SpatialTransformer(nn.Module): + """ + Transformer block for image-like data. + First, project the input (aka embedding) + and reshape to b, t, d. + Then apply standard transformer action. + Finally, reshape to image + """ + def __init__(self, in_channels, n_heads, d_head, + depth=1, dropout=0., context_dim=None, + disable_self_attn=False): + super().__init__() + self.in_channels = in_channels + inner_dim = n_heads * d_head + self.norm = Normalize(in_channels) + + self.proj_in = nn.Conv2d(in_channels, + inner_dim, + kernel_size=1, + stride=1, + padding=0) + + self.transformer_blocks = nn.ModuleList( + [BasicTransformerBlock(inner_dim, n_heads, d_head, dropout=dropout, context_dim=context_dim, + disable_self_attn=disable_self_attn) + for d in range(depth)] + ) + + self.proj_out = zero_module(nn.Conv2d(inner_dim, + in_channels, + kernel_size=1, + stride=1, + padding=0)) + + def forward(self, x, context=None): + # note: if no context is given, cross-attention defaults to self-attention + b, c, h, w = x.shape + x_in = x + x = self.norm(x) + x = self.proj_in(x) + x = rearrange(x, 'b c h w -> b (h w) c').contiguous() + for block in self.transformer_blocks: + x = block(x, context=context) + x = rearrange(x, 'b (h w) c -> b c h w', h=h, w=w).contiguous() + x = self.proj_out(x) + return x + x_in diff --git a/ldm/modules/diffusionmodules/__init__.py b/ldm/modules/diffusionmodules/__init__.py new file mode 100755 index 0000000..e69de29 diff --git a/ldm/modules/diffusionmodules/model.py b/ldm/modules/diffusionmodules/model.py new file mode 100755 index 0000000..533e589 --- /dev/null +++ b/ldm/modules/diffusionmodules/model.py @@ -0,0 +1,835 @@ +# pytorch_diffusion + derived encoder decoder +import math +import torch +import torch.nn as nn +import numpy as np +from einops import rearrange + +from ldm.util import instantiate_from_config +from ldm.modules.attention import LinearAttention + + +def get_timestep_embedding(timesteps, embedding_dim): + """ + This matches the implementation in Denoising Diffusion Probabilistic Models: + From Fairseq. + Build sinusoidal embeddings. + This matches the implementation in tensor2tensor, but differs slightly + from the description in Section 3.5 of "Attention Is All You Need". + """ + assert len(timesteps.shape) == 1 + + half_dim = embedding_dim // 2 + emb = math.log(10000) / (half_dim - 1) + emb = torch.exp(torch.arange(half_dim, dtype=torch.float32) * -emb) + emb = emb.to(device=timesteps.device) + emb = timesteps.float()[:, None] * emb[None, :] + emb = torch.cat([torch.sin(emb), torch.cos(emb)], dim=1) + if embedding_dim % 2 == 1: # zero pad + emb = torch.nn.functional.pad(emb, (0,1,0,0)) + return emb + + +def nonlinearity(x): + # swish + return x*torch.sigmoid(x) + + +def Normalize(in_channels, num_groups=32): + return torch.nn.GroupNorm(num_groups=num_groups, num_channels=in_channels, eps=1e-6, affine=True) + + +class Upsample(nn.Module): + def __init__(self, in_channels, with_conv): + super().__init__() + self.with_conv = with_conv + if self.with_conv: + self.conv = torch.nn.Conv2d(in_channels, + in_channels, + kernel_size=3, + stride=1, + padding=1) + + def forward(self, x): + x = torch.nn.functional.interpolate(x, scale_factor=2.0, mode="nearest") + if self.with_conv: + x = self.conv(x) + return x + + +class Downsample(nn.Module): + def __init__(self, in_channels, with_conv): + super().__init__() + self.with_conv = with_conv + if self.with_conv: + # no asymmetric padding in torch conv, must do it ourselves + self.conv = torch.nn.Conv2d(in_channels, + in_channels, + kernel_size=3, + stride=2, + padding=0) + + def forward(self, x): + if self.with_conv: + pad = (0,1,0,1) + x = torch.nn.functional.pad(x, pad, mode="constant", value=0) + x = self.conv(x) + else: + x = torch.nn.functional.avg_pool2d(x, kernel_size=2, stride=2) + return x + + +class ResnetBlock(nn.Module): + def __init__(self, *, in_channels, out_channels=None, conv_shortcut=False, + dropout, temb_channels=512): + super().__init__() + self.in_channels = in_channels + out_channels = in_channels if out_channels is None else out_channels + self.out_channels = out_channels + self.use_conv_shortcut = conv_shortcut + + self.norm1 = Normalize(in_channels) + self.conv1 = torch.nn.Conv2d(in_channels, + out_channels, + kernel_size=3, + stride=1, + padding=1) + if temb_channels > 0: + self.temb_proj = torch.nn.Linear(temb_channels, + out_channels) + self.norm2 = Normalize(out_channels) + self.dropout = torch.nn.Dropout(dropout) + self.conv2 = torch.nn.Conv2d(out_channels, + out_channels, + kernel_size=3, + stride=1, + padding=1) + if self.in_channels != self.out_channels: + if self.use_conv_shortcut: + self.conv_shortcut = torch.nn.Conv2d(in_channels, + out_channels, + kernel_size=3, + stride=1, + padding=1) + else: + self.nin_shortcut = torch.nn.Conv2d(in_channels, + out_channels, + kernel_size=1, + stride=1, + padding=0) + + def forward(self, x, temb): + h = x + h = self.norm1(h) + h = nonlinearity(h) + h = self.conv1(h) + + if temb is not None: + h = h + self.temb_proj(nonlinearity(temb))[:,:,None,None] + + h = self.norm2(h) + h = nonlinearity(h) + h = self.dropout(h) + h = self.conv2(h) + + if self.in_channels != self.out_channels: + if self.use_conv_shortcut: + x = self.conv_shortcut(x) + else: + x = self.nin_shortcut(x) + + return x+h + + +class LinAttnBlock(LinearAttention): + """to match AttnBlock usage""" + def __init__(self, in_channels): + super().__init__(dim=in_channels, heads=1, dim_head=in_channels) + + +class AttnBlock(nn.Module): + def __init__(self, in_channels): + super().__init__() + self.in_channels = in_channels + + self.norm = Normalize(in_channels) + self.q = torch.nn.Conv2d(in_channels, + in_channels, + kernel_size=1, + stride=1, + padding=0) + self.k = torch.nn.Conv2d(in_channels, + in_channels, + kernel_size=1, + stride=1, + padding=0) + self.v = torch.nn.Conv2d(in_channels, + in_channels, + kernel_size=1, + stride=1, + padding=0) + self.proj_out = torch.nn.Conv2d(in_channels, + in_channels, + kernel_size=1, + stride=1, + padding=0) + + + def forward(self, x): + h_ = x + h_ = self.norm(h_) + q = self.q(h_) + k = self.k(h_) + v = self.v(h_) + + # compute attention + b,c,h,w = q.shape + q = q.reshape(b,c,h*w) + q = q.permute(0,2,1) # b,hw,c + k = k.reshape(b,c,h*w) # b,c,hw + w_ = torch.bmm(q,k) # b,hw,hw w[b,i,j]=sum_c q[b,i,c]k[b,c,j] + w_ = w_ * (int(c)**(-0.5)) + w_ = torch.nn.functional.softmax(w_, dim=2) + + # attend to values + v = v.reshape(b,c,h*w) + w_ = w_.permute(0,2,1) # b,hw,hw (first hw of k, second of q) + h_ = torch.bmm(v,w_) # b, c,hw (hw of q) h_[b,c,j] = sum_i v[b,c,i] w_[b,i,j] + h_ = h_.reshape(b,c,h,w) + + h_ = self.proj_out(h_) + + return x+h_ + + +def make_attn(in_channels, attn_type="vanilla"): + assert attn_type in ["vanilla", "linear", "none"], f'attn_type {attn_type} unknown' + print(f"making attention of type '{attn_type}' with {in_channels} in_channels") + if attn_type == "vanilla": + return AttnBlock(in_channels) + elif attn_type == "none": + return nn.Identity(in_channels) + else: + return LinAttnBlock(in_channels) + + +class Model(nn.Module): + def __init__(self, *, ch, out_ch, ch_mult=(1,2,4,8), num_res_blocks, + attn_resolutions, dropout=0.0, resamp_with_conv=True, in_channels, + resolution, use_timestep=True, use_linear_attn=False, attn_type="vanilla"): + super().__init__() + if use_linear_attn: attn_type = "linear" + self.ch = ch + self.temb_ch = self.ch*4 + self.num_resolutions = len(ch_mult) + self.num_res_blocks = num_res_blocks + self.resolution = resolution + self.in_channels = in_channels + + self.use_timestep = use_timestep + if self.use_timestep: + # timestep embedding + self.temb = nn.Module() + self.temb.dense = nn.ModuleList([ + torch.nn.Linear(self.ch, + self.temb_ch), + torch.nn.Linear(self.temb_ch, + self.temb_ch), + ]) + + # downsampling + self.conv_in = torch.nn.Conv2d(in_channels, + self.ch, + kernel_size=3, + stride=1, + padding=1) + + curr_res = resolution + in_ch_mult = (1,)+tuple(ch_mult) + self.down = nn.ModuleList() + for i_level in range(self.num_resolutions): + block = nn.ModuleList() + attn = nn.ModuleList() + block_in = ch*in_ch_mult[i_level] + block_out = ch*ch_mult[i_level] + for i_block in range(self.num_res_blocks): + block.append(ResnetBlock(in_channels=block_in, + out_channels=block_out, + temb_channels=self.temb_ch, + dropout=dropout)) + block_in = block_out + if curr_res in attn_resolutions: + attn.append(make_attn(block_in, attn_type=attn_type)) + down = nn.Module() + down.block = block + down.attn = attn + if i_level != self.num_resolutions-1: + down.downsample = Downsample(block_in, resamp_with_conv) + curr_res = curr_res // 2 + self.down.append(down) + + # middle + self.mid = nn.Module() + self.mid.block_1 = ResnetBlock(in_channels=block_in, + out_channels=block_in, + temb_channels=self.temb_ch, + dropout=dropout) + self.mid.attn_1 = make_attn(block_in, attn_type=attn_type) + self.mid.block_2 = ResnetBlock(in_channels=block_in, + out_channels=block_in, + temb_channels=self.temb_ch, + dropout=dropout) + + # upsampling + self.up = nn.ModuleList() + for i_level in reversed(range(self.num_resolutions)): + block = nn.ModuleList() + attn = nn.ModuleList() + block_out = ch*ch_mult[i_level] + skip_in = ch*ch_mult[i_level] + for i_block in range(self.num_res_blocks+1): + if i_block == self.num_res_blocks: + skip_in = ch*in_ch_mult[i_level] + block.append(ResnetBlock(in_channels=block_in+skip_in, + out_channels=block_out, + temb_channels=self.temb_ch, + dropout=dropout)) + block_in = block_out + if curr_res in attn_resolutions: + attn.append(make_attn(block_in, attn_type=attn_type)) + up = nn.Module() + up.block = block + up.attn = attn + if i_level != 0: + up.upsample = Upsample(block_in, resamp_with_conv) + curr_res = curr_res * 2 + self.up.insert(0, up) # prepend to get consistent order + + # end + self.norm_out = Normalize(block_in) + self.conv_out = torch.nn.Conv2d(block_in, + out_ch, + kernel_size=3, + stride=1, + padding=1) + + def forward(self, x, t=None, context=None): + #assert x.shape[2] == x.shape[3] == self.resolution + if context is not None: + # assume aligned context, cat along channel axis + x = torch.cat((x, context), dim=1) + if self.use_timestep: + # timestep embedding + assert t is not None + temb = get_timestep_embedding(t, self.ch) + temb = self.temb.dense[0](temb) + temb = nonlinearity(temb) + temb = self.temb.dense[1](temb) + else: + temb = None + + # downsampling + hs = [self.conv_in(x)] + for i_level in range(self.num_resolutions): + for i_block in range(self.num_res_blocks): + h = self.down[i_level].block[i_block](hs[-1], temb) + if len(self.down[i_level].attn) > 0: + h = self.down[i_level].attn[i_block](h) + hs.append(h) + if i_level != self.num_resolutions-1: + hs.append(self.down[i_level].downsample(hs[-1])) + + # middle + h = hs[-1] + h = self.mid.block_1(h, temb) + h = self.mid.attn_1(h) + h = self.mid.block_2(h, temb) + + # upsampling + for i_level in reversed(range(self.num_resolutions)): + for i_block in range(self.num_res_blocks+1): + h = self.up[i_level].block[i_block]( + torch.cat([h, hs.pop()], dim=1), temb) + if len(self.up[i_level].attn) > 0: + h = self.up[i_level].attn[i_block](h) + if i_level != 0: + h = self.up[i_level].upsample(h) + + # end + h = self.norm_out(h) + h = nonlinearity(h) + h = self.conv_out(h) + return h + + def get_last_layer(self): + return self.conv_out.weight + + +class Encoder(nn.Module): + def __init__(self, *, ch, out_ch, ch_mult=(1,2,4,8), num_res_blocks, + attn_resolutions, dropout=0.0, resamp_with_conv=True, in_channels, + resolution, z_channels, double_z=True, use_linear_attn=False, attn_type="vanilla", + **ignore_kwargs): + super().__init__() + if use_linear_attn: attn_type = "linear" + self.ch = ch + self.temb_ch = 0 + self.num_resolutions = len(ch_mult) + self.num_res_blocks = num_res_blocks + self.resolution = resolution + self.in_channels = in_channels + + # downsampling + self.conv_in = torch.nn.Conv2d(in_channels, + self.ch, + kernel_size=3, + stride=1, + padding=1) + + curr_res = resolution + in_ch_mult = (1,)+tuple(ch_mult) + self.in_ch_mult = in_ch_mult + self.down = nn.ModuleList() + for i_level in range(self.num_resolutions): + block = nn.ModuleList() + attn = nn.ModuleList() + block_in = ch*in_ch_mult[i_level] + block_out = ch*ch_mult[i_level] + for i_block in range(self.num_res_blocks): + block.append(ResnetBlock(in_channels=block_in, + out_channels=block_out, + temb_channels=self.temb_ch, + dropout=dropout)) + block_in = block_out + if curr_res in attn_resolutions: + attn.append(make_attn(block_in, attn_type=attn_type)) + down = nn.Module() + down.block = block + down.attn = attn + if i_level != self.num_resolutions-1: + down.downsample = Downsample(block_in, resamp_with_conv) + curr_res = curr_res // 2 + self.down.append(down) + + # middle + self.mid = nn.Module() + self.mid.block_1 = ResnetBlock(in_channels=block_in, + out_channels=block_in, + temb_channels=self.temb_ch, + dropout=dropout) + self.mid.attn_1 = make_attn(block_in, attn_type=attn_type) + self.mid.block_2 = ResnetBlock(in_channels=block_in, + out_channels=block_in, + temb_channels=self.temb_ch, + dropout=dropout) + + # end + self.norm_out = Normalize(block_in) + self.conv_out = torch.nn.Conv2d(block_in, + 2*z_channels if double_z else z_channels, + kernel_size=3, + stride=1, + padding=1) + + def forward(self, x): + # timestep embedding + temb = None + + # downsampling + hs = [self.conv_in(x)] + for i_level in range(self.num_resolutions): + for i_block in range(self.num_res_blocks): + h = self.down[i_level].block[i_block](hs[-1], temb) + if len(self.down[i_level].attn) > 0: + h = self.down[i_level].attn[i_block](h) + hs.append(h) + if i_level != self.num_resolutions-1: + hs.append(self.down[i_level].downsample(hs[-1])) + + # middle + h = hs[-1] + h = self.mid.block_1(h, temb) + h = self.mid.attn_1(h) + h = self.mid.block_2(h, temb) + + # end + h = self.norm_out(h) + h = nonlinearity(h) + h = self.conv_out(h) + return h + + +class Decoder(nn.Module): + def __init__(self, *, ch, out_ch, ch_mult=(1,2,4,8), num_res_blocks, + attn_resolutions, dropout=0.0, resamp_with_conv=True, in_channels, + resolution, z_channels, give_pre_end=False, tanh_out=False, use_linear_attn=False, + attn_type="vanilla", **ignorekwargs): + super().__init__() + if use_linear_attn: attn_type = "linear" + self.ch = ch + self.temb_ch = 0 + self.num_resolutions = len(ch_mult) + self.num_res_blocks = num_res_blocks + self.resolution = resolution + self.in_channels = in_channels + self.give_pre_end = give_pre_end + self.tanh_out = tanh_out + + # compute in_ch_mult, block_in and curr_res at lowest res + in_ch_mult = (1,)+tuple(ch_mult) + block_in = ch*ch_mult[self.num_resolutions-1] + curr_res = resolution // 2**(self.num_resolutions-1) + self.z_shape = (1,z_channels,curr_res,curr_res) + print("Working with z of shape {} = {} dimensions.".format( + self.z_shape, np.prod(self.z_shape))) + + # z to block_in + self.conv_in = torch.nn.Conv2d(z_channels, + block_in, + kernel_size=3, + stride=1, + padding=1) + + # middle + self.mid = nn.Module() + self.mid.block_1 = ResnetBlock(in_channels=block_in, + out_channels=block_in, + temb_channels=self.temb_ch, + dropout=dropout) + self.mid.attn_1 = make_attn(block_in, attn_type=attn_type) + self.mid.block_2 = ResnetBlock(in_channels=block_in, + out_channels=block_in, + temb_channels=self.temb_ch, + dropout=dropout) + + # upsampling + self.up = nn.ModuleList() + for i_level in reversed(range(self.num_resolutions)): + block = nn.ModuleList() + attn = nn.ModuleList() + block_out = ch*ch_mult[i_level] + for i_block in range(self.num_res_blocks+1): + block.append(ResnetBlock(in_channels=block_in, + out_channels=block_out, + temb_channels=self.temb_ch, + dropout=dropout)) + block_in = block_out + if curr_res in attn_resolutions: + attn.append(make_attn(block_in, attn_type=attn_type)) + up = nn.Module() + up.block = block + up.attn = attn + if i_level != 0: + up.upsample = Upsample(block_in, resamp_with_conv) + curr_res = curr_res * 2 + self.up.insert(0, up) # prepend to get consistent order + + # end + self.norm_out = Normalize(block_in) + self.conv_out = torch.nn.Conv2d(block_in, + out_ch, + kernel_size=3, + stride=1, + padding=1) + + def forward(self, z): + #assert z.shape[1:] == self.z_shape[1:] + self.last_z_shape = z.shape + + # timestep embedding + temb = None + + # z to block_in + h = self.conv_in(z) + + # middle + h = self.mid.block_1(h, temb) + h = self.mid.attn_1(h) + h = self.mid.block_2(h, temb) + + # upsampling + for i_level in reversed(range(self.num_resolutions)): + for i_block in range(self.num_res_blocks+1): + h = self.up[i_level].block[i_block](h, temb) + if len(self.up[i_level].attn) > 0: + h = self.up[i_level].attn[i_block](h) + if i_level != 0: + h = self.up[i_level].upsample(h) + + # end + if self.give_pre_end: + return h + + h = self.norm_out(h) + h = nonlinearity(h) + h = self.conv_out(h) + if self.tanh_out: + h = torch.tanh(h) + return h + + +class SimpleDecoder(nn.Module): + def __init__(self, in_channels, out_channels, *args, **kwargs): + super().__init__() + self.model = nn.ModuleList([nn.Conv2d(in_channels, in_channels, 1), + ResnetBlock(in_channels=in_channels, + out_channels=2 * in_channels, + temb_channels=0, dropout=0.0), + ResnetBlock(in_channels=2 * in_channels, + out_channels=4 * in_channels, + temb_channels=0, dropout=0.0), + ResnetBlock(in_channels=4 * in_channels, + out_channels=2 * in_channels, + temb_channels=0, dropout=0.0), + nn.Conv2d(2*in_channels, in_channels, 1), + Upsample(in_channels, with_conv=True)]) + # end + self.norm_out = Normalize(in_channels) + self.conv_out = torch.nn.Conv2d(in_channels, + out_channels, + kernel_size=3, + stride=1, + padding=1) + + def forward(self, x): + for i, layer in enumerate(self.model): + if i in [1,2,3]: + x = layer(x, None) + else: + x = layer(x) + + h = self.norm_out(x) + h = nonlinearity(h) + x = self.conv_out(h) + return x + + +class UpsampleDecoder(nn.Module): + def __init__(self, in_channels, out_channels, ch, num_res_blocks, resolution, + ch_mult=(2,2), dropout=0.0): + super().__init__() + # upsampling + self.temb_ch = 0 + self.num_resolutions = len(ch_mult) + self.num_res_blocks = num_res_blocks + block_in = in_channels + curr_res = resolution // 2 ** (self.num_resolutions - 1) + self.res_blocks = nn.ModuleList() + self.upsample_blocks = nn.ModuleList() + for i_level in range(self.num_resolutions): + res_block = [] + block_out = ch * ch_mult[i_level] + for i_block in range(self.num_res_blocks + 1): + res_block.append(ResnetBlock(in_channels=block_in, + out_channels=block_out, + temb_channels=self.temb_ch, + dropout=dropout)) + block_in = block_out + self.res_blocks.append(nn.ModuleList(res_block)) + if i_level != self.num_resolutions - 1: + self.upsample_blocks.append(Upsample(block_in, True)) + curr_res = curr_res * 2 + + # end + self.norm_out = Normalize(block_in) + self.conv_out = torch.nn.Conv2d(block_in, + out_channels, + kernel_size=3, + stride=1, + padding=1) + + def forward(self, x): + # upsampling + h = x + for k, i_level in enumerate(range(self.num_resolutions)): + for i_block in range(self.num_res_blocks + 1): + h = self.res_blocks[i_level][i_block](h, None) + if i_level != self.num_resolutions - 1: + h = self.upsample_blocks[k](h) + h = self.norm_out(h) + h = nonlinearity(h) + h = self.conv_out(h) + return h + + +class LatentRescaler(nn.Module): + def __init__(self, factor, in_channels, mid_channels, out_channels, depth=2): + super().__init__() + # residual block, interpolate, residual block + self.factor = factor + self.conv_in = nn.Conv2d(in_channels, + mid_channels, + kernel_size=3, + stride=1, + padding=1) + self.res_block1 = nn.ModuleList([ResnetBlock(in_channels=mid_channels, + out_channels=mid_channels, + temb_channels=0, + dropout=0.0) for _ in range(depth)]) + self.attn = AttnBlock(mid_channels) + self.res_block2 = nn.ModuleList([ResnetBlock(in_channels=mid_channels, + out_channels=mid_channels, + temb_channels=0, + dropout=0.0) for _ in range(depth)]) + + self.conv_out = nn.Conv2d(mid_channels, + out_channels, + kernel_size=1, + ) + + def forward(self, x): + x = self.conv_in(x) + for block in self.res_block1: + x = block(x, None) + x = torch.nn.functional.interpolate(x, size=(int(round(x.shape[2]*self.factor)), int(round(x.shape[3]*self.factor)))) + x = self.attn(x) + for block in self.res_block2: + x = block(x, None) + x = self.conv_out(x) + return x + + +class MergedRescaleEncoder(nn.Module): + def __init__(self, in_channels, ch, resolution, out_ch, num_res_blocks, + attn_resolutions, dropout=0.0, resamp_with_conv=True, + ch_mult=(1,2,4,8), rescale_factor=1.0, rescale_module_depth=1): + super().__init__() + intermediate_chn = ch * ch_mult[-1] + self.encoder = Encoder(in_channels=in_channels, num_res_blocks=num_res_blocks, ch=ch, ch_mult=ch_mult, + z_channels=intermediate_chn, double_z=False, resolution=resolution, + attn_resolutions=attn_resolutions, dropout=dropout, resamp_with_conv=resamp_with_conv, + out_ch=None) + self.rescaler = LatentRescaler(factor=rescale_factor, in_channels=intermediate_chn, + mid_channels=intermediate_chn, out_channels=out_ch, depth=rescale_module_depth) + + def forward(self, x): + x = self.encoder(x) + x = self.rescaler(x) + return x + + +class MergedRescaleDecoder(nn.Module): + def __init__(self, z_channels, out_ch, resolution, num_res_blocks, attn_resolutions, ch, ch_mult=(1,2,4,8), + dropout=0.0, resamp_with_conv=True, rescale_factor=1.0, rescale_module_depth=1): + super().__init__() + tmp_chn = z_channels*ch_mult[-1] + self.decoder = Decoder(out_ch=out_ch, z_channels=tmp_chn, attn_resolutions=attn_resolutions, dropout=dropout, + resamp_with_conv=resamp_with_conv, in_channels=None, num_res_blocks=num_res_blocks, + ch_mult=ch_mult, resolution=resolution, ch=ch) + self.rescaler = LatentRescaler(factor=rescale_factor, in_channels=z_channels, mid_channels=tmp_chn, + out_channels=tmp_chn, depth=rescale_module_depth) + + def forward(self, x): + x = self.rescaler(x) + x = self.decoder(x) + return x + + +class Upsampler(nn.Module): + def __init__(self, in_size, out_size, in_channels, out_channels, ch_mult=2): + super().__init__() + assert out_size >= in_size + num_blocks = int(np.log2(out_size//in_size))+1 + factor_up = 1.+ (out_size % in_size) + print(f"Building {self.__class__.__name__} with in_size: {in_size} --> out_size {out_size} and factor {factor_up}") + self.rescaler = LatentRescaler(factor=factor_up, in_channels=in_channels, mid_channels=2*in_channels, + out_channels=in_channels) + self.decoder = Decoder(out_ch=out_channels, resolution=out_size, z_channels=in_channels, num_res_blocks=2, + attn_resolutions=[], in_channels=None, ch=in_channels, + ch_mult=[ch_mult for _ in range(num_blocks)]) + + def forward(self, x): + x = self.rescaler(x) + x = self.decoder(x) + return x + + +class Resize(nn.Module): + def __init__(self, in_channels=None, learned=False, mode="bilinear"): + super().__init__() + self.with_conv = learned + self.mode = mode + if self.with_conv: + print(f"Note: {self.__class__.__name} uses learned downsampling and will ignore the fixed {mode} mode") + raise NotImplementedError() + assert in_channels is not None + # no asymmetric padding in torch conv, must do it ourselves + self.conv = torch.nn.Conv2d(in_channels, + in_channels, + kernel_size=4, + stride=2, + padding=1) + + def forward(self, x, scale_factor=1.0): + if scale_factor==1.0: + return x + else: + x = torch.nn.functional.interpolate(x, mode=self.mode, align_corners=False, scale_factor=scale_factor) + return x + +class FirstStagePostProcessor(nn.Module): + + def __init__(self, ch_mult:list, in_channels, + pretrained_model:nn.Module=None, + reshape=False, + n_channels=None, + dropout=0., + pretrained_config=None): + super().__init__() + if pretrained_config is None: + assert pretrained_model is not None, 'Either "pretrained_model" or "pretrained_config" must not be None' + self.pretrained_model = pretrained_model + else: + assert pretrained_config is not None, 'Either "pretrained_model" or "pretrained_config" must not be None' + self.instantiate_pretrained(pretrained_config) + + self.do_reshape = reshape + + if n_channels is None: + n_channels = self.pretrained_model.encoder.ch + + self.proj_norm = Normalize(in_channels,num_groups=in_channels//2) + self.proj = nn.Conv2d(in_channels,n_channels,kernel_size=3, + stride=1,padding=1) + + blocks = [] + downs = [] + ch_in = n_channels + for m in ch_mult: + blocks.append(ResnetBlock(in_channels=ch_in,out_channels=m*n_channels,dropout=dropout)) + ch_in = m * n_channels + downs.append(Downsample(ch_in, with_conv=False)) + + self.model = nn.ModuleList(blocks) + self.downsampler = nn.ModuleList(downs) + + + def instantiate_pretrained(self, config): + model = instantiate_from_config(config) + self.pretrained_model = model.eval() + # self.pretrained_model.train = False + for param in self.pretrained_model.parameters(): + param.requires_grad = False + + + @torch.no_grad() + def encode_with_pretrained(self,x): + c = self.pretrained_model.encode(x) + if isinstance(c, DiagonalGaussianDistribution): + c = c.mode() + return c + + def forward(self,x): + z_fs = self.encode_with_pretrained(x) + z = self.proj_norm(z_fs) + z = self.proj(z) + z = nonlinearity(z) + + for submodel, downmodel in zip(self.model,self.downsampler): + z = submodel(z,temb=None) + z = downmodel(z) + + if self.do_reshape: + z = rearrange(z,'b c h w -> b (h w) c') + return z + diff --git a/ldm/modules/diffusionmodules/openaimodel.py b/ldm/modules/diffusionmodules/openaimodel.py new file mode 100755 index 0000000..09f0ae1 --- /dev/null +++ b/ldm/modules/diffusionmodules/openaimodel.py @@ -0,0 +1,996 @@ +from abc import abstractmethod +from functools import partial +import math +from typing import Iterable + +import numpy as np +import torch as th +import torch.nn as nn +import torch.nn.functional as F + +from ldm.modules.diffusionmodules.util import ( + checkpoint, + conv_nd, + linear, + avg_pool_nd, + zero_module, + normalization, + timestep_embedding, +) +from ldm.modules.attention import SpatialTransformer +from ldm.util import exists + + +# dummy replace +def convert_module_to_f16(x): + pass + +def convert_module_to_f32(x): + pass + + +## go +class AttentionPool2d(nn.Module): + """ + Adapted from CLIP: https://github.com/openai/CLIP/blob/main/clip/model.py + """ + + def __init__( + self, + spacial_dim: int, + embed_dim: int, + num_heads_channels: int, + output_dim: int = None, + ): + super().__init__() + self.positional_embedding = nn.Parameter(th.randn(embed_dim, spacial_dim ** 2 + 1) / embed_dim ** 0.5) + self.qkv_proj = conv_nd(1, embed_dim, 3 * embed_dim, 1) + self.c_proj = conv_nd(1, embed_dim, output_dim or embed_dim, 1) + self.num_heads = embed_dim // num_heads_channels + self.attention = QKVAttention(self.num_heads) + + def forward(self, x): + b, c, *_spatial = x.shape + x = x.reshape(b, c, -1) # NC(HW) + x = th.cat([x.mean(dim=-1, keepdim=True), x], dim=-1) # NC(HW+1) + x = x + self.positional_embedding[None, :, :].to(x.dtype) # NC(HW+1) + x = self.qkv_proj(x) + x = self.attention(x) + x = self.c_proj(x) + return x[:, :, 0] + + +class TimestepBlock(nn.Module): + """ + Any module where forward() takes timestep embeddings as a second argument. + """ + + @abstractmethod + def forward(self, x, emb): + """ + Apply the module to `x` given `emb` timestep embeddings. + """ + + +class TimestepEmbedSequential(nn.Sequential, TimestepBlock): + """ + A sequential module that passes timestep embeddings to the children that + support it as an extra input. + """ + + def forward(self, x, emb, context=None): + for layer in self: + if isinstance(layer, TimestepBlock): + x = layer(x, emb) + elif isinstance(layer, SpatialTransformer): + x = layer(x, context) + else: + x = layer(x) + return x + + +class Upsample(nn.Module): + """ + An upsampling layer with an optional convolution. + :param channels: channels in the inputs and outputs. + :param use_conv: a bool determining if a convolution is applied. + :param dims: determines if the signal is 1D, 2D, or 3D. If 3D, then + upsampling occurs in the inner-two dimensions. + """ + + def __init__(self, channels, use_conv, dims=2, out_channels=None, padding=1): + super().__init__() + self.channels = channels + self.out_channels = out_channels or channels + self.use_conv = use_conv + self.dims = dims + if use_conv: + self.conv = conv_nd(dims, self.channels, self.out_channels, 3, padding=padding) + + def forward(self, x): + assert x.shape[1] == self.channels + if self.dims == 3: + x = F.interpolate( + x, (x.shape[2], x.shape[3] * 2, x.shape[4] * 2), mode="nearest" + ) + else: + x = F.interpolate(x, scale_factor=2, mode="nearest") + if self.use_conv: + x = self.conv(x) + return x + +class TransposedUpsample(nn.Module): + 'Learned 2x upsampling without padding' + def __init__(self, channels, out_channels=None, ks=5): + super().__init__() + self.channels = channels + self.out_channels = out_channels or channels + + self.up = nn.ConvTranspose2d(self.channels,self.out_channels,kernel_size=ks,stride=2) + + def forward(self,x): + return self.up(x) + + +class Downsample(nn.Module): + """ + A downsampling layer with an optional convolution. + :param channels: channels in the inputs and outputs. + :param use_conv: a bool determining if a convolution is applied. + :param dims: determines if the signal is 1D, 2D, or 3D. If 3D, then + downsampling occurs in the inner-two dimensions. + """ + + def __init__(self, channels, use_conv, dims=2, out_channels=None,padding=1): + super().__init__() + self.channels = channels + self.out_channels = out_channels or channels + self.use_conv = use_conv + self.dims = dims + stride = 2 if dims != 3 else (1, 2, 2) + if use_conv: + self.op = conv_nd( + dims, self.channels, self.out_channels, 3, stride=stride, padding=padding + ) + else: + assert self.channels == self.out_channels + self.op = avg_pool_nd(dims, kernel_size=stride, stride=stride) + + def forward(self, x): + assert x.shape[1] == self.channels + return self.op(x) + + +class ResBlock(TimestepBlock): + """ + A residual block that can optionally change the number of channels. + :param channels: the number of input channels. + :param emb_channels: the number of timestep embedding channels. + :param dropout: the rate of dropout. + :param out_channels: if specified, the number of out channels. + :param use_conv: if True and out_channels is specified, use a spatial + convolution instead of a smaller 1x1 convolution to change the + channels in the skip connection. + :param dims: determines if the signal is 1D, 2D, or 3D. + :param use_checkpoint: if True, use gradient checkpointing on this module. + :param up: if True, use this block for upsampling. + :param down: if True, use this block for downsampling. + """ + + def __init__( + self, + channels, + emb_channels, + dropout, + out_channels=None, + use_conv=False, + use_scale_shift_norm=False, + dims=2, + use_checkpoint=False, + up=False, + down=False, + ): + super().__init__() + self.channels = channels + self.emb_channels = emb_channels + self.dropout = dropout + self.out_channels = out_channels or channels + self.use_conv = use_conv + self.use_checkpoint = use_checkpoint + self.use_scale_shift_norm = use_scale_shift_norm + + self.in_layers = nn.Sequential( + normalization(channels), + nn.SiLU(), + conv_nd(dims, channels, self.out_channels, 3, padding=1), + ) + + self.updown = up or down + + if up: + self.h_upd = Upsample(channels, False, dims) + self.x_upd = Upsample(channels, False, dims) + elif down: + self.h_upd = Downsample(channels, False, dims) + self.x_upd = Downsample(channels, False, dims) + else: + self.h_upd = self.x_upd = nn.Identity() + + self.emb_layers = nn.Sequential( + nn.SiLU(), + linear( + emb_channels, + 2 * self.out_channels if use_scale_shift_norm else self.out_channels, + ), + ) + self.out_layers = nn.Sequential( + normalization(self.out_channels), + nn.SiLU(), + nn.Dropout(p=dropout), + zero_module( + conv_nd(dims, self.out_channels, self.out_channels, 3, padding=1) + ), + ) + + if self.out_channels == channels: + self.skip_connection = nn.Identity() + elif use_conv: + self.skip_connection = conv_nd( + dims, channels, self.out_channels, 3, padding=1 + ) + else: + self.skip_connection = conv_nd(dims, channels, self.out_channels, 1) + + def forward(self, x, emb): + """ + Apply the block to a Tensor, conditioned on a timestep embedding. + :param x: an [N x C x ...] Tensor of features. + :param emb: an [N x emb_channels] Tensor of timestep embeddings. + :return: an [N x C x ...] Tensor of outputs. + """ + return checkpoint( + self._forward, (x, emb), self.parameters(), self.use_checkpoint + ) + + + def _forward(self, x, emb): + if self.updown: + in_rest, in_conv = self.in_layers[:-1], self.in_layers[-1] + h = in_rest(x) + h = self.h_upd(h) + x = self.x_upd(x) + h = in_conv(h) + else: + h = self.in_layers(x) + emb_out = self.emb_layers(emb).type(h.dtype) + while len(emb_out.shape) < len(h.shape): + emb_out = emb_out[..., None] + if self.use_scale_shift_norm: + out_norm, out_rest = self.out_layers[0], self.out_layers[1:] + scale, shift = th.chunk(emb_out, 2, dim=1) + h = out_norm(h) * (1 + scale) + shift + h = out_rest(h) + else: + h = h + emb_out + h = self.out_layers(h) + return self.skip_connection(x) + h + + +class AttentionBlock(nn.Module): + """ + An attention block that allows spatial positions to attend to each other. + Originally ported from here, but adapted to the N-d case. + https://github.com/hojonathanho/diffusion/blob/1e0dceb3b3495bbe19116a5e1b3596cd0706c543/diffusion_tf/models/unet.py#L66. + """ + + def __init__( + self, + channels, + num_heads=1, + num_head_channels=-1, + use_checkpoint=False, + use_new_attention_order=False, + ): + super().__init__() + self.channels = channels + if num_head_channels == -1: + self.num_heads = num_heads + else: + assert ( + channels % num_head_channels == 0 + ), f"q,k,v channels {channels} is not divisible by num_head_channels {num_head_channels}" + self.num_heads = channels // num_head_channels + self.use_checkpoint = use_checkpoint + self.norm = normalization(channels) + self.qkv = conv_nd(1, channels, channels * 3, 1) + if use_new_attention_order: + # split qkv before split heads + self.attention = QKVAttention(self.num_heads) + else: + # split heads before split qkv + self.attention = QKVAttentionLegacy(self.num_heads) + + self.proj_out = zero_module(conv_nd(1, channels, channels, 1)) + + def forward(self, x): + return checkpoint(self._forward, (x,), self.parameters(), True) # TODO: check checkpoint usage, is True # TODO: fix the .half call!!! + #return pt_checkpoint(self._forward, x) # pytorch + + def _forward(self, x): + b, c, *spatial = x.shape + x = x.reshape(b, c, -1) + qkv = self.qkv(self.norm(x)) + h = self.attention(qkv) + h = self.proj_out(h) + return (x + h).reshape(b, c, *spatial) + + +def count_flops_attn(model, _x, y): + """ + A counter for the `thop` package to count the operations in an + attention operation. + Meant to be used like: + macs, params = thop.profile( + model, + inputs=(inputs, timestamps), + custom_ops={QKVAttention: QKVAttention.count_flops}, + ) + """ + b, c, *spatial = y[0].shape + num_spatial = int(np.prod(spatial)) + # We perform two matmuls with the same number of ops. + # The first computes the weight matrix, the second computes + # the combination of the value vectors. + matmul_ops = 2 * b * (num_spatial ** 2) * c + model.total_ops += th.DoubleTensor([matmul_ops]) + + +class QKVAttentionLegacy(nn.Module): + """ + A module which performs QKV attention. Matches legacy QKVAttention + input/output heads shaping + """ + + def __init__(self, n_heads): + super().__init__() + self.n_heads = n_heads + + def forward(self, qkv): + """ + Apply QKV attention. + :param qkv: an [N x (H * 3 * C) x T] tensor of Qs, Ks, and Vs. + :return: an [N x (H * C) x T] tensor after attention. + """ + bs, width, length = qkv.shape + assert width % (3 * self.n_heads) == 0 + ch = width // (3 * self.n_heads) + q, k, v = qkv.reshape(bs * self.n_heads, ch * 3, length).split(ch, dim=1) + scale = 1 / math.sqrt(math.sqrt(ch)) + weight = th.einsum( + "bct,bcs->bts", q * scale, k * scale + ) # More stable with f16 than dividing afterwards + weight = th.softmax(weight.float(), dim=-1).type(weight.dtype) + a = th.einsum("bts,bcs->bct", weight, v) + return a.reshape(bs, -1, length) + + @staticmethod + def count_flops(model, _x, y): + return count_flops_attn(model, _x, y) + + +class QKVAttention(nn.Module): + """ + A module which performs QKV attention and splits in a different order. + """ + + def __init__(self, n_heads): + super().__init__() + self.n_heads = n_heads + + def forward(self, qkv): + """ + Apply QKV attention. + :param qkv: an [N x (3 * H * C) x T] tensor of Qs, Ks, and Vs. + :return: an [N x (H * C) x T] tensor after attention. + """ + bs, width, length = qkv.shape + assert width % (3 * self.n_heads) == 0 + ch = width // (3 * self.n_heads) + q, k, v = qkv.chunk(3, dim=1) + scale = 1 / math.sqrt(math.sqrt(ch)) + weight = th.einsum( + "bct,bcs->bts", + (q * scale).view(bs * self.n_heads, ch, length), + (k * scale).view(bs * self.n_heads, ch, length), + ) # More stable with f16 than dividing afterwards + weight = th.softmax(weight.float(), dim=-1).type(weight.dtype) + a = th.einsum("bts,bcs->bct", weight, v.reshape(bs * self.n_heads, ch, length)) + return a.reshape(bs, -1, length) + + @staticmethod + def count_flops(model, _x, y): + return count_flops_attn(model, _x, y) + + +class UNetModel(nn.Module): + """ + The full UNet model with attention and timestep embedding. + :param in_channels: channels in the input Tensor. + :param model_channels: base channel count for the model. + :param out_channels: channels in the output Tensor. + :param num_res_blocks: number of residual blocks per downsample. + :param attention_resolutions: a collection of downsample rates at which + attention will take place. May be a set, list, or tuple. + For example, if this contains 4, then at 4x downsampling, attention + will be used. + :param dropout: the dropout probability. + :param channel_mult: channel multiplier for each level of the UNet. + :param conv_resample: if True, use learned convolutions for upsampling and + downsampling. + :param dims: determines if the signal is 1D, 2D, or 3D. + :param num_classes: if specified (as an int), then this model will be + class-conditional with `num_classes` classes. + :param use_checkpoint: use gradient checkpointing to reduce memory usage. + :param num_heads: the number of attention heads in each attention layer. + :param num_heads_channels: if specified, ignore num_heads and instead use + a fixed channel width per attention head. + :param num_heads_upsample: works with num_heads to set a different number + of heads for upsampling. Deprecated. + :param use_scale_shift_norm: use a FiLM-like conditioning mechanism. + :param resblock_updown: use residual blocks for up/downsampling. + :param use_new_attention_order: use a different attention pattern for potentially + increased efficiency. + """ + + def __init__( + self, + image_size, + in_channels, + model_channels, + out_channels, + num_res_blocks, + attention_resolutions, + dropout=0, + channel_mult=(1, 2, 4, 8), + conv_resample=True, + dims=2, + num_classes=None, + use_checkpoint=False, + use_fp16=False, + num_heads=-1, + num_head_channels=-1, + num_heads_upsample=-1, + use_scale_shift_norm=False, + resblock_updown=False, + use_new_attention_order=False, + use_spatial_transformer=False, # custom transformer support + transformer_depth=1, # custom transformer support + context_dim=None, # custom transformer support + n_embed=None, # custom support for prediction of discrete ids into codebook of first stage vq model + legacy=True, + disable_self_attentions=None, + num_attention_blocks=None + ): + super().__init__() + if use_spatial_transformer: + assert context_dim is not None, 'Fool!! You forgot to include the dimension of your cross-attention conditioning...' + + if context_dim is not None: + assert use_spatial_transformer, 'Fool!! You forgot to use the spatial transformer for your cross-attention conditioning...' + from omegaconf.listconfig import ListConfig + if type(context_dim) == ListConfig: + context_dim = list(context_dim) + + if num_heads_upsample == -1: + num_heads_upsample = num_heads + + if num_heads == -1: + assert num_head_channels != -1, 'Either num_heads or num_head_channels has to be set' + + if num_head_channels == -1: + assert num_heads != -1, 'Either num_heads or num_head_channels has to be set' + + self.image_size = image_size + self.in_channels = in_channels + self.model_channels = model_channels + self.out_channels = out_channels + if isinstance(num_res_blocks, int): + self.num_res_blocks = len(channel_mult) * [num_res_blocks] + else: + if len(num_res_blocks) != len(channel_mult): + raise ValueError("provide num_res_blocks either as an int (globally constant) or " + "as a list/tuple (per-level) with the same length as channel_mult") + self.num_res_blocks = num_res_blocks + #self.num_res_blocks = num_res_blocks + if disable_self_attentions is not None: + # should be a list of booleans, indicating whether to disable self-attention in TransformerBlocks or not + assert len(disable_self_attentions) == len(channel_mult) + if num_attention_blocks is not None: + assert len(num_attention_blocks) == len(self.num_res_blocks) + assert all(map(lambda i: self.num_res_blocks[i] >= num_attention_blocks[i], range(len(num_attention_blocks)))) + print(f"Constructor of UNetModel received num_attention_blocks={num_attention_blocks}. " + f"This option has LESS priority than attention_resolutions {attention_resolutions}, " + f"i.e., in cases where num_attention_blocks[i] > 0 but 2**i not in attention_resolutions, " + f"attention will still not be set.") # todo: convert to warning + + self.attention_resolutions = attention_resolutions + self.dropout = dropout + self.channel_mult = channel_mult + self.conv_resample = conv_resample + self.num_classes = num_classes + self.use_checkpoint = use_checkpoint + self.dtype = th.float16 if use_fp16 else th.float32 + self.num_heads = num_heads + self.num_head_channels = num_head_channels + self.num_heads_upsample = num_heads_upsample + self.predict_codebook_ids = n_embed is not None + + time_embed_dim = model_channels * 4 + self.time_embed = nn.Sequential( + linear(model_channels, time_embed_dim), + nn.SiLU(), + linear(time_embed_dim, time_embed_dim), + ) + + if self.num_classes is not None: + self.label_emb = nn.Embedding(num_classes, time_embed_dim) + + self.input_blocks = nn.ModuleList( + [ + TimestepEmbedSequential( + conv_nd(dims, in_channels, model_channels, 3, padding=1) + ) + ] + ) + self._feature_size = model_channels + input_block_chans = [model_channels] + ch = model_channels + ds = 1 + for level, mult in enumerate(channel_mult): + for nr in range(self.num_res_blocks[level]): + layers = [ + ResBlock( + ch, + time_embed_dim, + dropout, + out_channels=mult * model_channels, + dims=dims, + use_checkpoint=use_checkpoint, + use_scale_shift_norm=use_scale_shift_norm, + ) + ] + ch = mult * model_channels + if ds in attention_resolutions: + if num_head_channels == -1: + dim_head = ch // num_heads + else: + num_heads = ch // num_head_channels + dim_head = num_head_channels + if legacy: + #num_heads = 1 + dim_head = ch // num_heads if use_spatial_transformer else num_head_channels + if exists(disable_self_attentions): + disabled_sa = disable_self_attentions[level] + else: + disabled_sa = False + + if not exists(num_attention_blocks) or nr < num_attention_blocks[level]: + layers.append( + AttentionBlock( + ch, + use_checkpoint=use_checkpoint, + num_heads=num_heads, + num_head_channels=dim_head, + use_new_attention_order=use_new_attention_order, + ) if not use_spatial_transformer else SpatialTransformer( + ch, num_heads, dim_head, depth=transformer_depth, context_dim=context_dim, + disable_self_attn=disabled_sa + ) + ) + self.input_blocks.append(TimestepEmbedSequential(*layers)) + self._feature_size += ch + input_block_chans.append(ch) + if level != len(channel_mult) - 1: + out_ch = ch + self.input_blocks.append( + TimestepEmbedSequential( + ResBlock( + ch, + time_embed_dim, + dropout, + out_channels=out_ch, + dims=dims, + use_checkpoint=use_checkpoint, + use_scale_shift_norm=use_scale_shift_norm, + down=True, + ) + if resblock_updown + else Downsample( + ch, conv_resample, dims=dims, out_channels=out_ch + ) + ) + ) + ch = out_ch + input_block_chans.append(ch) + ds *= 2 + self._feature_size += ch + + if num_head_channels == -1: + dim_head = ch // num_heads + else: + num_heads = ch // num_head_channels + dim_head = num_head_channels + if legacy: + #num_heads = 1 + dim_head = ch // num_heads if use_spatial_transformer else num_head_channels + self.middle_block = TimestepEmbedSequential( + ResBlock( + ch, + time_embed_dim, + dropout, + dims=dims, + use_checkpoint=use_checkpoint, + use_scale_shift_norm=use_scale_shift_norm, + ), + AttentionBlock( + ch, + use_checkpoint=use_checkpoint, + num_heads=num_heads, + num_head_channels=dim_head, + use_new_attention_order=use_new_attention_order, + ) if not use_spatial_transformer else SpatialTransformer( # always uses a self-attn + ch, num_heads, dim_head, depth=transformer_depth, context_dim=context_dim + ), + ResBlock( + ch, + time_embed_dim, + dropout, + dims=dims, + use_checkpoint=use_checkpoint, + use_scale_shift_norm=use_scale_shift_norm, + ), + ) + self._feature_size += ch + + self.output_blocks = nn.ModuleList([]) + for level, mult in list(enumerate(channel_mult))[::-1]: + for i in range(self.num_res_blocks[level] + 1): + ich = input_block_chans.pop() + layers = [ + ResBlock( + ch + ich, + time_embed_dim, + dropout, + out_channels=model_channels * mult, + dims=dims, + use_checkpoint=use_checkpoint, + use_scale_shift_norm=use_scale_shift_norm, + ) + ] + ch = model_channels * mult + if ds in attention_resolutions: + if num_head_channels == -1: + dim_head = ch // num_heads + else: + num_heads = ch // num_head_channels + dim_head = num_head_channels + if legacy: + #num_heads = 1 + dim_head = ch // num_heads if use_spatial_transformer else num_head_channels + if exists(disable_self_attentions): + disabled_sa = disable_self_attentions[level] + else: + disabled_sa = False + + if not exists(num_attention_blocks) or i < num_attention_blocks[level]: + layers.append( + AttentionBlock( + ch, + use_checkpoint=use_checkpoint, + num_heads=num_heads_upsample, + num_head_channels=dim_head, + use_new_attention_order=use_new_attention_order, + ) if not use_spatial_transformer else SpatialTransformer( + ch, num_heads, dim_head, depth=transformer_depth, context_dim=context_dim, + disable_self_attn=disabled_sa + ) + ) + if level and i == self.num_res_blocks[level]: + out_ch = ch + layers.append( + ResBlock( + ch, + time_embed_dim, + dropout, + out_channels=out_ch, + dims=dims, + use_checkpoint=use_checkpoint, + use_scale_shift_norm=use_scale_shift_norm, + up=True, + ) + if resblock_updown + else Upsample(ch, conv_resample, dims=dims, out_channels=out_ch) + ) + ds //= 2 + self.output_blocks.append(TimestepEmbedSequential(*layers)) + self._feature_size += ch + + self.out = nn.Sequential( + normalization(ch), + nn.SiLU(), + zero_module(conv_nd(dims, model_channels, out_channels, 3, padding=1)), + ) + if self.predict_codebook_ids: + self.id_predictor = nn.Sequential( + normalization(ch), + conv_nd(dims, model_channels, n_embed, 1), + #nn.LogSoftmax(dim=1) # change to cross_entropy and produce non-normalized logits + ) + + def convert_to_fp16(self): + """ + Convert the torso of the model to float16. + """ + self.input_blocks.apply(convert_module_to_f16) + self.middle_block.apply(convert_module_to_f16) + self.output_blocks.apply(convert_module_to_f16) + + def convert_to_fp32(self): + """ + Convert the torso of the model to float32. + """ + self.input_blocks.apply(convert_module_to_f32) + self.middle_block.apply(convert_module_to_f32) + self.output_blocks.apply(convert_module_to_f32) + + def forward(self, x, timesteps=None, context=None, y=None,**kwargs): + """ + Apply the model to an input batch. + :param x: an [N x C x ...] Tensor of inputs. + :param timesteps: a 1-D batch of timesteps. + :param context: conditioning plugged in via crossattn + :param y: an [N] Tensor of labels, if class-conditional. + :return: an [N x C x ...] Tensor of outputs. + """ + assert (y is not None) == ( + self.num_classes is not None + ), "must specify y if and only if the model is class-conditional" + hs = [] + t_emb = timestep_embedding(timesteps, self.model_channels, repeat_only=False) + emb = self.time_embed(t_emb) + + if self.num_classes is not None: + assert y.shape == (x.shape[0],) + emb = emb + self.label_emb(y) + + h = x.type(self.dtype) + for module in self.input_blocks: + h = module(h, emb, context) + hs.append(h) + h = self.middle_block(h, emb, context) + for module in self.output_blocks: + h = th.cat([h, hs.pop()], dim=1) + h = module(h, emb, context) + h = h.type(x.dtype) + if self.predict_codebook_ids: + return self.id_predictor(h) + else: + return self.out(h) + + +class EncoderUNetModel(nn.Module): + """ + The half UNet model with attention and timestep embedding. + For usage, see UNet. + """ + + def __init__( + self, + image_size, + in_channels, + model_channels, + out_channels, + num_res_blocks, + attention_resolutions, + dropout=0, + channel_mult=(1, 2, 4, 8), + conv_resample=True, + dims=2, + use_checkpoint=False, + use_fp16=False, + num_heads=1, + num_head_channels=-1, + num_heads_upsample=-1, + use_scale_shift_norm=False, + resblock_updown=False, + use_new_attention_order=False, + pool="adaptive", + *args, + **kwargs + ): + super().__init__() + + if num_heads_upsample == -1: + num_heads_upsample = num_heads + + self.in_channels = in_channels + self.model_channels = model_channels + self.out_channels = out_channels + self.num_res_blocks = num_res_blocks + self.attention_resolutions = attention_resolutions + self.dropout = dropout + self.channel_mult = channel_mult + self.conv_resample = conv_resample + self.use_checkpoint = use_checkpoint + self.dtype = th.float16 if use_fp16 else th.float32 + self.num_heads = num_heads + self.num_head_channels = num_head_channels + self.num_heads_upsample = num_heads_upsample + + time_embed_dim = model_channels * 4 + self.time_embed = nn.Sequential( + linear(model_channels, time_embed_dim), + nn.SiLU(), + linear(time_embed_dim, time_embed_dim), + ) + + self.input_blocks = nn.ModuleList( + [ + TimestepEmbedSequential( + conv_nd(dims, in_channels, model_channels, 3, padding=1) + ) + ] + ) + self._feature_size = model_channels + input_block_chans = [model_channels] + ch = model_channels + ds = 1 + for level, mult in enumerate(channel_mult): + for _ in range(num_res_blocks): + layers = [ + ResBlock( + ch, + time_embed_dim, + dropout, + out_channels=mult * model_channels, + dims=dims, + use_checkpoint=use_checkpoint, + use_scale_shift_norm=use_scale_shift_norm, + ) + ] + ch = mult * model_channels + if ds in attention_resolutions: + layers.append( + AttentionBlock( + ch, + use_checkpoint=use_checkpoint, + num_heads=num_heads, + num_head_channels=num_head_channels, + use_new_attention_order=use_new_attention_order, + ) + ) + self.input_blocks.append(TimestepEmbedSequential(*layers)) + self._feature_size += ch + input_block_chans.append(ch) + if level != len(channel_mult) - 1: + out_ch = ch + self.input_blocks.append( + TimestepEmbedSequential( + ResBlock( + ch, + time_embed_dim, + dropout, + out_channels=out_ch, + dims=dims, + use_checkpoint=use_checkpoint, + use_scale_shift_norm=use_scale_shift_norm, + down=True, + ) + if resblock_updown + else Downsample( + ch, conv_resample, dims=dims, out_channels=out_ch + ) + ) + ) + ch = out_ch + input_block_chans.append(ch) + ds *= 2 + self._feature_size += ch + + self.middle_block = TimestepEmbedSequential( + ResBlock( + ch, + time_embed_dim, + dropout, + dims=dims, + use_checkpoint=use_checkpoint, + use_scale_shift_norm=use_scale_shift_norm, + ), + AttentionBlock( + ch, + use_checkpoint=use_checkpoint, + num_heads=num_heads, + num_head_channels=num_head_channels, + use_new_attention_order=use_new_attention_order, + ), + ResBlock( + ch, + time_embed_dim, + dropout, + dims=dims, + use_checkpoint=use_checkpoint, + use_scale_shift_norm=use_scale_shift_norm, + ), + ) + self._feature_size += ch + self.pool = pool + if pool == "adaptive": + self.out = nn.Sequential( + normalization(ch), + nn.SiLU(), + nn.AdaptiveAvgPool2d((1, 1)), + zero_module(conv_nd(dims, ch, out_channels, 1)), + nn.Flatten(), + ) + elif pool == "attention": + assert num_head_channels != -1 + self.out = nn.Sequential( + normalization(ch), + nn.SiLU(), + AttentionPool2d( + (image_size // ds), ch, num_head_channels, out_channels + ), + ) + elif pool == "spatial": + self.out = nn.Sequential( + nn.Linear(self._feature_size, 2048), + nn.ReLU(), + nn.Linear(2048, self.out_channels), + ) + elif pool == "spatial_v2": + self.out = nn.Sequential( + nn.Linear(self._feature_size, 2048), + normalization(2048), + nn.SiLU(), + nn.Linear(2048, self.out_channels), + ) + else: + raise NotImplementedError(f"Unexpected {pool} pooling") + + def convert_to_fp16(self): + """ + Convert the torso of the model to float16. + """ + self.input_blocks.apply(convert_module_to_f16) + self.middle_block.apply(convert_module_to_f16) + + def convert_to_fp32(self): + """ + Convert the torso of the model to float32. + """ + self.input_blocks.apply(convert_module_to_f32) + self.middle_block.apply(convert_module_to_f32) + + def forward(self, x, timesteps): + """ + Apply the model to an input batch. + :param x: an [N x C x ...] Tensor of inputs. + :param timesteps: a 1-D batch of timesteps. + :return: an [N x K] Tensor of outputs. + """ + emb = self.time_embed(timestep_embedding(timesteps, self.model_channels)) + + results = [] + h = x.type(self.dtype) + for module in self.input_blocks: + h = module(h, emb) + if self.pool.startswith("spatial"): + results.append(h.type(x.dtype).mean(dim=(2, 3))) + h = self.middle_block(h, emb) + if self.pool.startswith("spatial"): + results.append(h.type(x.dtype).mean(dim=(2, 3))) + h = th.cat(results, axis=-1) + return self.out(h) + else: + h = h.type(x.dtype) + return self.out(h) + diff --git a/ldm/modules/diffusionmodules/util.py b/ldm/modules/diffusionmodules/util.py new file mode 100755 index 0000000..a952e6c --- /dev/null +++ b/ldm/modules/diffusionmodules/util.py @@ -0,0 +1,267 @@ +# adopted from +# https://github.com/openai/improved-diffusion/blob/main/improved_diffusion/gaussian_diffusion.py +# and +# https://github.com/lucidrains/denoising-diffusion-pytorch/blob/7706bdfc6f527f58d33f84b7b522e61e6e3164b3/denoising_diffusion_pytorch/denoising_diffusion_pytorch.py +# and +# https://github.com/openai/guided-diffusion/blob/0ba878e517b276c45d1195eb29f6f5f72659a05b/guided_diffusion/nn.py +# +# thanks! + + +import os +import math +import torch +import torch.nn as nn +import numpy as np +from einops import repeat + +from ldm.util import instantiate_from_config + + +def make_beta_schedule(schedule, n_timestep, linear_start=1e-4, linear_end=2e-2, cosine_s=8e-3): + if schedule == "linear": + betas = ( + torch.linspace(linear_start ** 0.5, linear_end ** 0.5, n_timestep, dtype=torch.float64) ** 2 + ) + + elif schedule == "cosine": + timesteps = ( + torch.arange(n_timestep + 1, dtype=torch.float64) / n_timestep + cosine_s + ) + alphas = timesteps / (1 + cosine_s) * np.pi / 2 + alphas = torch.cos(alphas).pow(2) + alphas = alphas / alphas[0] + betas = 1 - alphas[1:] / alphas[:-1] + betas = np.clip(betas, a_min=0, a_max=0.999) + + elif schedule == "sqrt_linear": + betas = torch.linspace(linear_start, linear_end, n_timestep, dtype=torch.float64) + elif schedule == "sqrt": + betas = torch.linspace(linear_start, linear_end, n_timestep, dtype=torch.float64) ** 0.5 + else: + raise ValueError(f"schedule '{schedule}' unknown.") + return betas.numpy() + + +def make_ddim_timesteps(ddim_discr_method, num_ddim_timesteps, num_ddpm_timesteps, verbose=True): + if ddim_discr_method == 'uniform': + c = num_ddpm_timesteps // num_ddim_timesteps + ddim_timesteps = np.asarray(list(range(0, num_ddpm_timesteps, c))) + elif ddim_discr_method == 'quad': + ddim_timesteps = ((np.linspace(0, np.sqrt(num_ddpm_timesteps * .8), num_ddim_timesteps)) ** 2).astype(int) + else: + raise NotImplementedError(f'There is no ddim discretization method called "{ddim_discr_method}"') + + # assert ddim_timesteps.shape[0] == num_ddim_timesteps + # add one to get the final alpha values right (the ones from first scale to data during sampling) + steps_out = ddim_timesteps + 1 + if verbose: + print(f'Selected timesteps for ddim sampler: {steps_out}') + return steps_out + + +def make_ddim_sampling_parameters(alphacums, ddim_timesteps, eta, verbose=True): + # select alphas for computing the variance schedule + alphas = alphacums[ddim_timesteps] + alphas_prev = np.asarray([alphacums[0]] + alphacums[ddim_timesteps[:-1]].tolist()) + + # according the the formula provided in https://arxiv.org/abs/2010.02502 + sigmas = eta * np.sqrt((1 - alphas_prev) / (1 - alphas) * (1 - alphas / alphas_prev)) + if verbose: + print(f'Selected alphas for ddim sampler: a_t: {alphas}; a_(t-1): {alphas_prev}') + print(f'For the chosen value of eta, which is {eta}, ' + f'this results in the following sigma_t schedule for ddim sampler {sigmas}') + return sigmas, alphas, alphas_prev + + +def betas_for_alpha_bar(num_diffusion_timesteps, alpha_bar, max_beta=0.999): + """ + Create a beta schedule that discretizes the given alpha_t_bar function, + which defines the cumulative product of (1-beta) over time from t = [0,1]. + :param num_diffusion_timesteps: the number of betas to produce. + :param alpha_bar: a lambda that takes an argument t from 0 to 1 and + produces the cumulative product of (1-beta) up to that + part of the diffusion process. + :param max_beta: the maximum beta to use; use values lower than 1 to + prevent singularities. + """ + betas = [] + for i in range(num_diffusion_timesteps): + t1 = i / num_diffusion_timesteps + t2 = (i + 1) / num_diffusion_timesteps + betas.append(min(1 - alpha_bar(t2) / alpha_bar(t1), max_beta)) + return np.array(betas) + + +def extract_into_tensor(a, t, x_shape): + b, *_ = t.shape + out = a.gather(-1, t) + return out.reshape(b, *((1,) * (len(x_shape) - 1))) + + +def checkpoint(func, inputs, params, flag): + """ + Evaluate a function without caching intermediate activations, allowing for + reduced memory at the expense of extra compute in the backward pass. + :param func: the function to evaluate. + :param inputs: the argument sequence to pass to `func`. + :param params: a sequence of parameters `func` depends on but does not + explicitly take as arguments. + :param flag: if False, disable gradient checkpointing. + """ + if flag: + args = tuple(inputs) + tuple(params) + return CheckpointFunction.apply(func, len(inputs), *args) + else: + return func(*inputs) + + +class CheckpointFunction(torch.autograd.Function): + @staticmethod + def forward(ctx, run_function, length, *args): + ctx.run_function = run_function + ctx.input_tensors = list(args[:length]) + ctx.input_params = list(args[length:]) + + with torch.no_grad(): + output_tensors = ctx.run_function(*ctx.input_tensors) + return output_tensors + + @staticmethod + def backward(ctx, *output_grads): + ctx.input_tensors = [x.detach().requires_grad_(True) for x in ctx.input_tensors] + with torch.enable_grad(): + # Fixes a bug where the first op in run_function modifies the + # Tensor storage in place, which is not allowed for detach()'d + # Tensors. + shallow_copies = [x.view_as(x) for x in ctx.input_tensors] + output_tensors = ctx.run_function(*shallow_copies) + input_grads = torch.autograd.grad( + output_tensors, + ctx.input_tensors + ctx.input_params, + output_grads, + allow_unused=True, + ) + del ctx.input_tensors + del ctx.input_params + del output_tensors + return (None, None) + input_grads + + +def timestep_embedding(timesteps, dim, max_period=10000, repeat_only=False): + """ + Create sinusoidal timestep embeddings. + :param timesteps: a 1-D Tensor of N indices, one per batch element. + These may be fractional. + :param dim: the dimension of the output. + :param max_period: controls the minimum frequency of the embeddings. + :return: an [N x dim] Tensor of positional embeddings. + """ + if not repeat_only: + half = dim // 2 + freqs = torch.exp( + -math.log(max_period) * torch.arange(start=0, end=half, dtype=torch.float32) / half + ).to(device=timesteps.device) + args = timesteps[:, None].float() * freqs[None] + embedding = torch.cat([torch.cos(args), torch.sin(args)], dim=-1) + if dim % 2: + embedding = torch.cat([embedding, torch.zeros_like(embedding[:, :1])], dim=-1) + else: + embedding = repeat(timesteps, 'b -> b d', d=dim) + return embedding + + +def zero_module(module): + """ + Zero out the parameters of a module and return it. + """ + for p in module.parameters(): + p.detach().zero_() + return module + + +def scale_module(module, scale): + """ + Scale the parameters of a module and return it. + """ + for p in module.parameters(): + p.detach().mul_(scale) + return module + + +def mean_flat(tensor): + """ + Take the mean over all non-batch dimensions. + """ + return tensor.mean(dim=list(range(1, len(tensor.shape)))) + + +def normalization(channels): + """ + Make a standard normalization layer. + :param channels: number of input channels. + :return: an nn.Module for normalization. + """ + return GroupNorm32(32, channels) + + +# PyTorch 1.7 has SiLU, but we support PyTorch 1.5. +class SiLU(nn.Module): + def forward(self, x): + return x * torch.sigmoid(x) + + +class GroupNorm32(nn.GroupNorm): + def forward(self, x): + return super().forward(x.float()).type(x.dtype) + +def conv_nd(dims, *args, **kwargs): + """ + Create a 1D, 2D, or 3D convolution module. + """ + if dims == 1: + return nn.Conv1d(*args, **kwargs) + elif dims == 2: + return nn.Conv2d(*args, **kwargs) + elif dims == 3: + return nn.Conv3d(*args, **kwargs) + raise ValueError(f"unsupported dimensions: {dims}") + + +def linear(*args, **kwargs): + """ + Create a linear module. + """ + return nn.Linear(*args, **kwargs) + + +def avg_pool_nd(dims, *args, **kwargs): + """ + Create a 1D, 2D, or 3D average pooling module. + """ + if dims == 1: + return nn.AvgPool1d(*args, **kwargs) + elif dims == 2: + return nn.AvgPool2d(*args, **kwargs) + elif dims == 3: + return nn.AvgPool3d(*args, **kwargs) + raise ValueError(f"unsupported dimensions: {dims}") + + +class HybridConditioner(nn.Module): + + def __init__(self, c_concat_config, c_crossattn_config): + super().__init__() + self.concat_conditioner = instantiate_from_config(c_concat_config) + self.crossattn_conditioner = instantiate_from_config(c_crossattn_config) + + def forward(self, c_concat, c_crossattn): + c_concat = self.concat_conditioner(c_concat) + c_crossattn = self.crossattn_conditioner(c_crossattn) + return {'c_concat': [c_concat], 'c_crossattn': [c_crossattn]} + + +def noise_like(shape, device, repeat=False): + repeat_noise = lambda: torch.randn((1, *shape[1:]), device=device).repeat(shape[0], *((1,) * (len(shape) - 1))) + noise = lambda: torch.randn(shape, device=device) + return repeat_noise() if repeat else noise() \ No newline at end of file diff --git a/ldm/modules/distributions/__init__.py b/ldm/modules/distributions/__init__.py new file mode 100755 index 0000000..e69de29 diff --git a/ldm/modules/distributions/distributions.py b/ldm/modules/distributions/distributions.py new file mode 100755 index 0000000..f2b8ef9 --- /dev/null +++ b/ldm/modules/distributions/distributions.py @@ -0,0 +1,92 @@ +import torch +import numpy as np + + +class AbstractDistribution: + def sample(self): + raise NotImplementedError() + + def mode(self): + raise NotImplementedError() + + +class DiracDistribution(AbstractDistribution): + def __init__(self, value): + self.value = value + + def sample(self): + return self.value + + def mode(self): + return self.value + + +class DiagonalGaussianDistribution(object): + def __init__(self, parameters, deterministic=False): + self.parameters = parameters + self.mean, self.logvar = torch.chunk(parameters, 2, dim=1) + self.logvar = torch.clamp(self.logvar, -30.0, 20.0) + self.deterministic = deterministic + self.std = torch.exp(0.5 * self.logvar) + self.var = torch.exp(self.logvar) + if self.deterministic: + self.var = self.std = torch.zeros_like(self.mean).to(device=self.parameters.device) + + def sample(self): + x = self.mean + self.std * torch.randn(self.mean.shape).to(device=self.parameters.device) + return x + + def kl(self, other=None): + if self.deterministic: + return torch.Tensor([0.]) + else: + if other is None: + return 0.5 * torch.sum(torch.pow(self.mean, 2) + + self.var - 1.0 - self.logvar, + dim=[1, 2, 3]) + else: + return 0.5 * torch.sum( + torch.pow(self.mean - other.mean, 2) / other.var + + self.var / other.var - 1.0 - self.logvar + other.logvar, + dim=[1, 2, 3]) + + def nll(self, sample, dims=[1,2,3]): + if self.deterministic: + return torch.Tensor([0.]) + logtwopi = np.log(2.0 * np.pi) + return 0.5 * torch.sum( + logtwopi + self.logvar + torch.pow(sample - self.mean, 2) / self.var, + dim=dims) + + def mode(self): + return self.mean + + +def normal_kl(mean1, logvar1, mean2, logvar2): + """ + source: https://github.com/openai/guided-diffusion/blob/27c20a8fab9cb472df5d6bdd6c8d11c8f430b924/guided_diffusion/losses.py#L12 + Compute the KL divergence between two gaussians. + Shapes are automatically broadcasted, so batches can be compared to + scalars, among other use cases. + """ + tensor = None + for obj in (mean1, logvar1, mean2, logvar2): + if isinstance(obj, torch.Tensor): + tensor = obj + break + assert tensor is not None, "at least one argument must be a Tensor" + + # Force variances to be Tensors. Broadcasting helps convert scalars to + # Tensors, but it does not work for torch.exp(). + logvar1, logvar2 = [ + x if isinstance(x, torch.Tensor) else torch.tensor(x).to(tensor) + for x in (logvar1, logvar2) + ] + + return 0.5 * ( + -1.0 + + logvar2 + - logvar1 + + torch.exp(logvar1 - logvar2) + + ((mean1 - mean2) ** 2) * torch.exp(-logvar2) + ) diff --git a/ldm/modules/ema.py b/ldm/modules/ema.py new file mode 100755 index 0000000..c8c75af --- /dev/null +++ b/ldm/modules/ema.py @@ -0,0 +1,76 @@ +import torch +from torch import nn + + +class LitEma(nn.Module): + def __init__(self, model, decay=0.9999, use_num_upates=True): + super().__init__() + if decay < 0.0 or decay > 1.0: + raise ValueError('Decay must be between 0 and 1') + + self.m_name2s_name = {} + self.register_buffer('decay', torch.tensor(decay, dtype=torch.float32)) + self.register_buffer('num_updates', torch.tensor(0,dtype=torch.int) if use_num_upates + else torch.tensor(-1,dtype=torch.int)) + + for name, p in model.named_parameters(): + if p.requires_grad: + #remove as '.'-character is not allowed in buffers + s_name = name.replace('.','') + self.m_name2s_name.update({name:s_name}) + self.register_buffer(s_name,p.clone().detach().data) + + self.collected_params = [] + + def forward(self,model): + decay = self.decay + + if self.num_updates >= 0: + self.num_updates += 1 + decay = min(self.decay,(1 + self.num_updates) / (10 + self.num_updates)) + + one_minus_decay = 1.0 - decay + + with torch.no_grad(): + m_param = dict(model.named_parameters()) + shadow_params = dict(self.named_buffers()) + + for key in m_param: + if m_param[key].requires_grad: + sname = self.m_name2s_name[key] + shadow_params[sname] = shadow_params[sname].type_as(m_param[key]) + shadow_params[sname].sub_(one_minus_decay * (shadow_params[sname] - m_param[key])) + else: + assert not key in self.m_name2s_name + + def copy_to(self, model): + m_param = dict(model.named_parameters()) + shadow_params = dict(self.named_buffers()) + for key in m_param: + if m_param[key].requires_grad: + m_param[key].data.copy_(shadow_params[self.m_name2s_name[key]].data) + else: + assert not key in self.m_name2s_name + + def store(self, parameters): + """ + Save the current parameters for restoring later. + Args: + parameters: Iterable of `torch.nn.Parameter`; the parameters to be + temporarily stored. + """ + self.collected_params = [param.clone() for param in parameters] + + def restore(self, parameters): + """ + Restore the parameters stored with the `store` method. + Useful to validate the model with EMA parameters without affecting the + original optimization process. Store the parameters before the + `copy_to` method. After validation (or model saving), use this to + restore the former parameters. + Args: + parameters: Iterable of `torch.nn.Parameter`; the parameters to be + updated with the stored parameters. + """ + for c_param, param in zip(self.collected_params, parameters): + param.data.copy_(c_param.data) diff --git a/ldm/modules/encoders/__init__.py b/ldm/modules/encoders/__init__.py new file mode 100755 index 0000000..e69de29 diff --git a/ldm/modules/encoders/modules.py b/ldm/modules/encoders/modules.py new file mode 100755 index 0000000..b1afccf --- /dev/null +++ b/ldm/modules/encoders/modules.py @@ -0,0 +1,550 @@ +import torch +import torch.nn as nn +import numpy as np +from functools import partial +import kornia + +from ldm.modules.x_transformer import Encoder, TransformerWrapper # TODO: can we directly rely on lucidrains code and simply add this as a reuirement? --> test +from ldm.util import default +import clip + + +class AbstractEncoder(nn.Module): + def __init__(self): + super().__init__() + + def encode(self, *args, **kwargs): + raise NotImplementedError + +class IdentityEncoder(AbstractEncoder): + + def encode(self, x): + return x + +class FaceClipEncoder(AbstractEncoder): + def __init__(self, augment=True, retreival_key=None): + super().__init__() + self.encoder = FrozenCLIPImageEmbedder() + self.augment = augment + self.retreival_key = retreival_key + + def forward(self, img): + encodings = [] + with torch.no_grad(): + x_offset = 125 + if self.retreival_key: + # Assumes retrieved image are packed into the second half of channels + face = img[:,3:,190:440,x_offset:(512-x_offset)] + other = img[:,:3,...].clone() + else: + face = img[:,:,190:440,x_offset:(512-x_offset)] + other = img.clone() + + if self.augment: + face = K.RandomHorizontalFlip()(face) + + other[:,:,190:440,x_offset:(512-x_offset)] *= 0 + encodings = [ + self.encoder.encode(face), + self.encoder.encode(other), + ] + + return torch.cat(encodings, dim=1) + + def encode(self, img): + if isinstance(img, list): + # Uncondition + return torch.zeros((1, 2, 768), device=self.encoder.model.visual.conv1.weight.device) + + return self(img) + +class FaceIdClipEncoder(AbstractEncoder): + def __init__(self): + super().__init__() + self.encoder = FrozenCLIPImageEmbedder() + for p in self.encoder.parameters(): + p.requires_grad = False + self.id = FrozenFaceEncoder("/home/jpinkney/code/stable-diffusion/model_ir_se50.pth", augment=True) + + def forward(self, img): + encodings = [] + with torch.no_grad(): + face = kornia.geometry.resize(img, (256, 256), + interpolation='bilinear', align_corners=True) + + other = img.clone() + other[:,:,184:452,122:396] *= 0 + encodings = [ + self.id.encode(face), + self.encoder.encode(other), + ] + + return torch.cat(encodings, dim=1) + + def encode(self, img): + if isinstance(img, list): + # Uncondition + return torch.zeros((1, 2, 768), device=self.encoder.model.visual.conv1.weight.device) + + return self(img) + +class ClassEmbedder(nn.Module): + def __init__(self, embed_dim, n_classes=1000, key='class'): + super().__init__() + self.key = key + self.embedding = nn.Embedding(n_classes, embed_dim) + + def forward(self, batch, key=None): + if key is None: + key = self.key + # this is for use in crossattn + c = batch[key][:, None] + c = self.embedding(c) + return c + + +class TransformerEmbedder(AbstractEncoder): + """Some transformer encoder layers""" + def __init__(self, n_embed, n_layer, vocab_size, max_seq_len=77, device="cuda"): + super().__init__() + self.device = device + self.transformer = TransformerWrapper(num_tokens=vocab_size, max_seq_len=max_seq_len, + attn_layers=Encoder(dim=n_embed, depth=n_layer)) + + def forward(self, tokens): + tokens = tokens.to(self.device) # meh + z = self.transformer(tokens, return_embeddings=True) + return z + + def encode(self, x): + return self(x) + + +class BERTTokenizer(AbstractEncoder): + """ Uses a pretrained BERT tokenizer by huggingface. Vocab size: 30522 (?)""" + def __init__(self, device="cuda", vq_interface=True, max_length=77): + super().__init__() + from transformers import BertTokenizerFast # TODO: add to reuquirements + self.tokenizer = BertTokenizerFast.from_pretrained("bert-base-uncased") + self.device = device + self.vq_interface = vq_interface + self.max_length = max_length + + def forward(self, text): + batch_encoding = self.tokenizer(text, truncation=True, max_length=self.max_length, return_length=True, + return_overflowing_tokens=False, padding="max_length", return_tensors="pt") + tokens = batch_encoding["input_ids"].to(self.device) + return tokens + + @torch.no_grad() + def encode(self, text): + tokens = self(text) + if not self.vq_interface: + return tokens + return None, None, [None, None, tokens] + + def decode(self, text): + return text + + +class BERTEmbedder(AbstractEncoder): + """Uses the BERT tokenizr model and add some transformer encoder layers""" + def __init__(self, n_embed, n_layer, vocab_size=30522, max_seq_len=77, + device="cuda",use_tokenizer=True, embedding_dropout=0.0): + super().__init__() + self.use_tknz_fn = use_tokenizer + if self.use_tknz_fn: + self.tknz_fn = BERTTokenizer(vq_interface=False, max_length=max_seq_len) + self.device = device + self.transformer = TransformerWrapper(num_tokens=vocab_size, max_seq_len=max_seq_len, + attn_layers=Encoder(dim=n_embed, depth=n_layer), + emb_dropout=embedding_dropout) + + def forward(self, text): + if self.use_tknz_fn: + tokens = self.tknz_fn(text)#.to(self.device) + else: + tokens = text + z = self.transformer(tokens, return_embeddings=True) + return z + + def encode(self, text): + # output of length 77 + return self(text) + + +from transformers import T5Tokenizer, T5EncoderModel, CLIPTokenizer, CLIPTextModel + +def disabled_train(self, mode=True): + """Overwrite model.train with this function to make sure train/eval mode + does not change anymore.""" + return self + + +class FrozenT5Embedder(AbstractEncoder): + """Uses the T5 transformer encoder for text""" + def __init__(self, version="google/t5-v1_1-large", device="cuda", max_length=77): # others are google/t5-v1_1-xl and google/t5-v1_1-xxl + super().__init__() + self.tokenizer = T5Tokenizer.from_pretrained(version) + self.transformer = T5EncoderModel.from_pretrained(version) + self.device = device + self.max_length = max_length # TODO: typical value? + self.freeze() + + def freeze(self): + self.transformer = self.transformer.eval() + #self.train = disabled_train + for param in self.parameters(): + param.requires_grad = False + + def forward(self, text): + batch_encoding = self.tokenizer(text, truncation=True, max_length=self.max_length, return_length=True, + return_overflowing_tokens=False, padding="max_length", return_tensors="pt") + tokens = batch_encoding["input_ids"].to(self.device) + outputs = self.transformer(input_ids=tokens) + + z = outputs.last_hidden_state + return z + + def encode(self, text): + return self(text) + +from ldm.thirdp.psp.id_loss import IDFeatures +import kornia.augmentation as K + +class FrozenFaceEncoder(AbstractEncoder): + def __init__(self, model_path, augment=False): + super().__init__() + self.loss_fn = IDFeatures(model_path) + # face encoder is frozen + for p in self.loss_fn.parameters(): + p.requires_grad = False + # Mapper is trainable + self.mapper = torch.nn.Linear(512, 768) + p = 0.25 + if augment: + self.augment = K.AugmentationSequential( + K.RandomHorizontalFlip(p=0.5), + K.RandomEqualize(p=p), + # K.RandomPlanckianJitter(p=p), + # K.RandomPlasmaBrightness(p=p), + # K.RandomPlasmaContrast(p=p), + # K.ColorJiggle(0.02, 0.2, 0.2, p=p), + ) + else: + self.augment = False + + def forward(self, img): + if isinstance(img, list): + # Uncondition + return torch.zeros((1, 1, 768), device=self.mapper.weight.device) + + if self.augment is not None: + # Transforms require 0-1 + img = self.augment((img + 1)/2) + img = 2*img - 1 + + feat = self.loss_fn(img, crop=True) + feat = self.mapper(feat.unsqueeze(1)) + return feat + + def encode(self, img): + return self(img) + +class FrozenCLIPEmbedder(AbstractEncoder): + """Uses the CLIP transformer encoder for text (from huggingface)""" + def __init__(self, version="openai/clip-vit-large-patch14", device="cuda", max_length=77): # clip-vit-base-patch32 + super().__init__() + self.tokenizer = CLIPTokenizer.from_pretrained(version) + self.transformer = CLIPTextModel.from_pretrained(version) + self.device = device + self.max_length = max_length # TODO: typical value? + self.freeze() + + def freeze(self): + self.transformer = self.transformer.eval() + #self.train = disabled_train + for param in self.parameters(): + param.requires_grad = False + + def forward(self, text): + batch_encoding = self.tokenizer(text, truncation=True, max_length=self.max_length, return_length=True, + return_overflowing_tokens=False, padding="max_length", return_tensors="pt") + tokens = batch_encoding["input_ids"].to(self.device) + outputs = self.transformer(input_ids=tokens) + + z = outputs.last_hidden_state + return z + + def encode(self, text): + return self(text) + +import torch.nn.functional as F +from transformers import CLIPVisionModel +class ClipImageProjector(AbstractEncoder): + """ + Uses the CLIP image encoder. + """ + def __init__(self, version="openai/clip-vit-large-patch14", max_length=77): # clip-vit-base-patch32 + super().__init__() + self.model = CLIPVisionModel.from_pretrained(version) + self.model.train() + self.max_length = max_length # TODO: typical value? + self.antialias = True + self.mapper = torch.nn.Linear(1024, 768) + self.register_buffer('mean', torch.Tensor([0.48145466, 0.4578275, 0.40821073]), persistent=False) + self.register_buffer('std', torch.Tensor([0.26862954, 0.26130258, 0.27577711]), persistent=False) + null_cond = self.get_null_cond(version, max_length) + self.register_buffer('null_cond', null_cond) + + @torch.no_grad() + def get_null_cond(self, version, max_length): + device = self.mean.device + embedder = FrozenCLIPEmbedder(version=version, device=device, max_length=max_length) + null_cond = embedder([""]) + return null_cond + + def preprocess(self, x): + # Expects inputs in the range -1, 1 + x = kornia.geometry.resize(x, (224, 224), + interpolation='bicubic',align_corners=True, + antialias=self.antialias) + x = (x + 1.) / 2. + # renormalize according to clip + x = kornia.enhance.normalize(x, self.mean, self.std) + return x + + def forward(self, x): + if isinstance(x, list): + return self.null_cond + # x is assumed to be in range [-1,1] + x = self.preprocess(x) + outputs = self.model(pixel_values=x) + last_hidden_state = outputs.last_hidden_state + last_hidden_state = self.mapper(last_hidden_state) + return F.pad(last_hidden_state, [0,0, 0,self.max_length-last_hidden_state.shape[1], 0,0]) + + def encode(self, im): + return self(im) + +class ProjectedFrozenCLIPEmbedder(AbstractEncoder): + def __init__(self, version="openai/clip-vit-large-patch14", device="cuda", max_length=77): # clip-vit-base-patch32 + super().__init__() + self.embedder = FrozenCLIPEmbedder(version=version, device=device, max_length=max_length) + self.projection = torch.nn.Linear(768, 768) + + def forward(self, text): + z = self.embedder(text) + return self.projection(z) + + def encode(self, text): + return self(text) + +class FrozenCLIPImageEmbedder(AbstractEncoder): + """ + Uses the CLIP image encoder. + Not actually frozen... If you want that set cond_stage_trainable=False in cfg + """ + def __init__( + self, + model='ViT-L/14', + jit=False, + device='cpu', + antialias=False, + ): + super().__init__() + self.model, _ = clip.load(name=model, device=device, jit=jit) + # We don't use the text part so delete it + del self.model.transformer + self.antialias = antialias + self.register_buffer('mean', torch.Tensor([0.48145466, 0.4578275, 0.40821073]), persistent=False) + self.register_buffer('std', torch.Tensor([0.26862954, 0.26130258, 0.27577711]), persistent=False) + + def preprocess(self, x): + # Expects inputs in the range -1, 1 + x = kornia.geometry.resize(x, (224, 224), + interpolation='bicubic',align_corners=True, + antialias=self.antialias) + x = (x + 1.) / 2. + # renormalize according to clip + x = kornia.enhance.normalize(x, self.mean, self.std) + return x + + def forward(self, x): + # x is assumed to be in range [-1,1] + if isinstance(x, list): + # [""] denotes condition dropout for ucg + device = self.model.visual.conv1.weight.device + return torch.zeros(1, 768, device=device) + return self.model.encode_image(self.preprocess(x)).float() + + def encode(self, im): + return self(im).unsqueeze(1) + +from torchvision import transforms +import random + +class FrozenCLIPImageMutliEmbedder(AbstractEncoder): + """ + Uses the CLIP image encoder. + Not actually frozen... If you want that set cond_stage_trainable=False in cfg + """ + def __init__( + self, + model='ViT-L/14', + jit=False, + device='cpu', + antialias=True, + max_crops=5, + ): + super().__init__() + self.model, _ = clip.load(name=model, device=device, jit=jit) + # We don't use the text part so delete it + del self.model.transformer + self.antialias = antialias + self.register_buffer('mean', torch.Tensor([0.48145466, 0.4578275, 0.40821073]), persistent=False) + self.register_buffer('std', torch.Tensor([0.26862954, 0.26130258, 0.27577711]), persistent=False) + self.max_crops = max_crops + + def preprocess(self, x): + + # Expects inputs in the range -1, 1 + randcrop = transforms.RandomResizedCrop(224, scale=(0.085, 1.0), ratio=(1,1)) + max_crops = self.max_crops + patches = [] + crops = [randcrop(x) for _ in range(max_crops)] + patches.extend(crops) + x = torch.cat(patches, dim=0) + x = (x + 1.) / 2. + # renormalize according to clip + x = kornia.enhance.normalize(x, self.mean, self.std) + return x + + def forward(self, x): + # x is assumed to be in range [-1,1] + if isinstance(x, list): + # [""] denotes condition dropout for ucg + device = self.model.visual.conv1.weight.device + return torch.zeros(1, self.max_crops, 768, device=device) + batch_tokens = [] + for im in x: + patches = self.preprocess(im.unsqueeze(0)) + tokens = self.model.encode_image(patches).float() + for t in tokens: + if random.random() < 0.1: + t *= 0 + batch_tokens.append(tokens.unsqueeze(0)) + + return torch.cat(batch_tokens, dim=0) + + def encode(self, im): + return self(im) + +class SpatialRescaler(nn.Module): + def __init__(self, + n_stages=1, + method='bilinear', + multiplier=0.5, + in_channels=3, + out_channels=None, + bias=False): + super().__init__() + self.n_stages = n_stages + assert self.n_stages >= 0 + assert method in ['nearest','linear','bilinear','trilinear','bicubic','area'] + self.multiplier = multiplier + self.interpolator = partial(torch.nn.functional.interpolate, mode=method) + self.remap_output = out_channels is not None + if self.remap_output: + print(f'Spatial Rescaler mapping from {in_channels} to {out_channels} channels after resizing.') + self.channel_mapper = nn.Conv2d(in_channels,out_channels,1,bias=bias) + + def forward(self,x): + for stage in range(self.n_stages): + x = self.interpolator(x, scale_factor=self.multiplier) + + + if self.remap_output: + x = self.channel_mapper(x) + return x + + def encode(self, x): + return self(x) + + +from ldm.util import instantiate_from_config +from ldm.modules.diffusionmodules.util import make_beta_schedule, extract_into_tensor, noise_like + + +class LowScaleEncoder(nn.Module): + def __init__(self, model_config, linear_start, linear_end, timesteps=1000, max_noise_level=250, output_size=64, + scale_factor=1.0): + super().__init__() + self.max_noise_level = max_noise_level + self.model = instantiate_from_config(model_config) + self.augmentation_schedule = self.register_schedule(timesteps=timesteps, linear_start=linear_start, + linear_end=linear_end) + self.out_size = output_size + self.scale_factor = scale_factor + + def register_schedule(self, beta_schedule="linear", timesteps=1000, + linear_start=1e-4, linear_end=2e-2, cosine_s=8e-3): + betas = make_beta_schedule(beta_schedule, timesteps, linear_start=linear_start, linear_end=linear_end, + cosine_s=cosine_s) + alphas = 1. - betas + alphas_cumprod = np.cumprod(alphas, axis=0) + alphas_cumprod_prev = np.append(1., alphas_cumprod[:-1]) + + timesteps, = betas.shape + self.num_timesteps = int(timesteps) + self.linear_start = linear_start + self.linear_end = linear_end + assert alphas_cumprod.shape[0] == self.num_timesteps, 'alphas have to be defined for each timestep' + + to_torch = partial(torch.tensor, dtype=torch.float32) + + self.register_buffer('betas', to_torch(betas)) + self.register_buffer('alphas_cumprod', to_torch(alphas_cumprod)) + self.register_buffer('alphas_cumprod_prev', to_torch(alphas_cumprod_prev)) + + # calculations for diffusion q(x_t | x_{t-1}) and others + self.register_buffer('sqrt_alphas_cumprod', to_torch(np.sqrt(alphas_cumprod))) + self.register_buffer('sqrt_one_minus_alphas_cumprod', to_torch(np.sqrt(1. - alphas_cumprod))) + self.register_buffer('log_one_minus_alphas_cumprod', to_torch(np.log(1. - alphas_cumprod))) + self.register_buffer('sqrt_recip_alphas_cumprod', to_torch(np.sqrt(1. / alphas_cumprod))) + self.register_buffer('sqrt_recipm1_alphas_cumprod', to_torch(np.sqrt(1. / alphas_cumprod - 1))) + + def q_sample(self, x_start, t, noise=None): + noise = default(noise, lambda: torch.randn_like(x_start)) + return (extract_into_tensor(self.sqrt_alphas_cumprod, t, x_start.shape) * x_start + + extract_into_tensor(self.sqrt_one_minus_alphas_cumprod, t, x_start.shape) * noise) + + def forward(self, x): + z = self.model.encode(x).sample() + z = z * self.scale_factor + noise_level = torch.randint(0, self.max_noise_level, (x.shape[0],), device=x.device).long() + z = self.q_sample(z, noise_level) + if self.out_size is not None: + z = torch.nn.functional.interpolate(z, size=self.out_size, mode="nearest") # TODO: experiment with mode + # z = z.repeat_interleave(2, -2).repeat_interleave(2, -1) + return z, noise_level + + def decode(self, z): + z = z / self.scale_factor + return self.model.decode(z) + + +if __name__ == "__main__": + from ldm.util import count_params + sentences = ["a hedgehog drinking a whiskey", "der mond ist aufgegangen", "Ein Satz mit vielen Sonderzeichen: äöü ß ?! : 'xx-y/@s'"] + model = FrozenT5Embedder(version="google/t5-v1_1-xl").cuda() + count_params(model, True) + z = model(sentences) + print(z.shape) + + model = FrozenCLIPEmbedder().cuda() + count_params(model, True) + z = model(sentences) + print(z.shape) + + print("done.") diff --git a/ldm/modules/evaluate/adm_evaluator.py b/ldm/modules/evaluate/adm_evaluator.py new file mode 100755 index 0000000..508cddf --- /dev/null +++ b/ldm/modules/evaluate/adm_evaluator.py @@ -0,0 +1,676 @@ +import argparse +import io +import os +import random +import warnings +import zipfile +from abc import ABC, abstractmethod +from contextlib import contextmanager +from functools import partial +from multiprocessing import cpu_count +from multiprocessing.pool import ThreadPool +from typing import Iterable, Optional, Tuple +import yaml + +import numpy as np +import requests +import tensorflow.compat.v1 as tf +from scipy import linalg +from tqdm.auto import tqdm + +INCEPTION_V3_URL = "https://openaipublic.blob.core.windows.net/diffusion/jul-2021/ref_batches/classify_image_graph_def.pb" +INCEPTION_V3_PATH = "classify_image_graph_def.pb" + +FID_POOL_NAME = "pool_3:0" +FID_SPATIAL_NAME = "mixed_6/conv:0" + +REQUIREMENTS = f"This script has the following requirements: \n" \ + 'tensorflow-gpu>=2.0' + "\n" + 'scipy' + "\n" + "requests" + "\n" + "tqdm" + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("--ref_batch", help="path to reference batch npz file") + parser.add_argument("--sample_batch", help="path to sample batch npz file") + args = parser.parse_args() + + config = tf.ConfigProto( + allow_soft_placement=True # allows DecodeJpeg to run on CPU in Inception graph + ) + config.gpu_options.allow_growth = True + evaluator = Evaluator(tf.Session(config=config)) + + print("warming up TensorFlow...") + # This will cause TF to print a bunch of verbose stuff now rather + # than after the next print(), to help prevent confusion. + evaluator.warmup() + + print("computing reference batch activations...") + ref_acts = evaluator.read_activations(args.ref_batch) + print("computing/reading reference batch statistics...") + ref_stats, ref_stats_spatial = evaluator.read_statistics(args.ref_batch, ref_acts) + + print("computing sample batch activations...") + sample_acts = evaluator.read_activations(args.sample_batch) + print("computing/reading sample batch statistics...") + sample_stats, sample_stats_spatial = evaluator.read_statistics(args.sample_batch, sample_acts) + + print("Computing evaluations...") + is_ = evaluator.compute_inception_score(sample_acts[0]) + print("Inception Score:", is_) + fid = sample_stats.frechet_distance(ref_stats) + print("FID:", fid) + sfid = sample_stats_spatial.frechet_distance(ref_stats_spatial) + print("sFID:", sfid) + prec, recall = evaluator.compute_prec_recall(ref_acts[0], sample_acts[0]) + print("Precision:", prec) + print("Recall:", recall) + + savepath = '/'.join(args.sample_batch.split('/')[:-1]) + results_file = os.path.join(savepath,'evaluation_metrics.yaml') + print(f'Saving evaluation results to "{results_file}"') + + results = { + 'IS': is_, + 'FID': fid, + 'sFID': sfid, + 'Precision:':prec, + 'Recall': recall + } + + with open(results_file, 'w') as f: + yaml.dump(results, f, default_flow_style=False) + +class InvalidFIDException(Exception): + pass + + +class FIDStatistics: + def __init__(self, mu: np.ndarray, sigma: np.ndarray): + self.mu = mu + self.sigma = sigma + + def frechet_distance(self, other, eps=1e-6): + """ + Compute the Frechet distance between two sets of statistics. + """ + # https://github.com/bioinf-jku/TTUR/blob/73ab375cdf952a12686d9aa7978567771084da42/fid.py#L132 + mu1, sigma1 = self.mu, self.sigma + mu2, sigma2 = other.mu, other.sigma + + mu1 = np.atleast_1d(mu1) + mu2 = np.atleast_1d(mu2) + + sigma1 = np.atleast_2d(sigma1) + sigma2 = np.atleast_2d(sigma2) + + assert ( + mu1.shape == mu2.shape + ), f"Training and test mean vectors have different lengths: {mu1.shape}, {mu2.shape}" + assert ( + sigma1.shape == sigma2.shape + ), f"Training and test covariances have different dimensions: {sigma1.shape}, {sigma2.shape}" + + diff = mu1 - mu2 + + # product might be almost singular + covmean, _ = linalg.sqrtm(sigma1.dot(sigma2), disp=False) + if not np.isfinite(covmean).all(): + msg = ( + "fid calculation produces singular product; adding %s to diagonal of cov estimates" + % eps + ) + warnings.warn(msg) + offset = np.eye(sigma1.shape[0]) * eps + covmean = linalg.sqrtm((sigma1 + offset).dot(sigma2 + offset)) + + # numerical error might give slight imaginary component + if np.iscomplexobj(covmean): + if not np.allclose(np.diagonal(covmean).imag, 0, atol=1e-3): + m = np.max(np.abs(covmean.imag)) + raise ValueError("Imaginary component {}".format(m)) + covmean = covmean.real + + tr_covmean = np.trace(covmean) + + return diff.dot(diff) + np.trace(sigma1) + np.trace(sigma2) - 2 * tr_covmean + + +class Evaluator: + def __init__( + self, + session, + batch_size=64, + softmax_batch_size=512, + ): + self.sess = session + self.batch_size = batch_size + self.softmax_batch_size = softmax_batch_size + self.manifold_estimator = ManifoldEstimator(session) + with self.sess.graph.as_default(): + self.image_input = tf.placeholder(tf.float32, shape=[None, None, None, 3]) + self.softmax_input = tf.placeholder(tf.float32, shape=[None, 2048]) + self.pool_features, self.spatial_features = _create_feature_graph(self.image_input) + self.softmax = _create_softmax_graph(self.softmax_input) + + def warmup(self): + self.compute_activations(np.zeros([1, 8, 64, 64, 3])) + + def read_activations(self, npz_path: str) -> Tuple[np.ndarray, np.ndarray]: + with open_npz_array(npz_path, "arr_0") as reader: + return self.compute_activations(reader.read_batches(self.batch_size)) + + def compute_activations(self, batches: Iterable[np.ndarray],silent=False) -> Tuple[np.ndarray, np.ndarray]: + """ + Compute image features for downstream evals. + + :param batches: a iterator over NHWC numpy arrays in [0, 255]. + :return: a tuple of numpy arrays of shape [N x X], where X is a feature + dimension. The tuple is (pool_3, spatial). + """ + preds = [] + spatial_preds = [] + it = batches if silent else tqdm(batches) + for batch in it: + batch = batch.astype(np.float32) + pred, spatial_pred = self.sess.run( + [self.pool_features, self.spatial_features], {self.image_input: batch} + ) + preds.append(pred.reshape([pred.shape[0], -1])) + spatial_preds.append(spatial_pred.reshape([spatial_pred.shape[0], -1])) + return ( + np.concatenate(preds, axis=0), + np.concatenate(spatial_preds, axis=0), + ) + + def read_statistics( + self, npz_path: str, activations: Tuple[np.ndarray, np.ndarray] + ) -> Tuple[FIDStatistics, FIDStatistics]: + obj = np.load(npz_path) + if "mu" in list(obj.keys()): + return FIDStatistics(obj["mu"], obj["sigma"]), FIDStatistics( + obj["mu_s"], obj["sigma_s"] + ) + return tuple(self.compute_statistics(x) for x in activations) + + def compute_statistics(self, activations: np.ndarray) -> FIDStatistics: + mu = np.mean(activations, axis=0) + sigma = np.cov(activations, rowvar=False) + return FIDStatistics(mu, sigma) + + def compute_inception_score(self, activations: np.ndarray, split_size: int = 5000) -> float: + softmax_out = [] + for i in range(0, len(activations), self.softmax_batch_size): + acts = activations[i : i + self.softmax_batch_size] + softmax_out.append(self.sess.run(self.softmax, feed_dict={self.softmax_input: acts})) + preds = np.concatenate(softmax_out, axis=0) + # https://github.com/openai/improved-gan/blob/4f5d1ec5c16a7eceb206f42bfc652693601e1d5c/inception_score/model.py#L46 + scores = [] + for i in range(0, len(preds), split_size): + part = preds[i : i + split_size] + kl = part * (np.log(part) - np.log(np.expand_dims(np.mean(part, 0), 0))) + kl = np.mean(np.sum(kl, 1)) + scores.append(np.exp(kl)) + return float(np.mean(scores)) + + def compute_prec_recall( + self, activations_ref: np.ndarray, activations_sample: np.ndarray + ) -> Tuple[float, float]: + radii_1 = self.manifold_estimator.manifold_radii(activations_ref) + radii_2 = self.manifold_estimator.manifold_radii(activations_sample) + pr = self.manifold_estimator.evaluate_pr( + activations_ref, radii_1, activations_sample, radii_2 + ) + return (float(pr[0][0]), float(pr[1][0])) + + +class ManifoldEstimator: + """ + A helper for comparing manifolds of feature vectors. + + Adapted from https://github.com/kynkaat/improved-precision-and-recall-metric/blob/f60f25e5ad933a79135c783fcda53de30f42c9b9/precision_recall.py#L57 + """ + + def __init__( + self, + session, + row_batch_size=10000, + col_batch_size=10000, + nhood_sizes=(3,), + clamp_to_percentile=None, + eps=1e-5, + ): + """ + Estimate the manifold of given feature vectors. + + :param session: the TensorFlow session. + :param row_batch_size: row batch size to compute pairwise distances + (parameter to trade-off between memory usage and performance). + :param col_batch_size: column batch size to compute pairwise distances. + :param nhood_sizes: number of neighbors used to estimate the manifold. + :param clamp_to_percentile: prune hyperspheres that have radius larger than + the given percentile. + :param eps: small number for numerical stability. + """ + self.distance_block = DistanceBlock(session) + self.row_batch_size = row_batch_size + self.col_batch_size = col_batch_size + self.nhood_sizes = nhood_sizes + self.num_nhoods = len(nhood_sizes) + self.clamp_to_percentile = clamp_to_percentile + self.eps = eps + + def warmup(self): + feats, radii = ( + np.zeros([1, 2048], dtype=np.float32), + np.zeros([1, 1], dtype=np.float32), + ) + self.evaluate_pr(feats, radii, feats, radii) + + def manifold_radii(self, features: np.ndarray) -> np.ndarray: + num_images = len(features) + + # Estimate manifold of features by calculating distances to k-NN of each sample. + radii = np.zeros([num_images, self.num_nhoods], dtype=np.float32) + distance_batch = np.zeros([self.row_batch_size, num_images], dtype=np.float32) + seq = np.arange(max(self.nhood_sizes) + 1, dtype=np.int32) + + for begin1 in range(0, num_images, self.row_batch_size): + end1 = min(begin1 + self.row_batch_size, num_images) + row_batch = features[begin1:end1] + + for begin2 in range(0, num_images, self.col_batch_size): + end2 = min(begin2 + self.col_batch_size, num_images) + col_batch = features[begin2:end2] + + # Compute distances between batches. + distance_batch[ + 0 : end1 - begin1, begin2:end2 + ] = self.distance_block.pairwise_distances(row_batch, col_batch) + + # Find the k-nearest neighbor from the current batch. + radii[begin1:end1, :] = np.concatenate( + [ + x[:, self.nhood_sizes] + for x in _numpy_partition(distance_batch[0 : end1 - begin1, :], seq, axis=1) + ], + axis=0, + ) + + if self.clamp_to_percentile is not None: + max_distances = np.percentile(radii, self.clamp_to_percentile, axis=0) + radii[radii > max_distances] = 0 + return radii + + def evaluate(self, features: np.ndarray, radii: np.ndarray, eval_features: np.ndarray): + """ + Evaluate if new feature vectors are at the manifold. + """ + num_eval_images = eval_features.shape[0] + num_ref_images = radii.shape[0] + distance_batch = np.zeros([self.row_batch_size, num_ref_images], dtype=np.float32) + batch_predictions = np.zeros([num_eval_images, self.num_nhoods], dtype=np.int32) + max_realism_score = np.zeros([num_eval_images], dtype=np.float32) + nearest_indices = np.zeros([num_eval_images], dtype=np.int32) + + for begin1 in range(0, num_eval_images, self.row_batch_size): + end1 = min(begin1 + self.row_batch_size, num_eval_images) + feature_batch = eval_features[begin1:end1] + + for begin2 in range(0, num_ref_images, self.col_batch_size): + end2 = min(begin2 + self.col_batch_size, num_ref_images) + ref_batch = features[begin2:end2] + + distance_batch[ + 0 : end1 - begin1, begin2:end2 + ] = self.distance_block.pairwise_distances(feature_batch, ref_batch) + + # From the minibatch of new feature vectors, determine if they are in the estimated manifold. + # If a feature vector is inside a hypersphere of some reference sample, then + # the new sample lies at the estimated manifold. + # The radii of the hyperspheres are determined from distances of neighborhood size k. + samples_in_manifold = distance_batch[0 : end1 - begin1, :, None] <= radii + batch_predictions[begin1:end1] = np.any(samples_in_manifold, axis=1).astype(np.int32) + + max_realism_score[begin1:end1] = np.max( + radii[:, 0] / (distance_batch[0 : end1 - begin1, :] + self.eps), axis=1 + ) + nearest_indices[begin1:end1] = np.argmin(distance_batch[0 : end1 - begin1, :], axis=1) + + return { + "fraction": float(np.mean(batch_predictions)), + "batch_predictions": batch_predictions, + "max_realisim_score": max_realism_score, + "nearest_indices": nearest_indices, + } + + def evaluate_pr( + self, + features_1: np.ndarray, + radii_1: np.ndarray, + features_2: np.ndarray, + radii_2: np.ndarray, + ) -> Tuple[np.ndarray, np.ndarray]: + """ + Evaluate precision and recall efficiently. + + :param features_1: [N1 x D] feature vectors for reference batch. + :param radii_1: [N1 x K1] radii for reference vectors. + :param features_2: [N2 x D] feature vectors for the other batch. + :param radii_2: [N x K2] radii for other vectors. + :return: a tuple of arrays for (precision, recall): + - precision: an np.ndarray of length K1 + - recall: an np.ndarray of length K2 + """ + features_1_status = np.zeros([len(features_1), radii_2.shape[1]], dtype=np.bool) + features_2_status = np.zeros([len(features_2), radii_1.shape[1]], dtype=np.bool) + for begin_1 in range(0, len(features_1), self.row_batch_size): + end_1 = begin_1 + self.row_batch_size + batch_1 = features_1[begin_1:end_1] + for begin_2 in range(0, len(features_2), self.col_batch_size): + end_2 = begin_2 + self.col_batch_size + batch_2 = features_2[begin_2:end_2] + batch_1_in, batch_2_in = self.distance_block.less_thans( + batch_1, radii_1[begin_1:end_1], batch_2, radii_2[begin_2:end_2] + ) + features_1_status[begin_1:end_1] |= batch_1_in + features_2_status[begin_2:end_2] |= batch_2_in + return ( + np.mean(features_2_status.astype(np.float64), axis=0), + np.mean(features_1_status.astype(np.float64), axis=0), + ) + + +class DistanceBlock: + """ + Calculate pairwise distances between vectors. + + Adapted from https://github.com/kynkaat/improved-precision-and-recall-metric/blob/f60f25e5ad933a79135c783fcda53de30f42c9b9/precision_recall.py#L34 + """ + + def __init__(self, session): + self.session = session + + # Initialize TF graph to calculate pairwise distances. + with session.graph.as_default(): + self._features_batch1 = tf.placeholder(tf.float32, shape=[None, None]) + self._features_batch2 = tf.placeholder(tf.float32, shape=[None, None]) + distance_block_16 = _batch_pairwise_distances( + tf.cast(self._features_batch1, tf.float16), + tf.cast(self._features_batch2, tf.float16), + ) + self.distance_block = tf.cond( + tf.reduce_all(tf.math.is_finite(distance_block_16)), + lambda: tf.cast(distance_block_16, tf.float32), + lambda: _batch_pairwise_distances(self._features_batch1, self._features_batch2), + ) + + # Extra logic for less thans. + self._radii1 = tf.placeholder(tf.float32, shape=[None, None]) + self._radii2 = tf.placeholder(tf.float32, shape=[None, None]) + dist32 = tf.cast(self.distance_block, tf.float32)[..., None] + self._batch_1_in = tf.math.reduce_any(dist32 <= self._radii2, axis=1) + self._batch_2_in = tf.math.reduce_any(dist32 <= self._radii1[:, None], axis=0) + + def pairwise_distances(self, U, V): + """ + Evaluate pairwise distances between two batches of feature vectors. + """ + return self.session.run( + self.distance_block, + feed_dict={self._features_batch1: U, self._features_batch2: V}, + ) + + def less_thans(self, batch_1, radii_1, batch_2, radii_2): + return self.session.run( + [self._batch_1_in, self._batch_2_in], + feed_dict={ + self._features_batch1: batch_1, + self._features_batch2: batch_2, + self._radii1: radii_1, + self._radii2: radii_2, + }, + ) + + +def _batch_pairwise_distances(U, V): + """ + Compute pairwise distances between two batches of feature vectors. + """ + with tf.variable_scope("pairwise_dist_block"): + # Squared norms of each row in U and V. + norm_u = tf.reduce_sum(tf.square(U), 1) + norm_v = tf.reduce_sum(tf.square(V), 1) + + # norm_u as a column and norm_v as a row vectors. + norm_u = tf.reshape(norm_u, [-1, 1]) + norm_v = tf.reshape(norm_v, [1, -1]) + + # Pairwise squared Euclidean distances. + D = tf.maximum(norm_u - 2 * tf.matmul(U, V, False, True) + norm_v, 0.0) + + return D + + +class NpzArrayReader(ABC): + @abstractmethod + def read_batch(self, batch_size: int) -> Optional[np.ndarray]: + pass + + @abstractmethod + def remaining(self) -> int: + pass + + def read_batches(self, batch_size: int) -> Iterable[np.ndarray]: + def gen_fn(): + while True: + batch = self.read_batch(batch_size) + if batch is None: + break + yield batch + + rem = self.remaining() + num_batches = rem // batch_size + int(rem % batch_size != 0) + return BatchIterator(gen_fn, num_batches) + + +class BatchIterator: + def __init__(self, gen_fn, length): + self.gen_fn = gen_fn + self.length = length + + def __len__(self): + return self.length + + def __iter__(self): + return self.gen_fn() + + +class StreamingNpzArrayReader(NpzArrayReader): + def __init__(self, arr_f, shape, dtype): + self.arr_f = arr_f + self.shape = shape + self.dtype = dtype + self.idx = 0 + + def read_batch(self, batch_size: int) -> Optional[np.ndarray]: + if self.idx >= self.shape[0]: + return None + + bs = min(batch_size, self.shape[0] - self.idx) + self.idx += bs + + if self.dtype.itemsize == 0: + return np.ndarray([bs, *self.shape[1:]], dtype=self.dtype) + + read_count = bs * np.prod(self.shape[1:]) + read_size = int(read_count * self.dtype.itemsize) + data = _read_bytes(self.arr_f, read_size, "array data") + return np.frombuffer(data, dtype=self.dtype).reshape([bs, *self.shape[1:]]) + + def remaining(self) -> int: + return max(0, self.shape[0] - self.idx) + + +class MemoryNpzArrayReader(NpzArrayReader): + def __init__(self, arr): + self.arr = arr + self.idx = 0 + + @classmethod + def load(cls, path: str, arr_name: str): + with open(path, "rb") as f: + arr = np.load(f)[arr_name] + return cls(arr) + + def read_batch(self, batch_size: int) -> Optional[np.ndarray]: + if self.idx >= self.arr.shape[0]: + return None + + res = self.arr[self.idx : self.idx + batch_size] + self.idx += batch_size + return res + + def remaining(self) -> int: + return max(0, self.arr.shape[0] - self.idx) + + +@contextmanager +def open_npz_array(path: str, arr_name: str) -> NpzArrayReader: + with _open_npy_file(path, arr_name) as arr_f: + version = np.lib.format.read_magic(arr_f) + if version == (1, 0): + header = np.lib.format.read_array_header_1_0(arr_f) + elif version == (2, 0): + header = np.lib.format.read_array_header_2_0(arr_f) + else: + yield MemoryNpzArrayReader.load(path, arr_name) + return + shape, fortran, dtype = header + if fortran or dtype.hasobject: + yield MemoryNpzArrayReader.load(path, arr_name) + else: + yield StreamingNpzArrayReader(arr_f, shape, dtype) + + +def _read_bytes(fp, size, error_template="ran out of data"): + """ + Copied from: https://github.com/numpy/numpy/blob/fb215c76967739268de71aa4bda55dd1b062bc2e/numpy/lib/format.py#L788-L886 + + Read from file-like object until size bytes are read. + Raises ValueError if not EOF is encountered before size bytes are read. + Non-blocking objects only supported if they derive from io objects. + Required as e.g. ZipExtFile in python 2.6 can return less data than + requested. + """ + data = bytes() + while True: + # io files (default in python3) return None or raise on + # would-block, python2 file will truncate, probably nothing can be + # done about that. note that regular files can't be non-blocking + try: + r = fp.read(size - len(data)) + data += r + if len(r) == 0 or len(data) == size: + break + except io.BlockingIOError: + pass + if len(data) != size: + msg = "EOF: reading %s, expected %d bytes got %d" + raise ValueError(msg % (error_template, size, len(data))) + else: + return data + + +@contextmanager +def _open_npy_file(path: str, arr_name: str): + with open(path, "rb") as f: + with zipfile.ZipFile(f, "r") as zip_f: + if f"{arr_name}.npy" not in zip_f.namelist(): + raise ValueError(f"missing {arr_name} in npz file") + with zip_f.open(f"{arr_name}.npy", "r") as arr_f: + yield arr_f + + +def _download_inception_model(): + if os.path.exists(INCEPTION_V3_PATH): + return + print("downloading InceptionV3 model...") + with requests.get(INCEPTION_V3_URL, stream=True) as r: + r.raise_for_status() + tmp_path = INCEPTION_V3_PATH + ".tmp" + with open(tmp_path, "wb") as f: + for chunk in tqdm(r.iter_content(chunk_size=8192)): + f.write(chunk) + os.rename(tmp_path, INCEPTION_V3_PATH) + + +def _create_feature_graph(input_batch): + _download_inception_model() + prefix = f"{random.randrange(2**32)}_{random.randrange(2**32)}" + with open(INCEPTION_V3_PATH, "rb") as f: + graph_def = tf.GraphDef() + graph_def.ParseFromString(f.read()) + pool3, spatial = tf.import_graph_def( + graph_def, + input_map={f"ExpandDims:0": input_batch}, + return_elements=[FID_POOL_NAME, FID_SPATIAL_NAME], + name=prefix, + ) + _update_shapes(pool3) + spatial = spatial[..., :7] + return pool3, spatial + + +def _create_softmax_graph(input_batch): + _download_inception_model() + prefix = f"{random.randrange(2**32)}_{random.randrange(2**32)}" + with open(INCEPTION_V3_PATH, "rb") as f: + graph_def = tf.GraphDef() + graph_def.ParseFromString(f.read()) + (matmul,) = tf.import_graph_def( + graph_def, return_elements=[f"softmax/logits/MatMul"], name=prefix + ) + w = matmul.inputs[1] + logits = tf.matmul(input_batch, w) + return tf.nn.softmax(logits) + + +def _update_shapes(pool3): + # https://github.com/bioinf-jku/TTUR/blob/73ab375cdf952a12686d9aa7978567771084da42/fid.py#L50-L63 + ops = pool3.graph.get_operations() + for op in ops: + for o in op.outputs: + shape = o.get_shape() + if shape._dims is not None: # pylint: disable=protected-access + # shape = [s.value for s in shape] TF 1.x + shape = [s for s in shape] # TF 2.x + new_shape = [] + for j, s in enumerate(shape): + if s == 1 and j == 0: + new_shape.append(None) + else: + new_shape.append(s) + o.__dict__["_shape_val"] = tf.TensorShape(new_shape) + return pool3 + + +def _numpy_partition(arr, kth, **kwargs): + num_workers = min(cpu_count(), len(arr)) + chunk_size = len(arr) // num_workers + extra = len(arr) % num_workers + + start_idx = 0 + batches = [] + for i in range(num_workers): + size = chunk_size + (1 if i < extra else 0) + batches.append(arr[start_idx : start_idx + size]) + start_idx += size + + with ThreadPool(num_workers) as pool: + return list(pool.map(partial(np.partition, kth=kth, **kwargs), batches)) + + +if __name__ == "__main__": + print(REQUIREMENTS) + main() diff --git a/ldm/modules/evaluate/evaluate_perceptualsim.py b/ldm/modules/evaluate/evaluate_perceptualsim.py new file mode 100755 index 0000000..c85fef9 --- /dev/null +++ b/ldm/modules/evaluate/evaluate_perceptualsim.py @@ -0,0 +1,630 @@ +import argparse +import glob +import os +from tqdm import tqdm +from collections import namedtuple + +import numpy as np +import torch +import torchvision.transforms as transforms +from torchvision import models +from PIL import Image + +from ldm.modules.evaluate.ssim import ssim + + +transform = transforms.Compose([transforms.ToTensor()]) + +def normalize_tensor(in_feat, eps=1e-10): + norm_factor = torch.sqrt(torch.sum(in_feat ** 2, dim=1)).view( + in_feat.size()[0], 1, in_feat.size()[2], in_feat.size()[3] + ) + return in_feat / (norm_factor.expand_as(in_feat) + eps) + + +def cos_sim(in0, in1): + in0_norm = normalize_tensor(in0) + in1_norm = normalize_tensor(in1) + N = in0.size()[0] + X = in0.size()[2] + Y = in0.size()[3] + + return torch.mean( + torch.mean( + torch.sum(in0_norm * in1_norm, dim=1).view(N, 1, X, Y), dim=2 + ).view(N, 1, 1, Y), + dim=3, + ).view(N) + + +class squeezenet(torch.nn.Module): + def __init__(self, requires_grad=False, pretrained=True): + super(squeezenet, self).__init__() + pretrained_features = models.squeezenet1_1( + pretrained=pretrained + ).features + self.slice1 = torch.nn.Sequential() + self.slice2 = torch.nn.Sequential() + self.slice3 = torch.nn.Sequential() + self.slice4 = torch.nn.Sequential() + self.slice5 = torch.nn.Sequential() + self.slice6 = torch.nn.Sequential() + self.slice7 = torch.nn.Sequential() + self.N_slices = 7 + for x in range(2): + self.slice1.add_module(str(x), pretrained_features[x]) + for x in range(2, 5): + self.slice2.add_module(str(x), pretrained_features[x]) + for x in range(5, 8): + self.slice3.add_module(str(x), pretrained_features[x]) + for x in range(8, 10): + self.slice4.add_module(str(x), pretrained_features[x]) + for x in range(10, 11): + self.slice5.add_module(str(x), pretrained_features[x]) + for x in range(11, 12): + self.slice6.add_module(str(x), pretrained_features[x]) + for x in range(12, 13): + self.slice7.add_module(str(x), pretrained_features[x]) + if not requires_grad: + for param in self.parameters(): + param.requires_grad = False + + def forward(self, X): + h = self.slice1(X) + h_relu1 = h + h = self.slice2(h) + h_relu2 = h + h = self.slice3(h) + h_relu3 = h + h = self.slice4(h) + h_relu4 = h + h = self.slice5(h) + h_relu5 = h + h = self.slice6(h) + h_relu6 = h + h = self.slice7(h) + h_relu7 = h + vgg_outputs = namedtuple( + "SqueezeOutputs", + ["relu1", "relu2", "relu3", "relu4", "relu5", "relu6", "relu7"], + ) + out = vgg_outputs( + h_relu1, h_relu2, h_relu3, h_relu4, h_relu5, h_relu6, h_relu7 + ) + + return out + + +class alexnet(torch.nn.Module): + def __init__(self, requires_grad=False, pretrained=True): + super(alexnet, self).__init__() + alexnet_pretrained_features = models.alexnet( + pretrained=pretrained + ).features + self.slice1 = torch.nn.Sequential() + self.slice2 = torch.nn.Sequential() + self.slice3 = torch.nn.Sequential() + self.slice4 = torch.nn.Sequential() + self.slice5 = torch.nn.Sequential() + self.N_slices = 5 + for x in range(2): + self.slice1.add_module(str(x), alexnet_pretrained_features[x]) + for x in range(2, 5): + self.slice2.add_module(str(x), alexnet_pretrained_features[x]) + for x in range(5, 8): + self.slice3.add_module(str(x), alexnet_pretrained_features[x]) + for x in range(8, 10): + self.slice4.add_module(str(x), alexnet_pretrained_features[x]) + for x in range(10, 12): + self.slice5.add_module(str(x), alexnet_pretrained_features[x]) + if not requires_grad: + for param in self.parameters(): + param.requires_grad = False + + def forward(self, X): + h = self.slice1(X) + h_relu1 = h + h = self.slice2(h) + h_relu2 = h + h = self.slice3(h) + h_relu3 = h + h = self.slice4(h) + h_relu4 = h + h = self.slice5(h) + h_relu5 = h + alexnet_outputs = namedtuple( + "AlexnetOutputs", ["relu1", "relu2", "relu3", "relu4", "relu5"] + ) + out = alexnet_outputs(h_relu1, h_relu2, h_relu3, h_relu4, h_relu5) + + return out + + +class vgg16(torch.nn.Module): + def __init__(self, requires_grad=False, pretrained=True): + super(vgg16, self).__init__() + vgg_pretrained_features = models.vgg16(pretrained=pretrained).features + self.slice1 = torch.nn.Sequential() + self.slice2 = torch.nn.Sequential() + self.slice3 = torch.nn.Sequential() + self.slice4 = torch.nn.Sequential() + self.slice5 = torch.nn.Sequential() + self.N_slices = 5 + for x in range(4): + self.slice1.add_module(str(x), vgg_pretrained_features[x]) + for x in range(4, 9): + self.slice2.add_module(str(x), vgg_pretrained_features[x]) + for x in range(9, 16): + self.slice3.add_module(str(x), vgg_pretrained_features[x]) + for x in range(16, 23): + self.slice4.add_module(str(x), vgg_pretrained_features[x]) + for x in range(23, 30): + self.slice5.add_module(str(x), vgg_pretrained_features[x]) + if not requires_grad: + for param in self.parameters(): + param.requires_grad = False + + def forward(self, X): + h = self.slice1(X) + h_relu1_2 = h + h = self.slice2(h) + h_relu2_2 = h + h = self.slice3(h) + h_relu3_3 = h + h = self.slice4(h) + h_relu4_3 = h + h = self.slice5(h) + h_relu5_3 = h + vgg_outputs = namedtuple( + "VggOutputs", + ["relu1_2", "relu2_2", "relu3_3", "relu4_3", "relu5_3"], + ) + out = vgg_outputs(h_relu1_2, h_relu2_2, h_relu3_3, h_relu4_3, h_relu5_3) + + return out + + +class resnet(torch.nn.Module): + def __init__(self, requires_grad=False, pretrained=True, num=18): + super(resnet, self).__init__() + if num == 18: + self.net = models.resnet18(pretrained=pretrained) + elif num == 34: + self.net = models.resnet34(pretrained=pretrained) + elif num == 50: + self.net = models.resnet50(pretrained=pretrained) + elif num == 101: + self.net = models.resnet101(pretrained=pretrained) + elif num == 152: + self.net = models.resnet152(pretrained=pretrained) + self.N_slices = 5 + + self.conv1 = self.net.conv1 + self.bn1 = self.net.bn1 + self.relu = self.net.relu + self.maxpool = self.net.maxpool + self.layer1 = self.net.layer1 + self.layer2 = self.net.layer2 + self.layer3 = self.net.layer3 + self.layer4 = self.net.layer4 + + def forward(self, X): + h = self.conv1(X) + h = self.bn1(h) + h = self.relu(h) + h_relu1 = h + h = self.maxpool(h) + h = self.layer1(h) + h_conv2 = h + h = self.layer2(h) + h_conv3 = h + h = self.layer3(h) + h_conv4 = h + h = self.layer4(h) + h_conv5 = h + + outputs = namedtuple( + "Outputs", ["relu1", "conv2", "conv3", "conv4", "conv5"] + ) + out = outputs(h_relu1, h_conv2, h_conv3, h_conv4, h_conv5) + + return out + +# Off-the-shelf deep network +class PNet(torch.nn.Module): + """Pre-trained network with all channels equally weighted by default""" + + def __init__(self, pnet_type="vgg", pnet_rand=False, use_gpu=True): + super(PNet, self).__init__() + + self.use_gpu = use_gpu + + self.pnet_type = pnet_type + self.pnet_rand = pnet_rand + + self.shift = torch.Tensor([-0.030, -0.088, -0.188]).view(1, 3, 1, 1) + self.scale = torch.Tensor([0.458, 0.448, 0.450]).view(1, 3, 1, 1) + + if self.pnet_type in ["vgg", "vgg16"]: + self.net = vgg16(pretrained=not self.pnet_rand, requires_grad=False) + elif self.pnet_type == "alex": + self.net = alexnet( + pretrained=not self.pnet_rand, requires_grad=False + ) + elif self.pnet_type[:-2] == "resnet": + self.net = resnet( + pretrained=not self.pnet_rand, + requires_grad=False, + num=int(self.pnet_type[-2:]), + ) + elif self.pnet_type == "squeeze": + self.net = squeezenet( + pretrained=not self.pnet_rand, requires_grad=False + ) + + self.L = self.net.N_slices + + if use_gpu: + self.net.cuda() + self.shift = self.shift.cuda() + self.scale = self.scale.cuda() + + def forward(self, in0, in1, retPerLayer=False): + in0_sc = (in0 - self.shift.expand_as(in0)) / self.scale.expand_as(in0) + in1_sc = (in1 - self.shift.expand_as(in0)) / self.scale.expand_as(in0) + + outs0 = self.net.forward(in0_sc) + outs1 = self.net.forward(in1_sc) + + if retPerLayer: + all_scores = [] + for (kk, out0) in enumerate(outs0): + cur_score = 1.0 - cos_sim(outs0[kk], outs1[kk]) + if kk == 0: + val = 1.0 * cur_score + else: + val = val + cur_score + if retPerLayer: + all_scores += [cur_score] + + if retPerLayer: + return (val, all_scores) + else: + return val + + + + +# The SSIM metric +def ssim_metric(img1, img2, mask=None): + return ssim(img1, img2, mask=mask, size_average=False) + + +# The PSNR metric +def psnr(img1, img2, mask=None,reshape=False): + b = img1.size(0) + if not (mask is None): + b = img1.size(0) + mse_err = (img1 - img2).pow(2) * mask + if reshape: + mse_err = mse_err.reshape(b, -1).sum(dim=1) / ( + 3 * mask.reshape(b, -1).sum(dim=1).clamp(min=1) + ) + else: + mse_err = mse_err.view(b, -1).sum(dim=1) / ( + 3 * mask.view(b, -1).sum(dim=1).clamp(min=1) + ) + else: + if reshape: + mse_err = (img1 - img2).pow(2).reshape(b, -1).mean(dim=1) + else: + mse_err = (img1 - img2).pow(2).view(b, -1).mean(dim=1) + + psnr = 10 * (1 / mse_err).log10() + return psnr + + +# The perceptual similarity metric +def perceptual_sim(img1, img2, vgg16): + # First extract features + dist = vgg16(img1 * 2 - 1, img2 * 2 - 1) + + return dist + +def load_img(img_name, size=None): + try: + img = Image.open(img_name) + + if type(size) == int: + img = img.resize((size, size)) + elif size is not None: + img = img.resize((size[1], size[0])) + + img = transform(img).cuda() + img = img.unsqueeze(0) + except Exception as e: + print("Failed at loading %s " % img_name) + print(e) + img = torch.zeros(1, 3, 256, 256).cuda() + raise + return img + + +def compute_perceptual_similarity(folder, pred_img, tgt_img, take_every_other): + + # Load VGG16 for feature similarity + vgg16 = PNet().to("cuda") + vgg16.eval() + vgg16.cuda() + + values_percsim = [] + values_ssim = [] + values_psnr = [] + folders = os.listdir(folder) + for i, f in tqdm(enumerate(sorted(folders))): + pred_imgs = glob.glob(folder + f + "/" + pred_img) + tgt_imgs = glob.glob(folder + f + "/" + tgt_img) + assert len(tgt_imgs) == 1 + + perc_sim = 10000 + ssim_sim = -10 + psnr_sim = -10 + for p_img in pred_imgs: + t_img = load_img(tgt_imgs[0]) + p_img = load_img(p_img, size=t_img.shape[2:]) + t_perc_sim = perceptual_sim(p_img, t_img, vgg16).item() + perc_sim = min(perc_sim, t_perc_sim) + + ssim_sim = max(ssim_sim, ssim_metric(p_img, t_img).item()) + psnr_sim = max(psnr_sim, psnr(p_img, t_img).item()) + + values_percsim += [perc_sim] + values_ssim += [ssim_sim] + values_psnr += [psnr_sim] + + if take_every_other: + n_valuespercsim = [] + n_valuesssim = [] + n_valuespsnr = [] + for i in range(0, len(values_percsim) // 2): + n_valuespercsim += [ + min(values_percsim[2 * i], values_percsim[2 * i + 1]) + ] + n_valuespsnr += [max(values_psnr[2 * i], values_psnr[2 * i + 1])] + n_valuesssim += [max(values_ssim[2 * i], values_ssim[2 * i + 1])] + + values_percsim = n_valuespercsim + values_ssim = n_valuesssim + values_psnr = n_valuespsnr + + avg_percsim = np.mean(np.array(values_percsim)) + std_percsim = np.std(np.array(values_percsim)) + + avg_psnr = np.mean(np.array(values_psnr)) + std_psnr = np.std(np.array(values_psnr)) + + avg_ssim = np.mean(np.array(values_ssim)) + std_ssim = np.std(np.array(values_ssim)) + + return { + "Perceptual similarity": (avg_percsim, std_percsim), + "PSNR": (avg_psnr, std_psnr), + "SSIM": (avg_ssim, std_ssim), + } + + +def compute_perceptual_similarity_from_list(pred_imgs_list, tgt_imgs_list, + take_every_other, + simple_format=True): + + # Load VGG16 for feature similarity + vgg16 = PNet().to("cuda") + vgg16.eval() + vgg16.cuda() + + values_percsim = [] + values_ssim = [] + values_psnr = [] + equal_count = 0 + ambig_count = 0 + for i, tgt_img in enumerate(tqdm(tgt_imgs_list)): + pred_imgs = pred_imgs_list[i] + tgt_imgs = [tgt_img] + assert len(tgt_imgs) == 1 + + if type(pred_imgs) != list: + pred_imgs = [pred_imgs] + + perc_sim = 10000 + ssim_sim = -10 + psnr_sim = -10 + assert len(pred_imgs)>0 + for p_img in pred_imgs: + t_img = load_img(tgt_imgs[0]) + p_img = load_img(p_img, size=t_img.shape[2:]) + t_perc_sim = perceptual_sim(p_img, t_img, vgg16).item() + perc_sim = min(perc_sim, t_perc_sim) + + ssim_sim = max(ssim_sim, ssim_metric(p_img, t_img).item()) + psnr_sim = max(psnr_sim, psnr(p_img, t_img).item()) + + values_percsim += [perc_sim] + values_ssim += [ssim_sim] + if psnr_sim != np.float("inf"): + values_psnr += [psnr_sim] + else: + if torch.allclose(p_img, t_img): + equal_count += 1 + print("{} equal src and wrp images.".format(equal_count)) + else: + ambig_count += 1 + print("{} ambiguous src and wrp images.".format(ambig_count)) + + if take_every_other: + n_valuespercsim = [] + n_valuesssim = [] + n_valuespsnr = [] + for i in range(0, len(values_percsim) // 2): + n_valuespercsim += [ + min(values_percsim[2 * i], values_percsim[2 * i + 1]) + ] + n_valuespsnr += [max(values_psnr[2 * i], values_psnr[2 * i + 1])] + n_valuesssim += [max(values_ssim[2 * i], values_ssim[2 * i + 1])] + + values_percsim = n_valuespercsim + values_ssim = n_valuesssim + values_psnr = n_valuespsnr + + avg_percsim = np.mean(np.array(values_percsim)) + std_percsim = np.std(np.array(values_percsim)) + + avg_psnr = np.mean(np.array(values_psnr)) + std_psnr = np.std(np.array(values_psnr)) + + avg_ssim = np.mean(np.array(values_ssim)) + std_ssim = np.std(np.array(values_ssim)) + + if simple_format: + # just to make yaml formatting readable + return { + "Perceptual similarity": [float(avg_percsim), float(std_percsim)], + "PSNR": [float(avg_psnr), float(std_psnr)], + "SSIM": [float(avg_ssim), float(std_ssim)], + } + else: + return { + "Perceptual similarity": (avg_percsim, std_percsim), + "PSNR": (avg_psnr, std_psnr), + "SSIM": (avg_ssim, std_ssim), + } + + +def compute_perceptual_similarity_from_list_topk(pred_imgs_list, tgt_imgs_list, + take_every_other, resize=False): + + # Load VGG16 for feature similarity + vgg16 = PNet().to("cuda") + vgg16.eval() + vgg16.cuda() + + values_percsim = [] + values_ssim = [] + values_psnr = [] + individual_percsim = [] + individual_ssim = [] + individual_psnr = [] + for i, tgt_img in enumerate(tqdm(tgt_imgs_list)): + pred_imgs = pred_imgs_list[i] + tgt_imgs = [tgt_img] + assert len(tgt_imgs) == 1 + + if type(pred_imgs) != list: + assert False + pred_imgs = [pred_imgs] + + perc_sim = 10000 + ssim_sim = -10 + psnr_sim = -10 + sample_percsim = list() + sample_ssim = list() + sample_psnr = list() + for p_img in pred_imgs: + if resize: + t_img = load_img(tgt_imgs[0], size=(256,256)) + else: + t_img = load_img(tgt_imgs[0]) + p_img = load_img(p_img, size=t_img.shape[2:]) + + t_perc_sim = perceptual_sim(p_img, t_img, vgg16).item() + sample_percsim.append(t_perc_sim) + perc_sim = min(perc_sim, t_perc_sim) + + t_ssim = ssim_metric(p_img, t_img).item() + sample_ssim.append(t_ssim) + ssim_sim = max(ssim_sim, t_ssim) + + t_psnr = psnr(p_img, t_img).item() + sample_psnr.append(t_psnr) + psnr_sim = max(psnr_sim, t_psnr) + + values_percsim += [perc_sim] + values_ssim += [ssim_sim] + values_psnr += [psnr_sim] + individual_percsim.append(sample_percsim) + individual_ssim.append(sample_ssim) + individual_psnr.append(sample_psnr) + + if take_every_other: + assert False, "Do this later, after specifying topk to get proper results" + n_valuespercsim = [] + n_valuesssim = [] + n_valuespsnr = [] + for i in range(0, len(values_percsim) // 2): + n_valuespercsim += [ + min(values_percsim[2 * i], values_percsim[2 * i + 1]) + ] + n_valuespsnr += [max(values_psnr[2 * i], values_psnr[2 * i + 1])] + n_valuesssim += [max(values_ssim[2 * i], values_ssim[2 * i + 1])] + + values_percsim = n_valuespercsim + values_ssim = n_valuesssim + values_psnr = n_valuespsnr + + avg_percsim = np.mean(np.array(values_percsim)) + std_percsim = np.std(np.array(values_percsim)) + + avg_psnr = np.mean(np.array(values_psnr)) + std_psnr = np.std(np.array(values_psnr)) + + avg_ssim = np.mean(np.array(values_ssim)) + std_ssim = np.std(np.array(values_ssim)) + + individual_percsim = np.array(individual_percsim) + individual_psnr = np.array(individual_psnr) + individual_ssim = np.array(individual_ssim) + + return { + "avg_of_best": { + "Perceptual similarity": [float(avg_percsim), float(std_percsim)], + "PSNR": [float(avg_psnr), float(std_psnr)], + "SSIM": [float(avg_ssim), float(std_ssim)], + }, + "individual": { + "PSIM": individual_percsim, + "PSNR": individual_psnr, + "SSIM": individual_ssim, + } + } + + +if __name__ == "__main__": + args = argparse.ArgumentParser() + args.add_argument("--folder", type=str, default="") + args.add_argument("--pred_image", type=str, default="") + args.add_argument("--target_image", type=str, default="") + args.add_argument("--take_every_other", action="store_true", default=False) + args.add_argument("--output_file", type=str, default="") + + opts = args.parse_args() + + folder = opts.folder + pred_img = opts.pred_image + tgt_img = opts.target_image + + results = compute_perceptual_similarity( + folder, pred_img, tgt_img, opts.take_every_other + ) + + f = open(opts.output_file, 'w') + for key in results: + print("%s for %s: \n" % (key, opts.folder)) + print( + "\t {:0.4f} | {:0.4f} \n".format(results[key][0], results[key][1]) + ) + + f.write("%s for %s: \n" % (key, opts.folder)) + f.write( + "\t {:0.4f} | {:0.4f} \n".format(results[key][0], results[key][1]) + ) + + f.close() diff --git a/ldm/modules/evaluate/frechet_video_distance.py b/ldm/modules/evaluate/frechet_video_distance.py new file mode 100755 index 0000000..d9e13c4 --- /dev/null +++ b/ldm/modules/evaluate/frechet_video_distance.py @@ -0,0 +1,147 @@ +# coding=utf-8 +# Copyright 2022 The Google Research Authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# Lint as: python2, python3 +"""Minimal Reference implementation for the Frechet Video Distance (FVD). + +FVD is a metric for the quality of video generation models. It is inspired by +the FID (Frechet Inception Distance) used for images, but uses a different +embedding to be better suitable for videos. +""" + +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function + + +import six +import tensorflow.compat.v1 as tf +import tensorflow_gan as tfgan +import tensorflow_hub as hub + + +def preprocess(videos, target_resolution): + """Runs some preprocessing on the videos for I3D model. + + Args: + videos: [batch_size, num_frames, height, width, depth] The videos to be + preprocessed. We don't care about the specific dtype of the videos, it can + be anything that tf.image.resize_bilinear accepts. Values are expected to + be in the range 0-255. + target_resolution: (width, height): target video resolution + + Returns: + videos: [batch_size, num_frames, height, width, depth] + """ + videos_shape = list(videos.shape) + all_frames = tf.reshape(videos, [-1] + videos_shape[-3:]) + resized_videos = tf.image.resize_bilinear(all_frames, size=target_resolution) + target_shape = [videos_shape[0], -1] + list(target_resolution) + [3] + output_videos = tf.reshape(resized_videos, target_shape) + scaled_videos = 2. * tf.cast(output_videos, tf.float32) / 255. - 1 + return scaled_videos + + +def _is_in_graph(tensor_name): + """Checks whether a given tensor does exists in the graph.""" + try: + tf.get_default_graph().get_tensor_by_name(tensor_name) + except KeyError: + return False + return True + + +def create_id3_embedding(videos,warmup=False,batch_size=16): + """Embeds the given videos using the Inflated 3D Convolution ne twork. + + Downloads the graph of the I3D from tf.hub and adds it to the graph on the + first call. + + Args: + videos: [batch_size, num_frames, height=224, width=224, depth=3]. + Expected range is [-1, 1]. + + Returns: + embedding: [batch_size, embedding_size]. embedding_size depends + on the model used. + + Raises: + ValueError: when a provided embedding_layer is not supported. + """ + + # batch_size = 16 + module_spec = "https://tfhub.dev/deepmind/i3d-kinetics-400/1" + + + # Making sure that we import the graph separately for + # each different input video tensor. + module_name = "fvd_kinetics-400_id3_module_" + six.ensure_str( + videos.name).replace(":", "_") + + + + assert_ops = [ + tf.Assert( + tf.reduce_max(videos) <= 1.001, + ["max value in frame is > 1", videos]), + tf.Assert( + tf.reduce_min(videos) >= -1.001, + ["min value in frame is < -1", videos]), + tf.assert_equal( + tf.shape(videos)[0], + batch_size, ["invalid frame batch size: ", + tf.shape(videos)], + summarize=6), + ] + with tf.control_dependencies(assert_ops): + videos = tf.identity(videos) + + module_scope = "%s_apply_default/" % module_name + + # To check whether the module has already been loaded into the graph, we look + # for a given tensor name. If this tensor name exists, we assume the function + # has been called before and the graph was imported. Otherwise we import it. + # Note: in theory, the tensor could exist, but have wrong shapes. + # This will happen if create_id3_embedding is called with a frames_placehoder + # of wrong size/batch size, because even though that will throw a tf.Assert + # on graph-execution time, it will insert the tensor (with wrong shape) into + # the graph. This is why we need the following assert. + if warmup: + video_batch_size = int(videos.shape[0]) + assert video_batch_size in [batch_size, -1, None], f"Invalid batch size {video_batch_size}" + tensor_name = module_scope + "RGB/inception_i3d/Mean:0" + if not _is_in_graph(tensor_name): + i3d_model = hub.Module(module_spec, name=module_name) + i3d_model(videos) + + # gets the kinetics-i3d-400-logits layer + tensor_name = module_scope + "RGB/inception_i3d/Mean:0" + tensor = tf.get_default_graph().get_tensor_by_name(tensor_name) + return tensor + + +def calculate_fvd(real_activations, + generated_activations): + """Returns a list of ops that compute metrics as funcs of activations. + + Args: + real_activations: [num_samples, embedding_size] + generated_activations: [num_samples, embedding_size] + + Returns: + A scalar that contains the requested FVD. + """ + return tfgan.eval.frechet_classifier_distance_from_activations( + real_activations, generated_activations) diff --git a/ldm/modules/evaluate/ssim.py b/ldm/modules/evaluate/ssim.py new file mode 100755 index 0000000..4e8883c --- /dev/null +++ b/ldm/modules/evaluate/ssim.py @@ -0,0 +1,124 @@ +# MIT Licence + +# Methods to predict the SSIM, taken from +# https://github.com/Po-Hsun-Su/pytorch-ssim/blob/master/pytorch_ssim/__init__.py + +from math import exp + +import torch +import torch.nn.functional as F +from torch.autograd import Variable + +def gaussian(window_size, sigma): + gauss = torch.Tensor( + [ + exp(-((x - window_size // 2) ** 2) / float(2 * sigma ** 2)) + for x in range(window_size) + ] + ) + return gauss / gauss.sum() + + +def create_window(window_size, channel): + _1D_window = gaussian(window_size, 1.5).unsqueeze(1) + _2D_window = _1D_window.mm(_1D_window.t()).float().unsqueeze(0).unsqueeze(0) + window = Variable( + _2D_window.expand(channel, 1, window_size, window_size).contiguous() + ) + return window + + +def _ssim( + img1, img2, window, window_size, channel, mask=None, size_average=True +): + mu1 = F.conv2d(img1, window, padding=window_size // 2, groups=channel) + mu2 = F.conv2d(img2, window, padding=window_size // 2, groups=channel) + + mu1_sq = mu1.pow(2) + mu2_sq = mu2.pow(2) + mu1_mu2 = mu1 * mu2 + + sigma1_sq = ( + F.conv2d(img1 * img1, window, padding=window_size // 2, groups=channel) + - mu1_sq + ) + sigma2_sq = ( + F.conv2d(img2 * img2, window, padding=window_size // 2, groups=channel) + - mu2_sq + ) + sigma12 = ( + F.conv2d(img1 * img2, window, padding=window_size // 2, groups=channel) + - mu1_mu2 + ) + + C1 = (0.01) ** 2 + C2 = (0.03) ** 2 + + ssim_map = ((2 * mu1_mu2 + C1) * (2 * sigma12 + C2)) / ( + (mu1_sq + mu2_sq + C1) * (sigma1_sq + sigma2_sq + C2) + ) + + if not (mask is None): + b = mask.size(0) + ssim_map = ssim_map.mean(dim=1, keepdim=True) * mask + ssim_map = ssim_map.view(b, -1).sum(dim=1) / mask.view(b, -1).sum( + dim=1 + ).clamp(min=1) + return ssim_map + + import pdb + + pdb.set_trace + + if size_average: + return ssim_map.mean() + else: + return ssim_map.mean(1).mean(1).mean(1) + + +class SSIM(torch.nn.Module): + def __init__(self, window_size=11, size_average=True): + super(SSIM, self).__init__() + self.window_size = window_size + self.size_average = size_average + self.channel = 1 + self.window = create_window(window_size, self.channel) + + def forward(self, img1, img2, mask=None): + (_, channel, _, _) = img1.size() + + if ( + channel == self.channel + and self.window.data.type() == img1.data.type() + ): + window = self.window + else: + window = create_window(self.window_size, channel) + + if img1.is_cuda: + window = window.cuda(img1.get_device()) + window = window.type_as(img1) + + self.window = window + self.channel = channel + + return _ssim( + img1, + img2, + window, + self.window_size, + channel, + mask, + self.size_average, + ) + + +def ssim(img1, img2, window_size=11, mask=None, size_average=True): + (_, channel, _, _) = img1.size() + window = create_window(window_size, channel) + + if img1.is_cuda: + window = window.cuda(img1.get_device()) + window = window.type_as(img1) + + return _ssim(img1, img2, window, window_size, channel, mask, size_average) diff --git a/ldm/modules/evaluate/torch_frechet_video_distance.py b/ldm/modules/evaluate/torch_frechet_video_distance.py new file mode 100755 index 0000000..04856b8 --- /dev/null +++ b/ldm/modules/evaluate/torch_frechet_video_distance.py @@ -0,0 +1,294 @@ +# based on https://github.com/universome/fvd-comparison/blob/master/compare_models.py; huge thanks! +import os +import numpy as np +import io +import re +import requests +import html +import hashlib +import urllib +import urllib.request +import scipy.linalg +import multiprocessing as mp +import glob + + +from tqdm import tqdm +from typing import Any, List, Tuple, Union, Dict, Callable + +from torchvision.io import read_video +import torch; torch.set_grad_enabled(False) +from einops import rearrange + +from nitro.util import isvideo + +def compute_frechet_distance(mu_sample,sigma_sample,mu_ref,sigma_ref) -> float: + print('Calculate frechet distance...') + m = np.square(mu_sample - mu_ref).sum() + s, _ = scipy.linalg.sqrtm(np.dot(sigma_sample, sigma_ref), disp=False) # pylint: disable=no-member + fid = np.real(m + np.trace(sigma_sample + sigma_ref - s * 2)) + + return float(fid) + + +def compute_stats(feats: np.ndarray) -> Tuple[np.ndarray, np.ndarray]: + mu = feats.mean(axis=0) # [d] + sigma = np.cov(feats, rowvar=False) # [d, d] + + return mu, sigma + + +def open_url(url: str, num_attempts: int = 10, verbose: bool = True, return_filename: bool = False) -> Any: + """Download the given URL and return a binary-mode file object to access the data.""" + assert num_attempts >= 1 + + # Doesn't look like an URL scheme so interpret it as a local filename. + if not re.match('^[a-z]+://', url): + return url if return_filename else open(url, "rb") + + # Handle file URLs. This code handles unusual file:// patterns that + # arise on Windows: + # + # file:///c:/foo.txt + # + # which would translate to a local '/c:/foo.txt' filename that's + # invalid. Drop the forward slash for such pathnames. + # + # If you touch this code path, you should test it on both Linux and + # Windows. + # + # Some internet resources suggest using urllib.request.url2pathname() but + # but that converts forward slashes to backslashes and this causes + # its own set of problems. + if url.startswith('file://'): + filename = urllib.parse.urlparse(url).path + if re.match(r'^/[a-zA-Z]:', filename): + filename = filename[1:] + return filename if return_filename else open(filename, "rb") + + url_md5 = hashlib.md5(url.encode("utf-8")).hexdigest() + + # Download. + url_name = None + url_data = None + with requests.Session() as session: + if verbose: + print("Downloading %s ..." % url, end="", flush=True) + for attempts_left in reversed(range(num_attempts)): + try: + with session.get(url) as res: + res.raise_for_status() + if len(res.content) == 0: + raise IOError("No data received") + + if len(res.content) < 8192: + content_str = res.content.decode("utf-8") + if "download_warning" in res.headers.get("Set-Cookie", ""): + links = [html.unescape(link) for link in content_str.split('"') if "export=download" in link] + if len(links) == 1: + url = requests.compat.urljoin(url, links[0]) + raise IOError("Google Drive virus checker nag") + if "Google Drive - Quota exceeded" in content_str: + raise IOError("Google Drive download quota exceeded -- please try again later") + + match = re.search(r'filename="([^"]*)"', res.headers.get("Content-Disposition", "")) + url_name = match[1] if match else url + url_data = res.content + if verbose: + print(" done") + break + except KeyboardInterrupt: + raise + except: + if not attempts_left: + if verbose: + print(" failed") + raise + if verbose: + print(".", end="", flush=True) + + # Return data as file object. + assert not return_filename + return io.BytesIO(url_data) + +def load_video(ip): + vid, *_ = read_video(ip) + vid = rearrange(vid, 't h w c -> t c h w').to(torch.uint8) + return vid + +def get_data_from_str(input_str,nprc = None): + assert os.path.isdir(input_str), f'Specified input folder "{input_str}" is not a directory' + vid_filelist = glob.glob(os.path.join(input_str,'*.mp4')) + print(f'Found {len(vid_filelist)} videos in dir {input_str}') + + if nprc is None: + try: + nprc = mp.cpu_count() + except NotImplementedError: + print('WARNING: cpu_count() not avlailable, using only 1 cpu for video loading') + nprc = 1 + + pool = mp.Pool(processes=nprc) + + vids = [] + for v in tqdm(pool.imap_unordered(load_video,vid_filelist),total=len(vid_filelist),desc='Loading videos...'): + vids.append(v) + + + vids = torch.stack(vids,dim=0).float() + + return vids + +def get_stats(stats): + assert os.path.isfile(stats) and stats.endswith('.npz'), f'no stats found under {stats}' + + print(f'Using precomputed statistics under {stats}') + stats = np.load(stats) + stats = {key: stats[key] for key in stats.files} + + return stats + + + + +@torch.no_grad() +def compute_fvd(ref_input, sample_input, bs=32, + ref_stats=None, + sample_stats=None, + nprc_load=None): + + + + calc_stats = ref_stats is None or sample_stats is None + + if calc_stats: + + only_ref = sample_stats is not None + only_sample = ref_stats is not None + + + if isinstance(ref_input,str) and not only_sample: + ref_input = get_data_from_str(ref_input,nprc_load) + + if isinstance(sample_input, str) and not only_ref: + sample_input = get_data_from_str(sample_input, nprc_load) + + stats = compute_statistics(sample_input,ref_input, + device='cuda' if torch.cuda.is_available() else 'cpu', + bs=bs, + only_ref=only_ref, + only_sample=only_sample) + + if only_ref: + stats.update(get_stats(sample_stats)) + elif only_sample: + stats.update(get_stats(ref_stats)) + + + + else: + stats = get_stats(sample_stats) + stats.update(get_stats(ref_stats)) + + fvd = compute_frechet_distance(**stats) + + return {'FVD' : fvd,} + + +@torch.no_grad() +def compute_statistics(videos_fake, videos_real, device: str='cuda', bs=32, only_ref=False,only_sample=False) -> Dict: + detector_url = 'https://www.dropbox.com/s/ge9e5ujwgetktms/i3d_torchscript.pt?dl=1' + detector_kwargs = dict(rescale=True, resize=True, return_features=True) # Return raw features before the softmax layer. + + with open_url(detector_url, verbose=False) as f: + detector = torch.jit.load(f).eval().to(device) + + + + assert not (only_sample and only_ref), 'only_ref and only_sample arguments are mutually exclusive' + + ref_embed, sample_embed = [], [] + + info = f'Computing I3D activations for FVD score with batch size {bs}' + + if only_ref: + + if not isvideo(videos_real): + # if not is video we assume to have numpy arrays pf shape (n_vids, t, h, w, c) in range [0,255] + videos_real = torch.from_numpy(videos_real).permute(0, 4, 1, 2, 3).float() + print(videos_real.shape) + + if videos_real.shape[0] % bs == 0: + n_secs = videos_real.shape[0] // bs + else: + n_secs = videos_real.shape[0] // bs + 1 + + videos_real = torch.tensor_split(videos_real, n_secs, dim=0) + + for ref_v in tqdm(videos_real, total=len(videos_real),desc=info): + + feats_ref = detector(ref_v.to(device).contiguous(), **detector_kwargs).cpu().numpy() + ref_embed.append(feats_ref) + + elif only_sample: + + if not isvideo(videos_fake): + # if not is video we assume to have numpy arrays pf shape (n_vids, t, h, w, c) in range [0,255] + videos_fake = torch.from_numpy(videos_fake).permute(0, 4, 1, 2, 3).float() + print(videos_fake.shape) + + if videos_fake.shape[0] % bs == 0: + n_secs = videos_fake.shape[0] // bs + else: + n_secs = videos_fake.shape[0] // bs + 1 + + videos_real = torch.tensor_split(videos_real, n_secs, dim=0) + + for sample_v in tqdm(videos_fake, total=len(videos_real),desc=info): + feats_sample = detector(sample_v.to(device).contiguous(), **detector_kwargs).cpu().numpy() + sample_embed.append(feats_sample) + + + else: + + if not isvideo(videos_real): + # if not is video we assume to have numpy arrays pf shape (n_vids, t, h, w, c) in range [0,255] + videos_real = torch.from_numpy(videos_real).permute(0, 4, 1, 2, 3).float() + + if not isvideo(videos_fake): + videos_fake = torch.from_numpy(videos_fake).permute(0, 4, 1, 2, 3).float() + + if videos_fake.shape[0] % bs == 0: + n_secs = videos_fake.shape[0] // bs + else: + n_secs = videos_fake.shape[0] // bs + 1 + + videos_real = torch.tensor_split(videos_real, n_secs, dim=0) + videos_fake = torch.tensor_split(videos_fake, n_secs, dim=0) + + for ref_v, sample_v in tqdm(zip(videos_real,videos_fake),total=len(videos_fake),desc=info): + # print(ref_v.shape) + # ref_v = torch.nn.functional.interpolate(ref_v, size=(sample_v.shape[2], 256, 256), mode='trilinear', align_corners=False) + # sample_v = torch.nn.functional.interpolate(sample_v, size=(sample_v.shape[2], 256, 256), mode='trilinear', align_corners=False) + + + feats_sample = detector(sample_v.to(device).contiguous(), **detector_kwargs).cpu().numpy() + feats_ref = detector(ref_v.to(device).contiguous(), **detector_kwargs).cpu().numpy() + sample_embed.append(feats_sample) + ref_embed.append(feats_ref) + + out = dict() + if len(sample_embed) > 0: + sample_embed = np.concatenate(sample_embed,axis=0) + mu_sample, sigma_sample = compute_stats(sample_embed) + out.update({'mu_sample': mu_sample, + 'sigma_sample': sigma_sample}) + + if len(ref_embed) > 0: + ref_embed = np.concatenate(ref_embed,axis=0) + mu_ref, sigma_ref = compute_stats(ref_embed) + out.update({'mu_ref': mu_ref, + 'sigma_ref': sigma_ref}) + + + return out diff --git a/ldm/modules/image_degradation/__init__.py b/ldm/modules/image_degradation/__init__.py new file mode 100755 index 0000000..7836cad --- /dev/null +++ b/ldm/modules/image_degradation/__init__.py @@ -0,0 +1,2 @@ +from ldm.modules.image_degradation.bsrgan import degradation_bsrgan_variant as degradation_fn_bsr +from ldm.modules.image_degradation.bsrgan_light import degradation_bsrgan_variant as degradation_fn_bsr_light diff --git a/ldm/modules/image_degradation/bsrgan.py b/ldm/modules/image_degradation/bsrgan.py new file mode 100755 index 0000000..32ef561 --- /dev/null +++ b/ldm/modules/image_degradation/bsrgan.py @@ -0,0 +1,730 @@ +# -*- coding: utf-8 -*- +""" +# -------------------------------------------- +# Super-Resolution +# -------------------------------------------- +# +# Kai Zhang (cskaizhang@gmail.com) +# https://github.com/cszn +# From 2019/03--2021/08 +# -------------------------------------------- +""" + +import numpy as np +import cv2 +import torch + +from functools import partial +import random +from scipy import ndimage +import scipy +import scipy.stats as ss +from scipy.interpolate import interp2d +from scipy.linalg import orth +import albumentations + +import ldm.modules.image_degradation.utils_image as util + + +def modcrop_np(img, sf): + ''' + Args: + img: numpy image, WxH or WxHxC + sf: scale factor + Return: + cropped image + ''' + w, h = img.shape[:2] + im = np.copy(img) + return im[:w - w % sf, :h - h % sf, ...] + + +""" +# -------------------------------------------- +# anisotropic Gaussian kernels +# -------------------------------------------- +""" + + +def analytic_kernel(k): + """Calculate the X4 kernel from the X2 kernel (for proof see appendix in paper)""" + k_size = k.shape[0] + # Calculate the big kernels size + big_k = np.zeros((3 * k_size - 2, 3 * k_size - 2)) + # Loop over the small kernel to fill the big one + for r in range(k_size): + for c in range(k_size): + big_k[2 * r:2 * r + k_size, 2 * c:2 * c + k_size] += k[r, c] * k + # Crop the edges of the big kernel to ignore very small values and increase run time of SR + crop = k_size // 2 + cropped_big_k = big_k[crop:-crop, crop:-crop] + # Normalize to 1 + return cropped_big_k / cropped_big_k.sum() + + +def anisotropic_Gaussian(ksize=15, theta=np.pi, l1=6, l2=6): + """ generate an anisotropic Gaussian kernel + Args: + ksize : e.g., 15, kernel size + theta : [0, pi], rotation angle range + l1 : [0.1,50], scaling of eigenvalues + l2 : [0.1,l1], scaling of eigenvalues + If l1 = l2, will get an isotropic Gaussian kernel. + Returns: + k : kernel + """ + + v = np.dot(np.array([[np.cos(theta), -np.sin(theta)], [np.sin(theta), np.cos(theta)]]), np.array([1., 0.])) + V = np.array([[v[0], v[1]], [v[1], -v[0]]]) + D = np.array([[l1, 0], [0, l2]]) + Sigma = np.dot(np.dot(V, D), np.linalg.inv(V)) + k = gm_blur_kernel(mean=[0, 0], cov=Sigma, size=ksize) + + return k + + +def gm_blur_kernel(mean, cov, size=15): + center = size / 2.0 + 0.5 + k = np.zeros([size, size]) + for y in range(size): + for x in range(size): + cy = y - center + 1 + cx = x - center + 1 + k[y, x] = ss.multivariate_normal.pdf([cx, cy], mean=mean, cov=cov) + + k = k / np.sum(k) + return k + + +def shift_pixel(x, sf, upper_left=True): + """shift pixel for super-resolution with different scale factors + Args: + x: WxHxC or WxH + sf: scale factor + upper_left: shift direction + """ + h, w = x.shape[:2] + shift = (sf - 1) * 0.5 + xv, yv = np.arange(0, w, 1.0), np.arange(0, h, 1.0) + if upper_left: + x1 = xv + shift + y1 = yv + shift + else: + x1 = xv - shift + y1 = yv - shift + + x1 = np.clip(x1, 0, w - 1) + y1 = np.clip(y1, 0, h - 1) + + if x.ndim == 2: + x = interp2d(xv, yv, x)(x1, y1) + if x.ndim == 3: + for i in range(x.shape[-1]): + x[:, :, i] = interp2d(xv, yv, x[:, :, i])(x1, y1) + + return x + + +def blur(x, k): + ''' + x: image, NxcxHxW + k: kernel, Nx1xhxw + ''' + n, c = x.shape[:2] + p1, p2 = (k.shape[-2] - 1) // 2, (k.shape[-1] - 1) // 2 + x = torch.nn.functional.pad(x, pad=(p1, p2, p1, p2), mode='replicate') + k = k.repeat(1, c, 1, 1) + k = k.view(-1, 1, k.shape[2], k.shape[3]) + x = x.view(1, -1, x.shape[2], x.shape[3]) + x = torch.nn.functional.conv2d(x, k, bias=None, stride=1, padding=0, groups=n * c) + x = x.view(n, c, x.shape[2], x.shape[3]) + + return x + + +def gen_kernel(k_size=np.array([15, 15]), scale_factor=np.array([4, 4]), min_var=0.6, max_var=10., noise_level=0): + """" + # modified version of https://github.com/assafshocher/BlindSR_dataset_generator + # Kai Zhang + # min_var = 0.175 * sf # variance of the gaussian kernel will be sampled between min_var and max_var + # max_var = 2.5 * sf + """ + # Set random eigen-vals (lambdas) and angle (theta) for COV matrix + lambda_1 = min_var + np.random.rand() * (max_var - min_var) + lambda_2 = min_var + np.random.rand() * (max_var - min_var) + theta = np.random.rand() * np.pi # random theta + noise = -noise_level + np.random.rand(*k_size) * noise_level * 2 + + # Set COV matrix using Lambdas and Theta + LAMBDA = np.diag([lambda_1, lambda_2]) + Q = np.array([[np.cos(theta), -np.sin(theta)], + [np.sin(theta), np.cos(theta)]]) + SIGMA = Q @ LAMBDA @ Q.T + INV_SIGMA = np.linalg.inv(SIGMA)[None, None, :, :] + + # Set expectation position (shifting kernel for aligned image) + MU = k_size // 2 - 0.5 * (scale_factor - 1) # - 0.5 * (scale_factor - k_size % 2) + MU = MU[None, None, :, None] + + # Create meshgrid for Gaussian + [X, Y] = np.meshgrid(range(k_size[0]), range(k_size[1])) + Z = np.stack([X, Y], 2)[:, :, :, None] + + # Calcualte Gaussian for every pixel of the kernel + ZZ = Z - MU + ZZ_t = ZZ.transpose(0, 1, 3, 2) + raw_kernel = np.exp(-0.5 * np.squeeze(ZZ_t @ INV_SIGMA @ ZZ)) * (1 + noise) + + # shift the kernel so it will be centered + # raw_kernel_centered = kernel_shift(raw_kernel, scale_factor) + + # Normalize the kernel and return + # kernel = raw_kernel_centered / np.sum(raw_kernel_centered) + kernel = raw_kernel / np.sum(raw_kernel) + return kernel + + +def fspecial_gaussian(hsize, sigma): + hsize = [hsize, hsize] + siz = [(hsize[0] - 1.0) / 2.0, (hsize[1] - 1.0) / 2.0] + std = sigma + [x, y] = np.meshgrid(np.arange(-siz[1], siz[1] + 1), np.arange(-siz[0], siz[0] + 1)) + arg = -(x * x + y * y) / (2 * std * std) + h = np.exp(arg) + h[h < scipy.finfo(float).eps * h.max()] = 0 + sumh = h.sum() + if sumh != 0: + h = h / sumh + return h + + +def fspecial_laplacian(alpha): + alpha = max([0, min([alpha, 1])]) + h1 = alpha / (alpha + 1) + h2 = (1 - alpha) / (alpha + 1) + h = [[h1, h2, h1], [h2, -4 / (alpha + 1), h2], [h1, h2, h1]] + h = np.array(h) + return h + + +def fspecial(filter_type, *args, **kwargs): + ''' + python code from: + https://github.com/ronaldosena/imagens-medicas-2/blob/40171a6c259edec7827a6693a93955de2bd39e76/Aulas/aula_2_-_uniform_filter/matlab_fspecial.py + ''' + if filter_type == 'gaussian': + return fspecial_gaussian(*args, **kwargs) + if filter_type == 'laplacian': + return fspecial_laplacian(*args, **kwargs) + + +""" +# -------------------------------------------- +# degradation models +# -------------------------------------------- +""" + + +def bicubic_degradation(x, sf=3): + ''' + Args: + x: HxWxC image, [0, 1] + sf: down-scale factor + Return: + bicubicly downsampled LR image + ''' + x = util.imresize_np(x, scale=1 / sf) + return x + + +def srmd_degradation(x, k, sf=3): + ''' blur + bicubic downsampling + Args: + x: HxWxC image, [0, 1] + k: hxw, double + sf: down-scale factor + Return: + downsampled LR image + Reference: + @inproceedings{zhang2018learning, + title={Learning a single convolutional super-resolution network for multiple degradations}, + author={Zhang, Kai and Zuo, Wangmeng and Zhang, Lei}, + booktitle={IEEE Conference on Computer Vision and Pattern Recognition}, + pages={3262--3271}, + year={2018} + } + ''' + x = ndimage.filters.convolve(x, np.expand_dims(k, axis=2), mode='wrap') # 'nearest' | 'mirror' + x = bicubic_degradation(x, sf=sf) + return x + + +def dpsr_degradation(x, k, sf=3): + ''' bicubic downsampling + blur + Args: + x: HxWxC image, [0, 1] + k: hxw, double + sf: down-scale factor + Return: + downsampled LR image + Reference: + @inproceedings{zhang2019deep, + title={Deep Plug-and-Play Super-Resolution for Arbitrary Blur Kernels}, + author={Zhang, Kai and Zuo, Wangmeng and Zhang, Lei}, + booktitle={IEEE Conference on Computer Vision and Pattern Recognition}, + pages={1671--1681}, + year={2019} + } + ''' + x = bicubic_degradation(x, sf=sf) + x = ndimage.filters.convolve(x, np.expand_dims(k, axis=2), mode='wrap') + return x + + +def classical_degradation(x, k, sf=3): + ''' blur + downsampling + Args: + x: HxWxC image, [0, 1]/[0, 255] + k: hxw, double + sf: down-scale factor + Return: + downsampled LR image + ''' + x = ndimage.filters.convolve(x, np.expand_dims(k, axis=2), mode='wrap') + # x = filters.correlate(x, np.expand_dims(np.flip(k), axis=2)) + st = 0 + return x[st::sf, st::sf, ...] + + +def add_sharpening(img, weight=0.5, radius=50, threshold=10): + """USM sharpening. borrowed from real-ESRGAN + Input image: I; Blurry image: B. + 1. K = I + weight * (I - B) + 2. Mask = 1 if abs(I - B) > threshold, else: 0 + 3. Blur mask: + 4. Out = Mask * K + (1 - Mask) * I + Args: + img (Numpy array): Input image, HWC, BGR; float32, [0, 1]. + weight (float): Sharp weight. Default: 1. + radius (float): Kernel size of Gaussian blur. Default: 50. + threshold (int): + """ + if radius % 2 == 0: + radius += 1 + blur = cv2.GaussianBlur(img, (radius, radius), 0) + residual = img - blur + mask = np.abs(residual) * 255 > threshold + mask = mask.astype('float32') + soft_mask = cv2.GaussianBlur(mask, (radius, radius), 0) + + K = img + weight * residual + K = np.clip(K, 0, 1) + return soft_mask * K + (1 - soft_mask) * img + + +def add_blur(img, sf=4): + wd2 = 4.0 + sf + wd = 2.0 + 0.2 * sf + if random.random() < 0.5: + l1 = wd2 * random.random() + l2 = wd2 * random.random() + k = anisotropic_Gaussian(ksize=2 * random.randint(2, 11) + 3, theta=random.random() * np.pi, l1=l1, l2=l2) + else: + k = fspecial('gaussian', 2 * random.randint(2, 11) + 3, wd * random.random()) + img = ndimage.filters.convolve(img, np.expand_dims(k, axis=2), mode='mirror') + + return img + + +def add_resize(img, sf=4): + rnum = np.random.rand() + if rnum > 0.8: # up + sf1 = random.uniform(1, 2) + elif rnum < 0.7: # down + sf1 = random.uniform(0.5 / sf, 1) + else: + sf1 = 1.0 + img = cv2.resize(img, (int(sf1 * img.shape[1]), int(sf1 * img.shape[0])), interpolation=random.choice([1, 2, 3])) + img = np.clip(img, 0.0, 1.0) + + return img + + +# def add_Gaussian_noise(img, noise_level1=2, noise_level2=25): +# noise_level = random.randint(noise_level1, noise_level2) +# rnum = np.random.rand() +# if rnum > 0.6: # add color Gaussian noise +# img += np.random.normal(0, noise_level / 255.0, img.shape).astype(np.float32) +# elif rnum < 0.4: # add grayscale Gaussian noise +# img += np.random.normal(0, noise_level / 255.0, (*img.shape[:2], 1)).astype(np.float32) +# else: # add noise +# L = noise_level2 / 255. +# D = np.diag(np.random.rand(3)) +# U = orth(np.random.rand(3, 3)) +# conv = np.dot(np.dot(np.transpose(U), D), U) +# img += np.random.multivariate_normal([0, 0, 0], np.abs(L ** 2 * conv), img.shape[:2]).astype(np.float32) +# img = np.clip(img, 0.0, 1.0) +# return img + +def add_Gaussian_noise(img, noise_level1=2, noise_level2=25): + noise_level = random.randint(noise_level1, noise_level2) + rnum = np.random.rand() + if rnum > 0.6: # add color Gaussian noise + img = img + np.random.normal(0, noise_level / 255.0, img.shape).astype(np.float32) + elif rnum < 0.4: # add grayscale Gaussian noise + img = img + np.random.normal(0, noise_level / 255.0, (*img.shape[:2], 1)).astype(np.float32) + else: # add noise + L = noise_level2 / 255. + D = np.diag(np.random.rand(3)) + U = orth(np.random.rand(3, 3)) + conv = np.dot(np.dot(np.transpose(U), D), U) + img = img + np.random.multivariate_normal([0, 0, 0], np.abs(L ** 2 * conv), img.shape[:2]).astype(np.float32) + img = np.clip(img, 0.0, 1.0) + return img + + +def add_speckle_noise(img, noise_level1=2, noise_level2=25): + noise_level = random.randint(noise_level1, noise_level2) + img = np.clip(img, 0.0, 1.0) + rnum = random.random() + if rnum > 0.6: + img += img * np.random.normal(0, noise_level / 255.0, img.shape).astype(np.float32) + elif rnum < 0.4: + img += img * np.random.normal(0, noise_level / 255.0, (*img.shape[:2], 1)).astype(np.float32) + else: + L = noise_level2 / 255. + D = np.diag(np.random.rand(3)) + U = orth(np.random.rand(3, 3)) + conv = np.dot(np.dot(np.transpose(U), D), U) + img += img * np.random.multivariate_normal([0, 0, 0], np.abs(L ** 2 * conv), img.shape[:2]).astype(np.float32) + img = np.clip(img, 0.0, 1.0) + return img + + +def add_Poisson_noise(img): + img = np.clip((img * 255.0).round(), 0, 255) / 255. + vals = 10 ** (2 * random.random() + 2.0) # [2, 4] + if random.random() < 0.5: + img = np.random.poisson(img * vals).astype(np.float32) / vals + else: + img_gray = np.dot(img[..., :3], [0.299, 0.587, 0.114]) + img_gray = np.clip((img_gray * 255.0).round(), 0, 255) / 255. + noise_gray = np.random.poisson(img_gray * vals).astype(np.float32) / vals - img_gray + img += noise_gray[:, :, np.newaxis] + img = np.clip(img, 0.0, 1.0) + return img + + +def add_JPEG_noise(img): + quality_factor = random.randint(30, 95) + img = cv2.cvtColor(util.single2uint(img), cv2.COLOR_RGB2BGR) + result, encimg = cv2.imencode('.jpg', img, [int(cv2.IMWRITE_JPEG_QUALITY), quality_factor]) + img = cv2.imdecode(encimg, 1) + img = cv2.cvtColor(util.uint2single(img), cv2.COLOR_BGR2RGB) + return img + + +def random_crop(lq, hq, sf=4, lq_patchsize=64): + h, w = lq.shape[:2] + rnd_h = random.randint(0, h - lq_patchsize) + rnd_w = random.randint(0, w - lq_patchsize) + lq = lq[rnd_h:rnd_h + lq_patchsize, rnd_w:rnd_w + lq_patchsize, :] + + rnd_h_H, rnd_w_H = int(rnd_h * sf), int(rnd_w * sf) + hq = hq[rnd_h_H:rnd_h_H + lq_patchsize * sf, rnd_w_H:rnd_w_H + lq_patchsize * sf, :] + return lq, hq + + +def degradation_bsrgan(img, sf=4, lq_patchsize=72, isp_model=None): + """ + This is the degradation model of BSRGAN from the paper + "Designing a Practical Degradation Model for Deep Blind Image Super-Resolution" + ---------- + img: HXWXC, [0, 1], its size should be large than (lq_patchsizexsf)x(lq_patchsizexsf) + sf: scale factor + isp_model: camera ISP model + Returns + ------- + img: low-quality patch, size: lq_patchsizeXlq_patchsizeXC, range: [0, 1] + hq: corresponding high-quality patch, size: (lq_patchsizexsf)X(lq_patchsizexsf)XC, range: [0, 1] + """ + isp_prob, jpeg_prob, scale2_prob = 0.25, 0.9, 0.25 + sf_ori = sf + + h1, w1 = img.shape[:2] + img = img.copy()[:w1 - w1 % sf, :h1 - h1 % sf, ...] # mod crop + h, w = img.shape[:2] + + if h < lq_patchsize * sf or w < lq_patchsize * sf: + raise ValueError(f'img size ({h1}X{w1}) is too small!') + + hq = img.copy() + + if sf == 4 and random.random() < scale2_prob: # downsample1 + if np.random.rand() < 0.5: + img = cv2.resize(img, (int(1 / 2 * img.shape[1]), int(1 / 2 * img.shape[0])), + interpolation=random.choice([1, 2, 3])) + else: + img = util.imresize_np(img, 1 / 2, True) + img = np.clip(img, 0.0, 1.0) + sf = 2 + + shuffle_order = random.sample(range(7), 7) + idx1, idx2 = shuffle_order.index(2), shuffle_order.index(3) + if idx1 > idx2: # keep downsample3 last + shuffle_order[idx1], shuffle_order[idx2] = shuffle_order[idx2], shuffle_order[idx1] + + for i in shuffle_order: + + if i == 0: + img = add_blur(img, sf=sf) + + elif i == 1: + img = add_blur(img, sf=sf) + + elif i == 2: + a, b = img.shape[1], img.shape[0] + # downsample2 + if random.random() < 0.75: + sf1 = random.uniform(1, 2 * sf) + img = cv2.resize(img, (int(1 / sf1 * img.shape[1]), int(1 / sf1 * img.shape[0])), + interpolation=random.choice([1, 2, 3])) + else: + k = fspecial('gaussian', 25, random.uniform(0.1, 0.6 * sf)) + k_shifted = shift_pixel(k, sf) + k_shifted = k_shifted / k_shifted.sum() # blur with shifted kernel + img = ndimage.filters.convolve(img, np.expand_dims(k_shifted, axis=2), mode='mirror') + img = img[0::sf, 0::sf, ...] # nearest downsampling + img = np.clip(img, 0.0, 1.0) + + elif i == 3: + # downsample3 + img = cv2.resize(img, (int(1 / sf * a), int(1 / sf * b)), interpolation=random.choice([1, 2, 3])) + img = np.clip(img, 0.0, 1.0) + + elif i == 4: + # add Gaussian noise + img = add_Gaussian_noise(img, noise_level1=2, noise_level2=25) + + elif i == 5: + # add JPEG noise + if random.random() < jpeg_prob: + img = add_JPEG_noise(img) + + elif i == 6: + # add processed camera sensor noise + if random.random() < isp_prob and isp_model is not None: + with torch.no_grad(): + img, hq = isp_model.forward(img.copy(), hq) + + # add final JPEG compression noise + img = add_JPEG_noise(img) + + # random crop + img, hq = random_crop(img, hq, sf_ori, lq_patchsize) + + return img, hq + + +# todo no isp_model? +def degradation_bsrgan_variant(image, sf=4, isp_model=None): + """ + This is the degradation model of BSRGAN from the paper + "Designing a Practical Degradation Model for Deep Blind Image Super-Resolution" + ---------- + sf: scale factor + isp_model: camera ISP model + Returns + ------- + img: low-quality patch, size: lq_patchsizeXlq_patchsizeXC, range: [0, 1] + hq: corresponding high-quality patch, size: (lq_patchsizexsf)X(lq_patchsizexsf)XC, range: [0, 1] + """ + image = util.uint2single(image) + isp_prob, jpeg_prob, scale2_prob = 0.25, 0.9, 0.25 + sf_ori = sf + + h1, w1 = image.shape[:2] + image = image.copy()[:w1 - w1 % sf, :h1 - h1 % sf, ...] # mod crop + h, w = image.shape[:2] + + hq = image.copy() + + if sf == 4 and random.random() < scale2_prob: # downsample1 + if np.random.rand() < 0.5: + image = cv2.resize(image, (int(1 / 2 * image.shape[1]), int(1 / 2 * image.shape[0])), + interpolation=random.choice([1, 2, 3])) + else: + image = util.imresize_np(image, 1 / 2, True) + image = np.clip(image, 0.0, 1.0) + sf = 2 + + shuffle_order = random.sample(range(7), 7) + idx1, idx2 = shuffle_order.index(2), shuffle_order.index(3) + if idx1 > idx2: # keep downsample3 last + shuffle_order[idx1], shuffle_order[idx2] = shuffle_order[idx2], shuffle_order[idx1] + + for i in shuffle_order: + + if i == 0: + image = add_blur(image, sf=sf) + + elif i == 1: + image = add_blur(image, sf=sf) + + elif i == 2: + a, b = image.shape[1], image.shape[0] + # downsample2 + if random.random() < 0.75: + sf1 = random.uniform(1, 2 * sf) + image = cv2.resize(image, (int(1 / sf1 * image.shape[1]), int(1 / sf1 * image.shape[0])), + interpolation=random.choice([1, 2, 3])) + else: + k = fspecial('gaussian', 25, random.uniform(0.1, 0.6 * sf)) + k_shifted = shift_pixel(k, sf) + k_shifted = k_shifted / k_shifted.sum() # blur with shifted kernel + image = ndimage.filters.convolve(image, np.expand_dims(k_shifted, axis=2), mode='mirror') + image = image[0::sf, 0::sf, ...] # nearest downsampling + image = np.clip(image, 0.0, 1.0) + + elif i == 3: + # downsample3 + image = cv2.resize(image, (int(1 / sf * a), int(1 / sf * b)), interpolation=random.choice([1, 2, 3])) + image = np.clip(image, 0.0, 1.0) + + elif i == 4: + # add Gaussian noise + image = add_Gaussian_noise(image, noise_level1=2, noise_level2=25) + + elif i == 5: + # add JPEG noise + if random.random() < jpeg_prob: + image = add_JPEG_noise(image) + + # elif i == 6: + # # add processed camera sensor noise + # if random.random() < isp_prob and isp_model is not None: + # with torch.no_grad(): + # img, hq = isp_model.forward(img.copy(), hq) + + # add final JPEG compression noise + image = add_JPEG_noise(image) + image = util.single2uint(image) + example = {"image":image} + return example + + +# TODO incase there is a pickle error one needs to replace a += x with a = a + x in add_speckle_noise etc... +def degradation_bsrgan_plus(img, sf=4, shuffle_prob=0.5, use_sharp=True, lq_patchsize=64, isp_model=None): + """ + This is an extended degradation model by combining + the degradation models of BSRGAN and Real-ESRGAN + ---------- + img: HXWXC, [0, 1], its size should be large than (lq_patchsizexsf)x(lq_patchsizexsf) + sf: scale factor + use_shuffle: the degradation shuffle + use_sharp: sharpening the img + Returns + ------- + img: low-quality patch, size: lq_patchsizeXlq_patchsizeXC, range: [0, 1] + hq: corresponding high-quality patch, size: (lq_patchsizexsf)X(lq_patchsizexsf)XC, range: [0, 1] + """ + + h1, w1 = img.shape[:2] + img = img.copy()[:w1 - w1 % sf, :h1 - h1 % sf, ...] # mod crop + h, w = img.shape[:2] + + if h < lq_patchsize * sf or w < lq_patchsize * sf: + raise ValueError(f'img size ({h1}X{w1}) is too small!') + + if use_sharp: + img = add_sharpening(img) + hq = img.copy() + + if random.random() < shuffle_prob: + shuffle_order = random.sample(range(13), 13) + else: + shuffle_order = list(range(13)) + # local shuffle for noise, JPEG is always the last one + shuffle_order[2:6] = random.sample(shuffle_order[2:6], len(range(2, 6))) + shuffle_order[9:13] = random.sample(shuffle_order[9:13], len(range(9, 13))) + + poisson_prob, speckle_prob, isp_prob = 0.1, 0.1, 0.1 + + for i in shuffle_order: + if i == 0: + img = add_blur(img, sf=sf) + elif i == 1: + img = add_resize(img, sf=sf) + elif i == 2: + img = add_Gaussian_noise(img, noise_level1=2, noise_level2=25) + elif i == 3: + if random.random() < poisson_prob: + img = add_Poisson_noise(img) + elif i == 4: + if random.random() < speckle_prob: + img = add_speckle_noise(img) + elif i == 5: + if random.random() < isp_prob and isp_model is not None: + with torch.no_grad(): + img, hq = isp_model.forward(img.copy(), hq) + elif i == 6: + img = add_JPEG_noise(img) + elif i == 7: + img = add_blur(img, sf=sf) + elif i == 8: + img = add_resize(img, sf=sf) + elif i == 9: + img = add_Gaussian_noise(img, noise_level1=2, noise_level2=25) + elif i == 10: + if random.random() < poisson_prob: + img = add_Poisson_noise(img) + elif i == 11: + if random.random() < speckle_prob: + img = add_speckle_noise(img) + elif i == 12: + if random.random() < isp_prob and isp_model is not None: + with torch.no_grad(): + img, hq = isp_model.forward(img.copy(), hq) + else: + print('check the shuffle!') + + # resize to desired size + img = cv2.resize(img, (int(1 / sf * hq.shape[1]), int(1 / sf * hq.shape[0])), + interpolation=random.choice([1, 2, 3])) + + # add final JPEG compression noise + img = add_JPEG_noise(img) + + # random crop + img, hq = random_crop(img, hq, sf, lq_patchsize) + + return img, hq + + +if __name__ == '__main__': + print("hey") + img = util.imread_uint('utils/test.png', 3) + print(img) + img = util.uint2single(img) + print(img) + img = img[:448, :448] + h = img.shape[0] // 4 + print("resizing to", h) + sf = 4 + deg_fn = partial(degradation_bsrgan_variant, sf=sf) + for i in range(20): + print(i) + img_lq = deg_fn(img) + print(img_lq) + img_lq_bicubic = albumentations.SmallestMaxSize(max_size=h, interpolation=cv2.INTER_CUBIC)(image=img)["image"] + print(img_lq.shape) + print("bicubic", img_lq_bicubic.shape) + print(img_hq.shape) + lq_nearest = cv2.resize(util.single2uint(img_lq), (int(sf * img_lq.shape[1]), int(sf * img_lq.shape[0])), + interpolation=0) + lq_bicubic_nearest = cv2.resize(util.single2uint(img_lq_bicubic), (int(sf * img_lq.shape[1]), int(sf * img_lq.shape[0])), + interpolation=0) + img_concat = np.concatenate([lq_bicubic_nearest, lq_nearest, util.single2uint(img_hq)], axis=1) + util.imsave(img_concat, str(i) + '.png') + + diff --git a/ldm/modules/image_degradation/bsrgan_light.py b/ldm/modules/image_degradation/bsrgan_light.py new file mode 100755 index 0000000..dfa7606 --- /dev/null +++ b/ldm/modules/image_degradation/bsrgan_light.py @@ -0,0 +1,650 @@ +# -*- coding: utf-8 -*- +import numpy as np +import cv2 +import torch + +from functools import partial +import random +from scipy import ndimage +import scipy +import scipy.stats as ss +from scipy.interpolate import interp2d +from scipy.linalg import orth +import albumentations + +import ldm.modules.image_degradation.utils_image as util + +""" +# -------------------------------------------- +# Super-Resolution +# -------------------------------------------- +# +# Kai Zhang (cskaizhang@gmail.com) +# https://github.com/cszn +# From 2019/03--2021/08 +# -------------------------------------------- +""" + + +def modcrop_np(img, sf): + ''' + Args: + img: numpy image, WxH or WxHxC + sf: scale factor + Return: + cropped image + ''' + w, h = img.shape[:2] + im = np.copy(img) + return im[:w - w % sf, :h - h % sf, ...] + + +""" +# -------------------------------------------- +# anisotropic Gaussian kernels +# -------------------------------------------- +""" + + +def analytic_kernel(k): + """Calculate the X4 kernel from the X2 kernel (for proof see appendix in paper)""" + k_size = k.shape[0] + # Calculate the big kernels size + big_k = np.zeros((3 * k_size - 2, 3 * k_size - 2)) + # Loop over the small kernel to fill the big one + for r in range(k_size): + for c in range(k_size): + big_k[2 * r:2 * r + k_size, 2 * c:2 * c + k_size] += k[r, c] * k + # Crop the edges of the big kernel to ignore very small values and increase run time of SR + crop = k_size // 2 + cropped_big_k = big_k[crop:-crop, crop:-crop] + # Normalize to 1 + return cropped_big_k / cropped_big_k.sum() + + +def anisotropic_Gaussian(ksize=15, theta=np.pi, l1=6, l2=6): + """ generate an anisotropic Gaussian kernel + Args: + ksize : e.g., 15, kernel size + theta : [0, pi], rotation angle range + l1 : [0.1,50], scaling of eigenvalues + l2 : [0.1,l1], scaling of eigenvalues + If l1 = l2, will get an isotropic Gaussian kernel. + Returns: + k : kernel + """ + + v = np.dot(np.array([[np.cos(theta), -np.sin(theta)], [np.sin(theta), np.cos(theta)]]), np.array([1., 0.])) + V = np.array([[v[0], v[1]], [v[1], -v[0]]]) + D = np.array([[l1, 0], [0, l2]]) + Sigma = np.dot(np.dot(V, D), np.linalg.inv(V)) + k = gm_blur_kernel(mean=[0, 0], cov=Sigma, size=ksize) + + return k + + +def gm_blur_kernel(mean, cov, size=15): + center = size / 2.0 + 0.5 + k = np.zeros([size, size]) + for y in range(size): + for x in range(size): + cy = y - center + 1 + cx = x - center + 1 + k[y, x] = ss.multivariate_normal.pdf([cx, cy], mean=mean, cov=cov) + + k = k / np.sum(k) + return k + + +def shift_pixel(x, sf, upper_left=True): + """shift pixel for super-resolution with different scale factors + Args: + x: WxHxC or WxH + sf: scale factor + upper_left: shift direction + """ + h, w = x.shape[:2] + shift = (sf - 1) * 0.5 + xv, yv = np.arange(0, w, 1.0), np.arange(0, h, 1.0) + if upper_left: + x1 = xv + shift + y1 = yv + shift + else: + x1 = xv - shift + y1 = yv - shift + + x1 = np.clip(x1, 0, w - 1) + y1 = np.clip(y1, 0, h - 1) + + if x.ndim == 2: + x = interp2d(xv, yv, x)(x1, y1) + if x.ndim == 3: + for i in range(x.shape[-1]): + x[:, :, i] = interp2d(xv, yv, x[:, :, i])(x1, y1) + + return x + + +def blur(x, k): + ''' + x: image, NxcxHxW + k: kernel, Nx1xhxw + ''' + n, c = x.shape[:2] + p1, p2 = (k.shape[-2] - 1) // 2, (k.shape[-1] - 1) // 2 + x = torch.nn.functional.pad(x, pad=(p1, p2, p1, p2), mode='replicate') + k = k.repeat(1, c, 1, 1) + k = k.view(-1, 1, k.shape[2], k.shape[3]) + x = x.view(1, -1, x.shape[2], x.shape[3]) + x = torch.nn.functional.conv2d(x, k, bias=None, stride=1, padding=0, groups=n * c) + x = x.view(n, c, x.shape[2], x.shape[3]) + + return x + + +def gen_kernel(k_size=np.array([15, 15]), scale_factor=np.array([4, 4]), min_var=0.6, max_var=10., noise_level=0): + """" + # modified version of https://github.com/assafshocher/BlindSR_dataset_generator + # Kai Zhang + # min_var = 0.175 * sf # variance of the gaussian kernel will be sampled between min_var and max_var + # max_var = 2.5 * sf + """ + # Set random eigen-vals (lambdas) and angle (theta) for COV matrix + lambda_1 = min_var + np.random.rand() * (max_var - min_var) + lambda_2 = min_var + np.random.rand() * (max_var - min_var) + theta = np.random.rand() * np.pi # random theta + noise = -noise_level + np.random.rand(*k_size) * noise_level * 2 + + # Set COV matrix using Lambdas and Theta + LAMBDA = np.diag([lambda_1, lambda_2]) + Q = np.array([[np.cos(theta), -np.sin(theta)], + [np.sin(theta), np.cos(theta)]]) + SIGMA = Q @ LAMBDA @ Q.T + INV_SIGMA = np.linalg.inv(SIGMA)[None, None, :, :] + + # Set expectation position (shifting kernel for aligned image) + MU = k_size // 2 - 0.5 * (scale_factor - 1) # - 0.5 * (scale_factor - k_size % 2) + MU = MU[None, None, :, None] + + # Create meshgrid for Gaussian + [X, Y] = np.meshgrid(range(k_size[0]), range(k_size[1])) + Z = np.stack([X, Y], 2)[:, :, :, None] + + # Calcualte Gaussian for every pixel of the kernel + ZZ = Z - MU + ZZ_t = ZZ.transpose(0, 1, 3, 2) + raw_kernel = np.exp(-0.5 * np.squeeze(ZZ_t @ INV_SIGMA @ ZZ)) * (1 + noise) + + # shift the kernel so it will be centered + # raw_kernel_centered = kernel_shift(raw_kernel, scale_factor) + + # Normalize the kernel and return + # kernel = raw_kernel_centered / np.sum(raw_kernel_centered) + kernel = raw_kernel / np.sum(raw_kernel) + return kernel + + +def fspecial_gaussian(hsize, sigma): + hsize = [hsize, hsize] + siz = [(hsize[0] - 1.0) / 2.0, (hsize[1] - 1.0) / 2.0] + std = sigma + [x, y] = np.meshgrid(np.arange(-siz[1], siz[1] + 1), np.arange(-siz[0], siz[0] + 1)) + arg = -(x * x + y * y) / (2 * std * std) + h = np.exp(arg) + h[h < scipy.finfo(float).eps * h.max()] = 0 + sumh = h.sum() + if sumh != 0: + h = h / sumh + return h + + +def fspecial_laplacian(alpha): + alpha = max([0, min([alpha, 1])]) + h1 = alpha / (alpha + 1) + h2 = (1 - alpha) / (alpha + 1) + h = [[h1, h2, h1], [h2, -4 / (alpha + 1), h2], [h1, h2, h1]] + h = np.array(h) + return h + + +def fspecial(filter_type, *args, **kwargs): + ''' + python code from: + https://github.com/ronaldosena/imagens-medicas-2/blob/40171a6c259edec7827a6693a93955de2bd39e76/Aulas/aula_2_-_uniform_filter/matlab_fspecial.py + ''' + if filter_type == 'gaussian': + return fspecial_gaussian(*args, **kwargs) + if filter_type == 'laplacian': + return fspecial_laplacian(*args, **kwargs) + + +""" +# -------------------------------------------- +# degradation models +# -------------------------------------------- +""" + + +def bicubic_degradation(x, sf=3): + ''' + Args: + x: HxWxC image, [0, 1] + sf: down-scale factor + Return: + bicubicly downsampled LR image + ''' + x = util.imresize_np(x, scale=1 / sf) + return x + + +def srmd_degradation(x, k, sf=3): + ''' blur + bicubic downsampling + Args: + x: HxWxC image, [0, 1] + k: hxw, double + sf: down-scale factor + Return: + downsampled LR image + Reference: + @inproceedings{zhang2018learning, + title={Learning a single convolutional super-resolution network for multiple degradations}, + author={Zhang, Kai and Zuo, Wangmeng and Zhang, Lei}, + booktitle={IEEE Conference on Computer Vision and Pattern Recognition}, + pages={3262--3271}, + year={2018} + } + ''' + x = ndimage.convolve(x, np.expand_dims(k, axis=2), mode='wrap') # 'nearest' | 'mirror' + x = bicubic_degradation(x, sf=sf) + return x + + +def dpsr_degradation(x, k, sf=3): + ''' bicubic downsampling + blur + Args: + x: HxWxC image, [0, 1] + k: hxw, double + sf: down-scale factor + Return: + downsampled LR image + Reference: + @inproceedings{zhang2019deep, + title={Deep Plug-and-Play Super-Resolution for Arbitrary Blur Kernels}, + author={Zhang, Kai and Zuo, Wangmeng and Zhang, Lei}, + booktitle={IEEE Conference on Computer Vision and Pattern Recognition}, + pages={1671--1681}, + year={2019} + } + ''' + x = bicubic_degradation(x, sf=sf) + x = ndimage.convolve(x, np.expand_dims(k, axis=2), mode='wrap') + return x + + +def classical_degradation(x, k, sf=3): + ''' blur + downsampling + Args: + x: HxWxC image, [0, 1]/[0, 255] + k: hxw, double + sf: down-scale factor + Return: + downsampled LR image + ''' + x = ndimage.convolve(x, np.expand_dims(k, axis=2), mode='wrap') + # x = filters.correlate(x, np.expand_dims(np.flip(k), axis=2)) + st = 0 + return x[st::sf, st::sf, ...] + + +def add_sharpening(img, weight=0.5, radius=50, threshold=10): + """USM sharpening. borrowed from real-ESRGAN + Input image: I; Blurry image: B. + 1. K = I + weight * (I - B) + 2. Mask = 1 if abs(I - B) > threshold, else: 0 + 3. Blur mask: + 4. Out = Mask * K + (1 - Mask) * I + Args: + img (Numpy array): Input image, HWC, BGR; float32, [0, 1]. + weight (float): Sharp weight. Default: 1. + radius (float): Kernel size of Gaussian blur. Default: 50. + threshold (int): + """ + if radius % 2 == 0: + radius += 1 + blur = cv2.GaussianBlur(img, (radius, radius), 0) + residual = img - blur + mask = np.abs(residual) * 255 > threshold + mask = mask.astype('float32') + soft_mask = cv2.GaussianBlur(mask, (radius, radius), 0) + + K = img + weight * residual + K = np.clip(K, 0, 1) + return soft_mask * K + (1 - soft_mask) * img + + +def add_blur(img, sf=4): + wd2 = 4.0 + sf + wd = 2.0 + 0.2 * sf + + wd2 = wd2/4 + wd = wd/4 + + if random.random() < 0.5: + l1 = wd2 * random.random() + l2 = wd2 * random.random() + k = anisotropic_Gaussian(ksize=random.randint(2, 11) + 3, theta=random.random() * np.pi, l1=l1, l2=l2) + else: + k = fspecial('gaussian', random.randint(2, 4) + 3, wd * random.random()) + img = ndimage.convolve(img, np.expand_dims(k, axis=2), mode='mirror') + + return img + + +def add_resize(img, sf=4): + rnum = np.random.rand() + if rnum > 0.8: # up + sf1 = random.uniform(1, 2) + elif rnum < 0.7: # down + sf1 = random.uniform(0.5 / sf, 1) + else: + sf1 = 1.0 + img = cv2.resize(img, (int(sf1 * img.shape[1]), int(sf1 * img.shape[0])), interpolation=random.choice([1, 2, 3])) + img = np.clip(img, 0.0, 1.0) + + return img + + +# def add_Gaussian_noise(img, noise_level1=2, noise_level2=25): +# noise_level = random.randint(noise_level1, noise_level2) +# rnum = np.random.rand() +# if rnum > 0.6: # add color Gaussian noise +# img += np.random.normal(0, noise_level / 255.0, img.shape).astype(np.float32) +# elif rnum < 0.4: # add grayscale Gaussian noise +# img += np.random.normal(0, noise_level / 255.0, (*img.shape[:2], 1)).astype(np.float32) +# else: # add noise +# L = noise_level2 / 255. +# D = np.diag(np.random.rand(3)) +# U = orth(np.random.rand(3, 3)) +# conv = np.dot(np.dot(np.transpose(U), D), U) +# img += np.random.multivariate_normal([0, 0, 0], np.abs(L ** 2 * conv), img.shape[:2]).astype(np.float32) +# img = np.clip(img, 0.0, 1.0) +# return img + +def add_Gaussian_noise(img, noise_level1=2, noise_level2=25): + noise_level = random.randint(noise_level1, noise_level2) + rnum = np.random.rand() + if rnum > 0.6: # add color Gaussian noise + img = img + np.random.normal(0, noise_level / 255.0, img.shape).astype(np.float32) + elif rnum < 0.4: # add grayscale Gaussian noise + img = img + np.random.normal(0, noise_level / 255.0, (*img.shape[:2], 1)).astype(np.float32) + else: # add noise + L = noise_level2 / 255. + D = np.diag(np.random.rand(3)) + U = orth(np.random.rand(3, 3)) + conv = np.dot(np.dot(np.transpose(U), D), U) + img = img + np.random.multivariate_normal([0, 0, 0], np.abs(L ** 2 * conv), img.shape[:2]).astype(np.float32) + img = np.clip(img, 0.0, 1.0) + return img + + +def add_speckle_noise(img, noise_level1=2, noise_level2=25): + noise_level = random.randint(noise_level1, noise_level2) + img = np.clip(img, 0.0, 1.0) + rnum = random.random() + if rnum > 0.6: + img += img * np.random.normal(0, noise_level / 255.0, img.shape).astype(np.float32) + elif rnum < 0.4: + img += img * np.random.normal(0, noise_level / 255.0, (*img.shape[:2], 1)).astype(np.float32) + else: + L = noise_level2 / 255. + D = np.diag(np.random.rand(3)) + U = orth(np.random.rand(3, 3)) + conv = np.dot(np.dot(np.transpose(U), D), U) + img += img * np.random.multivariate_normal([0, 0, 0], np.abs(L ** 2 * conv), img.shape[:2]).astype(np.float32) + img = np.clip(img, 0.0, 1.0) + return img + + +def add_Poisson_noise(img): + img = np.clip((img * 255.0).round(), 0, 255) / 255. + vals = 10 ** (2 * random.random() + 2.0) # [2, 4] + if random.random() < 0.5: + img = np.random.poisson(img * vals).astype(np.float32) / vals + else: + img_gray = np.dot(img[..., :3], [0.299, 0.587, 0.114]) + img_gray = np.clip((img_gray * 255.0).round(), 0, 255) / 255. + noise_gray = np.random.poisson(img_gray * vals).astype(np.float32) / vals - img_gray + img += noise_gray[:, :, np.newaxis] + img = np.clip(img, 0.0, 1.0) + return img + + +def add_JPEG_noise(img): + quality_factor = random.randint(80, 95) + img = cv2.cvtColor(util.single2uint(img), cv2.COLOR_RGB2BGR) + result, encimg = cv2.imencode('.jpg', img, [int(cv2.IMWRITE_JPEG_QUALITY), quality_factor]) + img = cv2.imdecode(encimg, 1) + img = cv2.cvtColor(util.uint2single(img), cv2.COLOR_BGR2RGB) + return img + + +def random_crop(lq, hq, sf=4, lq_patchsize=64): + h, w = lq.shape[:2] + rnd_h = random.randint(0, h - lq_patchsize) + rnd_w = random.randint(0, w - lq_patchsize) + lq = lq[rnd_h:rnd_h + lq_patchsize, rnd_w:rnd_w + lq_patchsize, :] + + rnd_h_H, rnd_w_H = int(rnd_h * sf), int(rnd_w * sf) + hq = hq[rnd_h_H:rnd_h_H + lq_patchsize * sf, rnd_w_H:rnd_w_H + lq_patchsize * sf, :] + return lq, hq + + +def degradation_bsrgan(img, sf=4, lq_patchsize=72, isp_model=None): + """ + This is the degradation model of BSRGAN from the paper + "Designing a Practical Degradation Model for Deep Blind Image Super-Resolution" + ---------- + img: HXWXC, [0, 1], its size should be large than (lq_patchsizexsf)x(lq_patchsizexsf) + sf: scale factor + isp_model: camera ISP model + Returns + ------- + img: low-quality patch, size: lq_patchsizeXlq_patchsizeXC, range: [0, 1] + hq: corresponding high-quality patch, size: (lq_patchsizexsf)X(lq_patchsizexsf)XC, range: [0, 1] + """ + isp_prob, jpeg_prob, scale2_prob = 0.25, 0.9, 0.25 + sf_ori = sf + + h1, w1 = img.shape[:2] + img = img.copy()[:w1 - w1 % sf, :h1 - h1 % sf, ...] # mod crop + h, w = img.shape[:2] + + if h < lq_patchsize * sf or w < lq_patchsize * sf: + raise ValueError(f'img size ({h1}X{w1}) is too small!') + + hq = img.copy() + + if sf == 4 and random.random() < scale2_prob: # downsample1 + if np.random.rand() < 0.5: + img = cv2.resize(img, (int(1 / 2 * img.shape[1]), int(1 / 2 * img.shape[0])), + interpolation=random.choice([1, 2, 3])) + else: + img = util.imresize_np(img, 1 / 2, True) + img = np.clip(img, 0.0, 1.0) + sf = 2 + + shuffle_order = random.sample(range(7), 7) + idx1, idx2 = shuffle_order.index(2), shuffle_order.index(3) + if idx1 > idx2: # keep downsample3 last + shuffle_order[idx1], shuffle_order[idx2] = shuffle_order[idx2], shuffle_order[idx1] + + for i in shuffle_order: + + if i == 0: + img = add_blur(img, sf=sf) + + elif i == 1: + img = add_blur(img, sf=sf) + + elif i == 2: + a, b = img.shape[1], img.shape[0] + # downsample2 + if random.random() < 0.75: + sf1 = random.uniform(1, 2 * sf) + img = cv2.resize(img, (int(1 / sf1 * img.shape[1]), int(1 / sf1 * img.shape[0])), + interpolation=random.choice([1, 2, 3])) + else: + k = fspecial('gaussian', 25, random.uniform(0.1, 0.6 * sf)) + k_shifted = shift_pixel(k, sf) + k_shifted = k_shifted / k_shifted.sum() # blur with shifted kernel + img = ndimage.convolve(img, np.expand_dims(k_shifted, axis=2), mode='mirror') + img = img[0::sf, 0::sf, ...] # nearest downsampling + img = np.clip(img, 0.0, 1.0) + + elif i == 3: + # downsample3 + img = cv2.resize(img, (int(1 / sf * a), int(1 / sf * b)), interpolation=random.choice([1, 2, 3])) + img = np.clip(img, 0.0, 1.0) + + elif i == 4: + # add Gaussian noise + img = add_Gaussian_noise(img, noise_level1=2, noise_level2=8) + + elif i == 5: + # add JPEG noise + if random.random() < jpeg_prob: + img = add_JPEG_noise(img) + + elif i == 6: + # add processed camera sensor noise + if random.random() < isp_prob and isp_model is not None: + with torch.no_grad(): + img, hq = isp_model.forward(img.copy(), hq) + + # add final JPEG compression noise + img = add_JPEG_noise(img) + + # random crop + img, hq = random_crop(img, hq, sf_ori, lq_patchsize) + + return img, hq + + +# todo no isp_model? +def degradation_bsrgan_variant(image, sf=4, isp_model=None): + """ + This is the degradation model of BSRGAN from the paper + "Designing a Practical Degradation Model for Deep Blind Image Super-Resolution" + ---------- + sf: scale factor + isp_model: camera ISP model + Returns + ------- + img: low-quality patch, size: lq_patchsizeXlq_patchsizeXC, range: [0, 1] + hq: corresponding high-quality patch, size: (lq_patchsizexsf)X(lq_patchsizexsf)XC, range: [0, 1] + """ + image = util.uint2single(image) + isp_prob, jpeg_prob, scale2_prob = 0.25, 0.9, 0.25 + sf_ori = sf + + h1, w1 = image.shape[:2] + image = image.copy()[:w1 - w1 % sf, :h1 - h1 % sf, ...] # mod crop + h, w = image.shape[:2] + + hq = image.copy() + + if sf == 4 and random.random() < scale2_prob: # downsample1 + if np.random.rand() < 0.5: + image = cv2.resize(image, (int(1 / 2 * image.shape[1]), int(1 / 2 * image.shape[0])), + interpolation=random.choice([1, 2, 3])) + else: + image = util.imresize_np(image, 1 / 2, True) + image = np.clip(image, 0.0, 1.0) + sf = 2 + + shuffle_order = random.sample(range(7), 7) + idx1, idx2 = shuffle_order.index(2), shuffle_order.index(3) + if idx1 > idx2: # keep downsample3 last + shuffle_order[idx1], shuffle_order[idx2] = shuffle_order[idx2], shuffle_order[idx1] + + for i in shuffle_order: + + if i == 0: + image = add_blur(image, sf=sf) + + # elif i == 1: + # image = add_blur(image, sf=sf) + + if i == 0: + pass + + elif i == 2: + a, b = image.shape[1], image.shape[0] + # downsample2 + if random.random() < 0.8: + sf1 = random.uniform(1, 2 * sf) + image = cv2.resize(image, (int(1 / sf1 * image.shape[1]), int(1 / sf1 * image.shape[0])), + interpolation=random.choice([1, 2, 3])) + else: + k = fspecial('gaussian', 25, random.uniform(0.1, 0.6 * sf)) + k_shifted = shift_pixel(k, sf) + k_shifted = k_shifted / k_shifted.sum() # blur with shifted kernel + image = ndimage.convolve(image, np.expand_dims(k_shifted, axis=2), mode='mirror') + image = image[0::sf, 0::sf, ...] # nearest downsampling + + image = np.clip(image, 0.0, 1.0) + + elif i == 3: + # downsample3 + image = cv2.resize(image, (int(1 / sf * a), int(1 / sf * b)), interpolation=random.choice([1, 2, 3])) + image = np.clip(image, 0.0, 1.0) + + elif i == 4: + # add Gaussian noise + image = add_Gaussian_noise(image, noise_level1=1, noise_level2=2) + + elif i == 5: + # add JPEG noise + if random.random() < jpeg_prob: + image = add_JPEG_noise(image) + # + # elif i == 6: + # # add processed camera sensor noise + # if random.random() < isp_prob and isp_model is not None: + # with torch.no_grad(): + # img, hq = isp_model.forward(img.copy(), hq) + + # add final JPEG compression noise + image = add_JPEG_noise(image) + image = util.single2uint(image) + example = {"image": image} + return example + + + + +if __name__ == '__main__': + print("hey") + img = util.imread_uint('utils/test.png', 3) + img = img[:448, :448] + h = img.shape[0] // 4 + print("resizing to", h) + sf = 4 + deg_fn = partial(degradation_bsrgan_variant, sf=sf) + for i in range(20): + print(i) + img_hq = img + img_lq = deg_fn(img)["image"] + img_hq, img_lq = util.uint2single(img_hq), util.uint2single(img_lq) + print(img_lq) + img_lq_bicubic = albumentations.SmallestMaxSize(max_size=h, interpolation=cv2.INTER_CUBIC)(image=img_hq)["image"] + print(img_lq.shape) + print("bicubic", img_lq_bicubic.shape) + print(img_hq.shape) + lq_nearest = cv2.resize(util.single2uint(img_lq), (int(sf * img_lq.shape[1]), int(sf * img_lq.shape[0])), + interpolation=0) + lq_bicubic_nearest = cv2.resize(util.single2uint(img_lq_bicubic), + (int(sf * img_lq.shape[1]), int(sf * img_lq.shape[0])), + interpolation=0) + img_concat = np.concatenate([lq_bicubic_nearest, lq_nearest, util.single2uint(img_hq)], axis=1) + util.imsave(img_concat, str(i) + '.png') diff --git a/ldm/modules/image_degradation/utils/test.png b/ldm/modules/image_degradation/utils/test.png new file mode 100755 index 0000000..4249b43 Binary files /dev/null and b/ldm/modules/image_degradation/utils/test.png differ diff --git a/ldm/modules/image_degradation/utils_image.py b/ldm/modules/image_degradation/utils_image.py new file mode 100755 index 0000000..0175f15 --- /dev/null +++ b/ldm/modules/image_degradation/utils_image.py @@ -0,0 +1,916 @@ +import os +import math +import random +import numpy as np +import torch +import cv2 +from torchvision.utils import make_grid +from datetime import datetime +#import matplotlib.pyplot as plt # TODO: check with Dominik, also bsrgan.py vs bsrgan_light.py + + +os.environ["KMP_DUPLICATE_LIB_OK"]="TRUE" + + +''' +# -------------------------------------------- +# Kai Zhang (github: https://github.com/cszn) +# 03/Mar/2019 +# -------------------------------------------- +# https://github.com/twhui/SRGAN-pyTorch +# https://github.com/xinntao/BasicSR +# -------------------------------------------- +''' + + +IMG_EXTENSIONS = ['.jpg', '.JPG', '.jpeg', '.JPEG', '.png', '.PNG', '.ppm', '.PPM', '.bmp', '.BMP', '.tif'] + + +def is_image_file(filename): + return any(filename.endswith(extension) for extension in IMG_EXTENSIONS) + + +def get_timestamp(): + return datetime.now().strftime('%y%m%d-%H%M%S') + + +def imshow(x, title=None, cbar=False, figsize=None): + plt.figure(figsize=figsize) + plt.imshow(np.squeeze(x), interpolation='nearest', cmap='gray') + if title: + plt.title(title) + if cbar: + plt.colorbar() + plt.show() + + +def surf(Z, cmap='rainbow', figsize=None): + plt.figure(figsize=figsize) + ax3 = plt.axes(projection='3d') + + w, h = Z.shape[:2] + xx = np.arange(0,w,1) + yy = np.arange(0,h,1) + X, Y = np.meshgrid(xx, yy) + ax3.plot_surface(X,Y,Z,cmap=cmap) + #ax3.contour(X,Y,Z, zdim='z',offset=-2，cmap=cmap) + plt.show() + + +''' +# -------------------------------------------- +# get image pathes +# -------------------------------------------- +''' + + +def get_image_paths(dataroot): + paths = None # return None if dataroot is None + if dataroot is not None: + paths = sorted(_get_paths_from_images(dataroot)) + return paths + + +def _get_paths_from_images(path): + assert os.path.isdir(path), '{:s} is not a valid directory'.format(path) + images = [] + for dirpath, _, fnames in sorted(os.walk(path)): + for fname in sorted(fnames): + if is_image_file(fname): + img_path = os.path.join(dirpath, fname) + images.append(img_path) + assert images, '{:s} has no valid image file'.format(path) + return images + + +''' +# -------------------------------------------- +# split large images into small images +# -------------------------------------------- +''' + + +def patches_from_image(img, p_size=512, p_overlap=64, p_max=800): + w, h = img.shape[:2] + patches = [] + if w > p_max and h > p_max: + w1 = list(np.arange(0, w-p_size, p_size-p_overlap, dtype=np.int)) + h1 = list(np.arange(0, h-p_size, p_size-p_overlap, dtype=np.int)) + w1.append(w-p_size) + h1.append(h-p_size) +# print(w1) +# print(h1) + for i in w1: + for j in h1: + patches.append(img[i:i+p_size, j:j+p_size,:]) + else: + patches.append(img) + + return patches + + +def imssave(imgs, img_path): + """ + imgs: list, N images of size WxHxC + """ + img_name, ext = os.path.splitext(os.path.basename(img_path)) + + for i, img in enumerate(imgs): + if img.ndim == 3: + img = img[:, :, [2, 1, 0]] + new_path = os.path.join(os.path.dirname(img_path), img_name+str('_s{:04d}'.format(i))+'.png') + cv2.imwrite(new_path, img) + + +def split_imageset(original_dataroot, taget_dataroot, n_channels=3, p_size=800, p_overlap=96, p_max=1000): + """ + split the large images from original_dataroot into small overlapped images with size (p_size)x(p_size), + and save them into taget_dataroot; only the images with larger size than (p_max)x(p_max) + will be splitted. + Args: + original_dataroot: + taget_dataroot: + p_size: size of small images + p_overlap: patch size in training is a good choice + p_max: images with smaller size than (p_max)x(p_max) keep unchanged. + """ + paths = get_image_paths(original_dataroot) + for img_path in paths: + # img_name, ext = os.path.splitext(os.path.basename(img_path)) + img = imread_uint(img_path, n_channels=n_channels) + patches = patches_from_image(img, p_size, p_overlap, p_max) + imssave(patches, os.path.join(taget_dataroot,os.path.basename(img_path))) + #if original_dataroot == taget_dataroot: + #del img_path + +''' +# -------------------------------------------- +# makedir +# -------------------------------------------- +''' + + +def mkdir(path): + if not os.path.exists(path): + os.makedirs(path) + + +def mkdirs(paths): + if isinstance(paths, str): + mkdir(paths) + else: + for path in paths: + mkdir(path) + + +def mkdir_and_rename(path): + if os.path.exists(path): + new_name = path + '_archived_' + get_timestamp() + print('Path already exists. Rename it to [{:s}]'.format(new_name)) + os.rename(path, new_name) + os.makedirs(path) + + +''' +# -------------------------------------------- +# read image from path +# opencv is fast, but read BGR numpy image +# -------------------------------------------- +''' + + +# -------------------------------------------- +# get uint8 image of size HxWxn_channles (RGB) +# -------------------------------------------- +def imread_uint(path, n_channels=3): + # input: path + # output: HxWx3(RGB or GGG), or HxWx1 (G) + if n_channels == 1: + img = cv2.imread(path, 0) # cv2.IMREAD_GRAYSCALE + img = np.expand_dims(img, axis=2) # HxWx1 + elif n_channels == 3: + img = cv2.imread(path, cv2.IMREAD_UNCHANGED) # BGR or G + if img.ndim == 2: + img = cv2.cvtColor(img, cv2.COLOR_GRAY2RGB) # GGG + else: + img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) # RGB + return img + + +# -------------------------------------------- +# matlab's imwrite +# -------------------------------------------- +def imsave(img, img_path): + img = np.squeeze(img) + if img.ndim == 3: + img = img[:, :, [2, 1, 0]] + cv2.imwrite(img_path, img) + +def imwrite(img, img_path): + img = np.squeeze(img) + if img.ndim == 3: + img = img[:, :, [2, 1, 0]] + cv2.imwrite(img_path, img) + + + +# -------------------------------------------- +# get single image of size HxWxn_channles (BGR) +# -------------------------------------------- +def read_img(path): + # read image by cv2 + # return: Numpy float32, HWC, BGR, [0,1] + img = cv2.imread(path, cv2.IMREAD_UNCHANGED) # cv2.IMREAD_GRAYSCALE + img = img.astype(np.float32) / 255. + if img.ndim == 2: + img = np.expand_dims(img, axis=2) + # some images have 4 channels + if img.shape[2] > 3: + img = img[:, :, :3] + return img + + +''' +# -------------------------------------------- +# image format conversion +# -------------------------------------------- +# numpy(single) <---> numpy(unit) +# numpy(single) <---> tensor +# numpy(unit) <---> tensor +# -------------------------------------------- +''' + + +# -------------------------------------------- +# numpy(single) [0, 1] <---> numpy(unit) +# -------------------------------------------- + + +def uint2single(img): + + return np.float32(img/255.) + + +def single2uint(img): + + return np.uint8((img.clip(0, 1)*255.).round()) + + +def uint162single(img): + + return np.float32(img/65535.) + + +def single2uint16(img): + + return np.uint16((img.clip(0, 1)*65535.).round()) + + +# -------------------------------------------- +# numpy(unit) (HxWxC or HxW) <---> tensor +# -------------------------------------------- + + +# convert uint to 4-dimensional torch tensor +def uint2tensor4(img): + if img.ndim == 2: + img = np.expand_dims(img, axis=2) + return torch.from_numpy(np.ascontiguousarray(img)).permute(2, 0, 1).float().div(255.).unsqueeze(0) + + +# convert uint to 3-dimensional torch tensor +def uint2tensor3(img): + if img.ndim == 2: + img = np.expand_dims(img, axis=2) + return torch.from_numpy(np.ascontiguousarray(img)).permute(2, 0, 1).float().div(255.) + + +# convert 2/3/4-dimensional torch tensor to uint +def tensor2uint(img): + img = img.data.squeeze().float().clamp_(0, 1).cpu().numpy() + if img.ndim == 3: + img = np.transpose(img, (1, 2, 0)) + return np.uint8((img*255.0).round()) + + +# -------------------------------------------- +# numpy(single) (HxWxC) <---> tensor +# -------------------------------------------- + + +# convert single (HxWxC) to 3-dimensional torch tensor +def single2tensor3(img): + return torch.from_numpy(np.ascontiguousarray(img)).permute(2, 0, 1).float() + + +# convert single (HxWxC) to 4-dimensional torch tensor +def single2tensor4(img): + return torch.from_numpy(np.ascontiguousarray(img)).permute(2, 0, 1).float().unsqueeze(0) + + +# convert torch tensor to single +def tensor2single(img): + img = img.data.squeeze().float().cpu().numpy() + if img.ndim == 3: + img = np.transpose(img, (1, 2, 0)) + + return img + +# convert torch tensor to single +def tensor2single3(img): + img = img.data.squeeze().float().cpu().numpy() + if img.ndim == 3: + img = np.transpose(img, (1, 2, 0)) + elif img.ndim == 2: + img = np.expand_dims(img, axis=2) + return img + + +def single2tensor5(img): + return torch.from_numpy(np.ascontiguousarray(img)).permute(2, 0, 1, 3).float().unsqueeze(0) + + +def single32tensor5(img): + return torch.from_numpy(np.ascontiguousarray(img)).float().unsqueeze(0).unsqueeze(0) + + +def single42tensor4(img): + return torch.from_numpy(np.ascontiguousarray(img)).permute(2, 0, 1, 3).float() + + +# from skimage.io import imread, imsave +def tensor2img(tensor, out_type=np.uint8, min_max=(0, 1)): + ''' + Converts a torch Tensor into an image Numpy array of BGR channel order + Input: 4D(B,(3/1),H,W), 3D(C,H,W), or 2D(H,W), any range, RGB channel order + Output: 3D(H,W,C) or 2D(H,W), [0,255], np.uint8 (default) + ''' + tensor = tensor.squeeze().float().cpu().clamp_(*min_max) # squeeze first, then clamp + tensor = (tensor - min_max[0]) / (min_max[1] - min_max[0]) # to range [0,1] + n_dim = tensor.dim() + if n_dim == 4: + n_img = len(tensor) + img_np = make_grid(tensor, nrow=int(math.sqrt(n_img)), normalize=False).numpy() + img_np = np.transpose(img_np[[2, 1, 0], :, :], (1, 2, 0)) # HWC, BGR + elif n_dim == 3: + img_np = tensor.numpy() + img_np = np.transpose(img_np[[2, 1, 0], :, :], (1, 2, 0)) # HWC, BGR + elif n_dim == 2: + img_np = tensor.numpy() + else: + raise TypeError( + 'Only support 4D, 3D and 2D tensor. But received with dimension: {:d}'.format(n_dim)) + if out_type == np.uint8: + img_np = (img_np * 255.0).round() + # Important. Unlike matlab, numpy.unit8() WILL NOT round by default. + return img_np.astype(out_type) + + +''' +# -------------------------------------------- +# Augmentation, flipe and/or rotate +# -------------------------------------------- +# The following two are enough. +# (1) augmet_img: numpy image of WxHxC or WxH +# (2) augment_img_tensor4: tensor image 1xCxWxH +# -------------------------------------------- +''' + + +def augment_img(img, mode=0): + '''Kai Zhang (github: https://github.com/cszn) + ''' + if mode == 0: + return img + elif mode == 1: + return np.flipud(np.rot90(img)) + elif mode == 2: + return np.flipud(img) + elif mode == 3: + return np.rot90(img, k=3) + elif mode == 4: + return np.flipud(np.rot90(img, k=2)) + elif mode == 5: + return np.rot90(img) + elif mode == 6: + return np.rot90(img, k=2) + elif mode == 7: + return np.flipud(np.rot90(img, k=3)) + + +def augment_img_tensor4(img, mode=0): + '''Kai Zhang (github: https://github.com/cszn) + ''' + if mode == 0: + return img + elif mode == 1: + return img.rot90(1, [2, 3]).flip([2]) + elif mode == 2: + return img.flip([2]) + elif mode == 3: + return img.rot90(3, [2, 3]) + elif mode == 4: + return img.rot90(2, [2, 3]).flip([2]) + elif mode == 5: + return img.rot90(1, [2, 3]) + elif mode == 6: + return img.rot90(2, [2, 3]) + elif mode == 7: + return img.rot90(3, [2, 3]).flip([2]) + + +def augment_img_tensor(img, mode=0): + '''Kai Zhang (github: https://github.com/cszn) + ''' + img_size = img.size() + img_np = img.data.cpu().numpy() + if len(img_size) == 3: + img_np = np.transpose(img_np, (1, 2, 0)) + elif len(img_size) == 4: + img_np = np.transpose(img_np, (2, 3, 1, 0)) + img_np = augment_img(img_np, mode=mode) + img_tensor = torch.from_numpy(np.ascontiguousarray(img_np)) + if len(img_size) == 3: + img_tensor = img_tensor.permute(2, 0, 1) + elif len(img_size) == 4: + img_tensor = img_tensor.permute(3, 2, 0, 1) + + return img_tensor.type_as(img) + + +def augment_img_np3(img, mode=0): + if mode == 0: + return img + elif mode == 1: + return img.transpose(1, 0, 2) + elif mode == 2: + return img[::-1, :, :] + elif mode == 3: + img = img[::-1, :, :] + img = img.transpose(1, 0, 2) + return img + elif mode == 4: + return img[:, ::-1, :] + elif mode == 5: + img = img[:, ::-1, :] + img = img.transpose(1, 0, 2) + return img + elif mode == 6: + img = img[:, ::-1, :] + img = img[::-1, :, :] + return img + elif mode == 7: + img = img[:, ::-1, :] + img = img[::-1, :, :] + img = img.transpose(1, 0, 2) + return img + + +def augment_imgs(img_list, hflip=True, rot=True): + # horizontal flip OR rotate + hflip = hflip and random.random() < 0.5 + vflip = rot and random.random() < 0.5 + rot90 = rot and random.random() < 0.5 + + def _augment(img): + if hflip: + img = img[:, ::-1, :] + if vflip: + img = img[::-1, :, :] + if rot90: + img = img.transpose(1, 0, 2) + return img + + return [_augment(img) for img in img_list] + + +''' +# -------------------------------------------- +# modcrop and shave +# -------------------------------------------- +''' + + +def modcrop(img_in, scale): + # img_in: Numpy, HWC or HW + img = np.copy(img_in) + if img.ndim == 2: + H, W = img.shape + H_r, W_r = H % scale, W % scale + img = img[:H - H_r, :W - W_r] + elif img.ndim == 3: + H, W, C = img.shape + H_r, W_r = H % scale, W % scale + img = img[:H - H_r, :W - W_r, :] + else: + raise ValueError('Wrong img ndim: [{:d}].'.format(img.ndim)) + return img + + +def shave(img_in, border=0): + # img_in: Numpy, HWC or HW + img = np.copy(img_in) + h, w = img.shape[:2] + img = img[border:h-border, border:w-border] + return img + + +''' +# -------------------------------------------- +# image processing process on numpy image +# channel_convert(in_c, tar_type, img_list): +# rgb2ycbcr(img, only_y=True): +# bgr2ycbcr(img, only_y=True): +# ycbcr2rgb(img): +# -------------------------------------------- +''' + + +def rgb2ycbcr(img, only_y=True): + '''same as matlab rgb2ycbcr + only_y: only return Y channel + Input: + uint8, [0, 255] + float, [0, 1] + ''' + in_img_type = img.dtype + img.astype(np.float32) + if in_img_type != np.uint8: + img *= 255. + # convert + if only_y: + rlt = np.dot(img, [65.481, 128.553, 24.966]) / 255.0 + 16.0 + else: + rlt = np.matmul(img, [[65.481, -37.797, 112.0], [128.553, -74.203, -93.786], + [24.966, 112.0, -18.214]]) / 255.0 + [16, 128, 128] + if in_img_type == np.uint8: + rlt = rlt.round() + else: + rlt /= 255. + return rlt.astype(in_img_type) + + +def ycbcr2rgb(img): + '''same as matlab ycbcr2rgb + Input: + uint8, [0, 255] + float, [0, 1] + ''' + in_img_type = img.dtype + img.astype(np.float32) + if in_img_type != np.uint8: + img *= 255. + # convert + rlt = np.matmul(img, [[0.00456621, 0.00456621, 0.00456621], [0, -0.00153632, 0.00791071], + [0.00625893, -0.00318811, 0]]) * 255.0 + [-222.921, 135.576, -276.836] + if in_img_type == np.uint8: + rlt = rlt.round() + else: + rlt /= 255. + return rlt.astype(in_img_type) + + +def bgr2ycbcr(img, only_y=True): + '''bgr version of rgb2ycbcr + only_y: only return Y channel + Input: + uint8, [0, 255] + float, [0, 1] + ''' + in_img_type = img.dtype + img.astype(np.float32) + if in_img_type != np.uint8: + img *= 255. + # convert + if only_y: + rlt = np.dot(img, [24.966, 128.553, 65.481]) / 255.0 + 16.0 + else: + rlt = np.matmul(img, [[24.966, 112.0, -18.214], [128.553, -74.203, -93.786], + [65.481, -37.797, 112.0]]) / 255.0 + [16, 128, 128] + if in_img_type == np.uint8: + rlt = rlt.round() + else: + rlt /= 255. + return rlt.astype(in_img_type) + + +def channel_convert(in_c, tar_type, img_list): + # conversion among BGR, gray and y + if in_c == 3 and tar_type == 'gray': # BGR to gray + gray_list = [cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) for img in img_list] + return [np.expand_dims(img, axis=2) for img in gray_list] + elif in_c == 3 and tar_type == 'y': # BGR to y + y_list = [bgr2ycbcr(img, only_y=True) for img in img_list] + return [np.expand_dims(img, axis=2) for img in y_list] + elif in_c == 1 and tar_type == 'RGB': # gray/y to BGR + return [cv2.cvtColor(img, cv2.COLOR_GRAY2BGR) for img in img_list] + else: + return img_list + + +''' +# -------------------------------------------- +# metric, PSNR and SSIM +# -------------------------------------------- +''' + + +# -------------------------------------------- +# PSNR +# -------------------------------------------- +def calculate_psnr(img1, img2, border=0): + # img1 and img2 have range [0, 255] + #img1 = img1.squeeze() + #img2 = img2.squeeze() + if not img1.shape == img2.shape: + raise ValueError('Input images must have the same dimensions.') + h, w = img1.shape[:2] + img1 = img1[border:h-border, border:w-border] + img2 = img2[border:h-border, border:w-border] + + 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)) + + +# -------------------------------------------- +# SSIM +# -------------------------------------------- +def calculate_ssim(img1, img2, border=0): + '''calculate SSIM + the same outputs as MATLAB's + img1, img2: [0, 255] + ''' + #img1 = img1.squeeze() + #img2 = img2.squeeze() + if not img1.shape == img2.shape: + raise ValueError('Input images must have the same dimensions.') + h, w = img1.shape[:2] + img1 = img1[border:h-border, border:w-border] + img2 = img2[border:h-border, border:w-border] + + if img1.ndim == 2: + return ssim(img1, img2) + elif img1.ndim == 3: + if img1.shape[2] == 3: + ssims = [] + for i in range(3): + ssims.append(ssim(img1[:,:,i], img2[:,:,i])) + 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.') + + +def ssim(img1, img2): + 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() + + +''' +# -------------------------------------------- +# matlab's bicubic imresize (numpy and torch) [0, 1] +# -------------------------------------------- +''' + + +# matlab 'imresize' function, now only support 'bicubic' +def cubic(x): + absx = torch.abs(x) + absx2 = absx**2 + absx3 = absx**3 + return (1.5*absx3 - 2.5*absx2 + 1) * ((absx <= 1).type_as(absx)) + \ + (-0.5*absx3 + 2.5*absx2 - 4*absx + 2) * (((absx > 1)*(absx <= 2)).type_as(absx)) + + +def calculate_weights_indices(in_length, out_length, scale, kernel, kernel_width, antialiasing): + if (scale < 1) and (antialiasing): + # Use a modified kernel to simultaneously interpolate and antialias- larger kernel width + kernel_width = kernel_width / scale + + # Output-space coordinates + x = torch.linspace(1, out_length, out_length) + + # Input-space coordinates. Calculate the inverse mapping such that 0.5 + # in output space maps to 0.5 in input space, and 0.5+scale in output + # space maps to 1.5 in input space. + u = x / scale + 0.5 * (1 - 1 / scale) + + # What is the left-most pixel that can be involved in the computation? + left = torch.floor(u - kernel_width / 2) + + # What is the maximum number of pixels that can be involved in the + # computation? Note: it's OK to use an extra pixel here; if the + # corresponding weights are all zero, it will be eliminated at the end + # of this function. + P = math.ceil(kernel_width) + 2 + + # The indices of the input pixels involved in computing the k-th output + # pixel are in row k of the indices matrix. + indices = left.view(out_length, 1).expand(out_length, P) + torch.linspace(0, P - 1, P).view( + 1, P).expand(out_length, P) + + # The weights used to compute the k-th output pixel are in row k of the + # weights matrix. + distance_to_center = u.view(out_length, 1).expand(out_length, P) - indices + # apply cubic kernel + if (scale < 1) and (antialiasing): + weights = scale * cubic(distance_to_center * scale) + else: + weights = cubic(distance_to_center) + # Normalize the weights matrix so that each row sums to 1. + weights_sum = torch.sum(weights, 1).view(out_length, 1) + weights = weights / weights_sum.expand(out_length, P) + + # If a column in weights is all zero, get rid of it. only consider the first and last column. + weights_zero_tmp = torch.sum((weights == 0), 0) + if not math.isclose(weights_zero_tmp[0], 0, rel_tol=1e-6): + indices = indices.narrow(1, 1, P - 2) + weights = weights.narrow(1, 1, P - 2) + if not math.isclose(weights_zero_tmp[-1], 0, rel_tol=1e-6): + indices = indices.narrow(1, 0, P - 2) + weights = weights.narrow(1, 0, P - 2) + weights = weights.contiguous() + indices = indices.contiguous() + sym_len_s = -indices.min() + 1 + sym_len_e = indices.max() - in_length + indices = indices + sym_len_s - 1 + return weights, indices, int(sym_len_s), int(sym_len_e) + + +# -------------------------------------------- +# imresize for tensor image [0, 1] +# -------------------------------------------- +def imresize(img, scale, antialiasing=True): + # Now the scale should be the same for H and W + # input: img: pytorch tensor, CHW or HW [0,1] + # output: CHW or HW [0,1] w/o round + need_squeeze = True if img.dim() == 2 else False + if need_squeeze: + img.unsqueeze_(0) + in_C, in_H, in_W = img.size() + out_C, out_H, out_W = in_C, math.ceil(in_H * scale), math.ceil(in_W * scale) + kernel_width = 4 + kernel = 'cubic' + + # Return the desired dimension order for performing the resize. The + # strategy is to perform the resize first along the dimension with the + # smallest scale factor. + # Now we do not support this. + + # get weights and indices + weights_H, indices_H, sym_len_Hs, sym_len_He = calculate_weights_indices( + in_H, out_H, scale, kernel, kernel_width, antialiasing) + weights_W, indices_W, sym_len_Ws, sym_len_We = calculate_weights_indices( + in_W, out_W, scale, kernel, kernel_width, antialiasing) + # process H dimension + # symmetric copying + img_aug = torch.FloatTensor(in_C, in_H + sym_len_Hs + sym_len_He, in_W) + img_aug.narrow(1, sym_len_Hs, in_H).copy_(img) + + sym_patch = img[:, :sym_len_Hs, :] + inv_idx = torch.arange(sym_patch.size(1) - 1, -1, -1).long() + sym_patch_inv = sym_patch.index_select(1, inv_idx) + img_aug.narrow(1, 0, sym_len_Hs).copy_(sym_patch_inv) + + sym_patch = img[:, -sym_len_He:, :] + inv_idx = torch.arange(sym_patch.size(1) - 1, -1, -1).long() + sym_patch_inv = sym_patch.index_select(1, inv_idx) + img_aug.narrow(1, sym_len_Hs + in_H, sym_len_He).copy_(sym_patch_inv) + + out_1 = torch.FloatTensor(in_C, out_H, in_W) + kernel_width = weights_H.size(1) + for i in range(out_H): + idx = int(indices_H[i][0]) + for j in range(out_C): + out_1[j, i, :] = img_aug[j, idx:idx + kernel_width, :].transpose(0, 1).mv(weights_H[i]) + + # process W dimension + # symmetric copying + out_1_aug = torch.FloatTensor(in_C, out_H, in_W + sym_len_Ws + sym_len_We) + out_1_aug.narrow(2, sym_len_Ws, in_W).copy_(out_1) + + sym_patch = out_1[:, :, :sym_len_Ws] + inv_idx = torch.arange(sym_patch.size(2) - 1, -1, -1).long() + sym_patch_inv = sym_patch.index_select(2, inv_idx) + out_1_aug.narrow(2, 0, sym_len_Ws).copy_(sym_patch_inv) + + sym_patch = out_1[:, :, -sym_len_We:] + inv_idx = torch.arange(sym_patch.size(2) - 1, -1, -1).long() + sym_patch_inv = sym_patch.index_select(2, inv_idx) + out_1_aug.narrow(2, sym_len_Ws + in_W, sym_len_We).copy_(sym_patch_inv) + + out_2 = torch.FloatTensor(in_C, out_H, out_W) + kernel_width = weights_W.size(1) + for i in range(out_W): + idx = int(indices_W[i][0]) + for j in range(out_C): + out_2[j, :, i] = out_1_aug[j, :, idx:idx + kernel_width].mv(weights_W[i]) + if need_squeeze: + out_2.squeeze_() + return out_2 + + +# -------------------------------------------- +# imresize for numpy image [0, 1] +# -------------------------------------------- +def imresize_np(img, scale, antialiasing=True): + # Now the scale should be the same for H and W + # input: img: Numpy, HWC or HW [0,1] + # output: HWC or HW [0,1] w/o round + img = torch.from_numpy(img) + need_squeeze = True if img.dim() == 2 else False + if need_squeeze: + img.unsqueeze_(2) + + in_H, in_W, in_C = img.size() + out_C, out_H, out_W = in_C, math.ceil(in_H * scale), math.ceil(in_W * scale) + kernel_width = 4 + kernel = 'cubic' + + # Return the desired dimension order for performing the resize. The + # strategy is to perform the resize first along the dimension with the + # smallest scale factor. + # Now we do not support this. + + # get weights and indices + weights_H, indices_H, sym_len_Hs, sym_len_He = calculate_weights_indices( + in_H, out_H, scale, kernel, kernel_width, antialiasing) + weights_W, indices_W, sym_len_Ws, sym_len_We = calculate_weights_indices( + in_W, out_W, scale, kernel, kernel_width, antialiasing) + # process H dimension + # symmetric copying + img_aug = torch.FloatTensor(in_H + sym_len_Hs + sym_len_He, in_W, in_C) + img_aug.narrow(0, sym_len_Hs, in_H).copy_(img) + + sym_patch = img[:sym_len_Hs, :, :] + inv_idx = torch.arange(sym_patch.size(0) - 1, -1, -1).long() + sym_patch_inv = sym_patch.index_select(0, inv_idx) + img_aug.narrow(0, 0, sym_len_Hs).copy_(sym_patch_inv) + + sym_patch = img[-sym_len_He:, :, :] + inv_idx = torch.arange(sym_patch.size(0) - 1, -1, -1).long() + sym_patch_inv = sym_patch.index_select(0, inv_idx) + img_aug.narrow(0, sym_len_Hs + in_H, sym_len_He).copy_(sym_patch_inv) + + out_1 = torch.FloatTensor(out_H, in_W, in_C) + kernel_width = weights_H.size(1) + for i in range(out_H): + idx = int(indices_H[i][0]) + for j in range(out_C): + out_1[i, :, j] = img_aug[idx:idx + kernel_width, :, j].transpose(0, 1).mv(weights_H[i]) + + # process W dimension + # symmetric copying + out_1_aug = torch.FloatTensor(out_H, in_W + sym_len_Ws + sym_len_We, in_C) + out_1_aug.narrow(1, sym_len_Ws, in_W).copy_(out_1) + + sym_patch = out_1[:, :sym_len_Ws, :] + inv_idx = torch.arange(sym_patch.size(1) - 1, -1, -1).long() + sym_patch_inv = sym_patch.index_select(1, inv_idx) + out_1_aug.narrow(1, 0, sym_len_Ws).copy_(sym_patch_inv) + + sym_patch = out_1[:, -sym_len_We:, :] + inv_idx = torch.arange(sym_patch.size(1) - 1, -1, -1).long() + sym_patch_inv = sym_patch.index_select(1, inv_idx) + out_1_aug.narrow(1, sym_len_Ws + in_W, sym_len_We).copy_(sym_patch_inv) + + out_2 = torch.FloatTensor(out_H, out_W, in_C) + kernel_width = weights_W.size(1) + for i in range(out_W): + idx = int(indices_W[i][0]) + for j in range(out_C): + out_2[:, i, j] = out_1_aug[:, idx:idx + kernel_width, j].mv(weights_W[i]) + if need_squeeze: + out_2.squeeze_() + + return out_2.numpy() + + +if __name__ == '__main__': + print('---') +# img = imread_uint('test.bmp', 3) +# img = uint2single(img) +# img_bicubic = imresize_np(img, 1/4) \ No newline at end of file diff --git a/ldm/modules/losses/__init__.py b/ldm/modules/losses/__init__.py new file mode 100755 index 0000000..876d7c5 --- /dev/null +++ b/ldm/modules/losses/__init__.py @@ -0,0 +1 @@ +from ldm.modules.losses.contperceptual import LPIPSWithDiscriminator \ No newline at end of file diff --git a/ldm/modules/losses/contperceptual.py b/ldm/modules/losses/contperceptual.py new file mode 100755 index 0000000..672c1e3 --- /dev/null +++ b/ldm/modules/losses/contperceptual.py @@ -0,0 +1,111 @@ +import torch +import torch.nn as nn + +from taming.modules.losses.vqperceptual import * # TODO: taming dependency yes/no? + + +class LPIPSWithDiscriminator(nn.Module): + def __init__(self, disc_start, logvar_init=0.0, kl_weight=1.0, pixelloss_weight=1.0, + disc_num_layers=3, disc_in_channels=3, disc_factor=1.0, disc_weight=1.0, + perceptual_weight=1.0, use_actnorm=False, disc_conditional=False, + disc_loss="hinge"): + + super().__init__() + assert disc_loss in ["hinge", "vanilla"] + self.kl_weight = kl_weight + self.pixel_weight = pixelloss_weight + self.perceptual_loss = LPIPS().eval() + self.perceptual_weight = perceptual_weight + # output log variance + self.logvar = nn.Parameter(torch.ones(size=()) * logvar_init) + + self.discriminator = NLayerDiscriminator(input_nc=disc_in_channels, + n_layers=disc_num_layers, + use_actnorm=use_actnorm + ).apply(weights_init) + self.discriminator_iter_start = disc_start + self.disc_loss = hinge_d_loss if disc_loss == "hinge" else vanilla_d_loss + self.disc_factor = disc_factor + self.discriminator_weight = disc_weight + self.disc_conditional = disc_conditional + + def calculate_adaptive_weight(self, nll_loss, g_loss, last_layer=None): + if last_layer is not None: + nll_grads = torch.autograd.grad(nll_loss, last_layer, retain_graph=True)[0] + g_grads = torch.autograd.grad(g_loss, last_layer, retain_graph=True)[0] + else: + nll_grads = torch.autograd.grad(nll_loss, self.last_layer[0], retain_graph=True)[0] + g_grads = torch.autograd.grad(g_loss, self.last_layer[0], retain_graph=True)[0] + + d_weight = torch.norm(nll_grads) / (torch.norm(g_grads) + 1e-4) + d_weight = torch.clamp(d_weight, 0.0, 1e4).detach() + d_weight = d_weight * self.discriminator_weight + return d_weight + + def forward(self, inputs, reconstructions, posteriors, optimizer_idx, + global_step, last_layer=None, cond=None, split="train", + weights=None): + rec_loss = torch.abs(inputs.contiguous() - reconstructions.contiguous()) + if self.perceptual_weight > 0: + p_loss = self.perceptual_loss(inputs.contiguous(), reconstructions.contiguous()) + rec_loss = rec_loss + self.perceptual_weight * p_loss + + nll_loss = rec_loss / torch.exp(self.logvar) + self.logvar + weighted_nll_loss = nll_loss + if weights is not None: + weighted_nll_loss = weights*nll_loss + weighted_nll_loss = torch.sum(weighted_nll_loss) / weighted_nll_loss.shape[0] + nll_loss = torch.sum(nll_loss) / nll_loss.shape[0] + kl_loss = posteriors.kl() + kl_loss = torch.sum(kl_loss) / kl_loss.shape[0] + + # now the GAN part + if optimizer_idx == 0: + # generator update + if cond is None: + assert not self.disc_conditional + logits_fake = self.discriminator(reconstructions.contiguous()) + else: + assert self.disc_conditional + logits_fake = self.discriminator(torch.cat((reconstructions.contiguous(), cond), dim=1)) + g_loss = -torch.mean(logits_fake) + + if self.disc_factor > 0.0: + try: + d_weight = self.calculate_adaptive_weight(nll_loss, g_loss, last_layer=last_layer) + except RuntimeError: + assert not self.training + d_weight = torch.tensor(0.0) + else: + d_weight = torch.tensor(0.0) + + disc_factor = adopt_weight(self.disc_factor, global_step, threshold=self.discriminator_iter_start) + loss = weighted_nll_loss + self.kl_weight * kl_loss + d_weight * disc_factor * g_loss + + log = {"{}/total_loss".format(split): loss.clone().detach().mean(), "{}/logvar".format(split): self.logvar.detach(), + "{}/kl_loss".format(split): kl_loss.detach().mean(), "{}/nll_loss".format(split): nll_loss.detach().mean(), + "{}/rec_loss".format(split): rec_loss.detach().mean(), + "{}/d_weight".format(split): d_weight.detach(), + "{}/disc_factor".format(split): torch.tensor(disc_factor), + "{}/g_loss".format(split): g_loss.detach().mean(), + } + return loss, log + + if optimizer_idx == 1: + # second pass for discriminator update + if cond is None: + logits_real = self.discriminator(inputs.contiguous().detach()) + logits_fake = self.discriminator(reconstructions.contiguous().detach()) + else: + logits_real = self.discriminator(torch.cat((inputs.contiguous().detach(), cond), dim=1)) + logits_fake = self.discriminator(torch.cat((reconstructions.contiguous().detach(), cond), dim=1)) + + disc_factor = adopt_weight(self.disc_factor, global_step, threshold=self.discriminator_iter_start) + d_loss = disc_factor * self.disc_loss(logits_real, logits_fake) + + log = {"{}/disc_loss".format(split): d_loss.clone().detach().mean(), + "{}/logits_real".format(split): logits_real.detach().mean(), + "{}/logits_fake".format(split): logits_fake.detach().mean() + } + return d_loss, log + diff --git a/ldm/modules/losses/vqperceptual.py b/ldm/modules/losses/vqperceptual.py new file mode 100755 index 0000000..f699817 --- /dev/null +++ b/ldm/modules/losses/vqperceptual.py @@ -0,0 +1,167 @@ +import torch +from torch import nn +import torch.nn.functional as F +from einops import repeat + +from taming.modules.discriminator.model import NLayerDiscriminator, weights_init +from taming.modules.losses.lpips import LPIPS +from taming.modules.losses.vqperceptual import hinge_d_loss, vanilla_d_loss + + +def hinge_d_loss_with_exemplar_weights(logits_real, logits_fake, weights): + assert weights.shape[0] == logits_real.shape[0] == logits_fake.shape[0] + loss_real = torch.mean(F.relu(1. - logits_real), dim=[1,2,3]) + loss_fake = torch.mean(F.relu(1. + logits_fake), dim=[1,2,3]) + loss_real = (weights * loss_real).sum() / weights.sum() + loss_fake = (weights * loss_fake).sum() / weights.sum() + d_loss = 0.5 * (loss_real + loss_fake) + return d_loss + +def adopt_weight(weight, global_step, threshold=0, value=0.): + if global_step < threshold: + weight = value + return weight + + +def measure_perplexity(predicted_indices, n_embed): + # src: https://github.com/karpathy/deep-vector-quantization/blob/main/model.py + # eval cluster perplexity. when perplexity == num_embeddings then all clusters are used exactly equally + encodings = F.one_hot(predicted_indices, n_embed).float().reshape(-1, n_embed) + avg_probs = encodings.mean(0) + perplexity = (-(avg_probs * torch.log(avg_probs + 1e-10)).sum()).exp() + cluster_use = torch.sum(avg_probs > 0) + return perplexity, cluster_use + +def l1(x, y): + return torch.abs(x-y) + + +def l2(x, y): + return torch.pow((x-y), 2) + + +class VQLPIPSWithDiscriminator(nn.Module): + def __init__(self, disc_start, codebook_weight=1.0, pixelloss_weight=1.0, + disc_num_layers=3, disc_in_channels=3, disc_factor=1.0, disc_weight=1.0, + perceptual_weight=1.0, use_actnorm=False, disc_conditional=False, + disc_ndf=64, disc_loss="hinge", n_classes=None, perceptual_loss="lpips", + pixel_loss="l1"): + super().__init__() + assert disc_loss in ["hinge", "vanilla"] + assert perceptual_loss in ["lpips", "clips", "dists"] + assert pixel_loss in ["l1", "l2"] + self.codebook_weight = codebook_weight + self.pixel_weight = pixelloss_weight + if perceptual_loss == "lpips": + print(f"{self.__class__.__name__}: Running with LPIPS.") + self.perceptual_loss = LPIPS().eval() + else: + raise ValueError(f"Unknown perceptual loss: >> {perceptual_loss} <<") + self.perceptual_weight = perceptual_weight + + if pixel_loss == "l1": + self.pixel_loss = l1 + else: + self.pixel_loss = l2 + + self.discriminator = NLayerDiscriminator(input_nc=disc_in_channels, + n_layers=disc_num_layers, + use_actnorm=use_actnorm, + ndf=disc_ndf + ).apply(weights_init) + self.discriminator_iter_start = disc_start + if disc_loss == "hinge": + self.disc_loss = hinge_d_loss + elif disc_loss == "vanilla": + self.disc_loss = vanilla_d_loss + else: + raise ValueError(f"Unknown GAN loss '{disc_loss}'.") + print(f"VQLPIPSWithDiscriminator running with {disc_loss} loss.") + self.disc_factor = disc_factor + self.discriminator_weight = disc_weight + self.disc_conditional = disc_conditional + self.n_classes = n_classes + + def calculate_adaptive_weight(self, nll_loss, g_loss, last_layer=None): + if last_layer is not None: + nll_grads = torch.autograd.grad(nll_loss, last_layer, retain_graph=True)[0] + g_grads = torch.autograd.grad(g_loss, last_layer, retain_graph=True)[0] + else: + nll_grads = torch.autograd.grad(nll_loss, self.last_layer[0], retain_graph=True)[0] + g_grads = torch.autograd.grad(g_loss, self.last_layer[0], retain_graph=True)[0] + + d_weight = torch.norm(nll_grads) / (torch.norm(g_grads) + 1e-4) + d_weight = torch.clamp(d_weight, 0.0, 1e4).detach() + d_weight = d_weight * self.discriminator_weight + return d_weight + + def forward(self, codebook_loss, inputs, reconstructions, optimizer_idx, + global_step, last_layer=None, cond=None, split="train", predicted_indices=None): + if not exists(codebook_loss): + codebook_loss = torch.tensor([0.]).to(inputs.device) + #rec_loss = torch.abs(inputs.contiguous() - reconstructions.contiguous()) + rec_loss = self.pixel_loss(inputs.contiguous(), reconstructions.contiguous()) + if self.perceptual_weight > 0: + p_loss = self.perceptual_loss(inputs.contiguous(), reconstructions.contiguous()) + rec_loss = rec_loss + self.perceptual_weight * p_loss + else: + p_loss = torch.tensor([0.0]) + + nll_loss = rec_loss + #nll_loss = torch.sum(nll_loss) / nll_loss.shape[0] + nll_loss = torch.mean(nll_loss) + + # now the GAN part + if optimizer_idx == 0: + # generator update + if cond is None: + assert not self.disc_conditional + logits_fake = self.discriminator(reconstructions.contiguous()) + else: + assert self.disc_conditional + logits_fake = self.discriminator(torch.cat((reconstructions.contiguous(), cond), dim=1)) + g_loss = -torch.mean(logits_fake) + + try: + d_weight = self.calculate_adaptive_weight(nll_loss, g_loss, last_layer=last_layer) + except RuntimeError: + assert not self.training + d_weight = torch.tensor(0.0) + + disc_factor = adopt_weight(self.disc_factor, global_step, threshold=self.discriminator_iter_start) + loss = nll_loss + d_weight * disc_factor * g_loss + self.codebook_weight * codebook_loss.mean() + + log = {"{}/total_loss".format(split): loss.clone().detach().mean(), + "{}/quant_loss".format(split): codebook_loss.detach().mean(), + "{}/nll_loss".format(split): nll_loss.detach().mean(), + "{}/rec_loss".format(split): rec_loss.detach().mean(), + "{}/p_loss".format(split): p_loss.detach().mean(), + "{}/d_weight".format(split): d_weight.detach(), + "{}/disc_factor".format(split): torch.tensor(disc_factor), + "{}/g_loss".format(split): g_loss.detach().mean(), + } + if predicted_indices is not None: + assert self.n_classes is not None + with torch.no_grad(): + perplexity, cluster_usage = measure_perplexity(predicted_indices, self.n_classes) + log[f"{split}/perplexity"] = perplexity + log[f"{split}/cluster_usage"] = cluster_usage + return loss, log + + if optimizer_idx == 1: + # second pass for discriminator update + if cond is None: + logits_real = self.discriminator(inputs.contiguous().detach()) + logits_fake = self.discriminator(reconstructions.contiguous().detach()) + else: + logits_real = self.discriminator(torch.cat((inputs.contiguous().detach(), cond), dim=1)) + logits_fake = self.discriminator(torch.cat((reconstructions.contiguous().detach(), cond), dim=1)) + + disc_factor = adopt_weight(self.disc_factor, global_step, threshold=self.discriminator_iter_start) + d_loss = disc_factor * self.disc_loss(logits_real, logits_fake) + + log = {"{}/disc_loss".format(split): d_loss.clone().detach().mean(), + "{}/logits_real".format(split): logits_real.detach().mean(), + "{}/logits_fake".format(split): logits_fake.detach().mean() + } + return d_loss, log diff --git a/ldm/modules/x_transformer.py b/ldm/modules/x_transformer.py new file mode 100755 index 0000000..5fc15bf --- /dev/null +++ b/ldm/modules/x_transformer.py @@ -0,0 +1,641 @@ +"""shout-out to https://github.com/lucidrains/x-transformers/tree/main/x_transformers""" +import torch +from torch import nn, einsum +import torch.nn.functional as F +from functools import partial +from inspect import isfunction +from collections import namedtuple +from einops import rearrange, repeat, reduce + +# constants + +DEFAULT_DIM_HEAD = 64 + +Intermediates = namedtuple('Intermediates', [ + 'pre_softmax_attn', + 'post_softmax_attn' +]) + +LayerIntermediates = namedtuple('Intermediates', [ + 'hiddens', + 'attn_intermediates' +]) + + +class AbsolutePositionalEmbedding(nn.Module): + def __init__(self, dim, max_seq_len): + super().__init__() + self.emb = nn.Embedding(max_seq_len, dim) + self.init_() + + def init_(self): + nn.init.normal_(self.emb.weight, std=0.02) + + def forward(self, x): + n = torch.arange(x.shape[1], device=x.device) + return self.emb(n)[None, :, :] + + +class FixedPositionalEmbedding(nn.Module): + def __init__(self, dim): + super().__init__() + inv_freq = 1. / (10000 ** (torch.arange(0, dim, 2).float() / dim)) + self.register_buffer('inv_freq', inv_freq) + + def forward(self, x, seq_dim=1, offset=0): + t = torch.arange(x.shape[seq_dim], device=x.device).type_as(self.inv_freq) + offset + sinusoid_inp = torch.einsum('i , j -> i j', t, self.inv_freq) + emb = torch.cat((sinusoid_inp.sin(), sinusoid_inp.cos()), dim=-1) + return emb[None, :, :] + + +# helpers + +def exists(val): + return val is not None + + +def default(val, d): + if exists(val): + return val + return d() if isfunction(d) else d + + +def always(val): + def inner(*args, **kwargs): + return val + return inner + + +def not_equals(val): + def inner(x): + return x != val + return inner + + +def equals(val): + def inner(x): + return x == val + return inner + + +def max_neg_value(tensor): + return -torch.finfo(tensor.dtype).max + + +# keyword argument helpers + +def pick_and_pop(keys, d): + values = list(map(lambda key: d.pop(key), keys)) + return dict(zip(keys, values)) + + +def group_dict_by_key(cond, d): + return_val = [dict(), dict()] + for key in d.keys(): + match = bool(cond(key)) + ind = int(not match) + return_val[ind][key] = d[key] + return (*return_val,) + + +def string_begins_with(prefix, str): + return str.startswith(prefix) + + +def group_by_key_prefix(prefix, d): + return group_dict_by_key(partial(string_begins_with, prefix), d) + + +def groupby_prefix_and_trim(prefix, d): + kwargs_with_prefix, kwargs = group_dict_by_key(partial(string_begins_with, prefix), d) + kwargs_without_prefix = dict(map(lambda x: (x[0][len(prefix):], x[1]), tuple(kwargs_with_prefix.items()))) + return kwargs_without_prefix, kwargs + + +# classes +class Scale(nn.Module): + def __init__(self, value, fn): + super().__init__() + self.value = value + self.fn = fn + + def forward(self, x, **kwargs): + x, *rest = self.fn(x, **kwargs) + return (x * self.value, *rest) + + +class Rezero(nn.Module): + def __init__(self, fn): + super().__init__() + self.fn = fn + self.g = nn.Parameter(torch.zeros(1)) + + def forward(self, x, **kwargs): + x, *rest = self.fn(x, **kwargs) + return (x * self.g, *rest) + + +class ScaleNorm(nn.Module): + def __init__(self, dim, eps=1e-5): + super().__init__() + self.scale = dim ** -0.5 + self.eps = eps + self.g = nn.Parameter(torch.ones(1)) + + def forward(self, x): + norm = torch.norm(x, dim=-1, keepdim=True) * self.scale + return x / norm.clamp(min=self.eps) * self.g + + +class RMSNorm(nn.Module): + def __init__(self, dim, eps=1e-8): + super().__init__() + self.scale = dim ** -0.5 + self.eps = eps + self.g = nn.Parameter(torch.ones(dim)) + + def forward(self, x): + norm = torch.norm(x, dim=-1, keepdim=True) * self.scale + return x / norm.clamp(min=self.eps) * self.g + + +class Residual(nn.Module): + def forward(self, x, residual): + return x + residual + + +class GRUGating(nn.Module): + def __init__(self, dim): + super().__init__() + self.gru = nn.GRUCell(dim, dim) + + def forward(self, x, residual): + gated_output = self.gru( + rearrange(x, 'b n d -> (b n) d'), + rearrange(residual, 'b n d -> (b n) d') + ) + + return gated_output.reshape_as(x) + + +# feedforward + +class GEGLU(nn.Module): + def __init__(self, dim_in, dim_out): + super().__init__() + self.proj = nn.Linear(dim_in, dim_out * 2) + + def forward(self, x): + x, gate = self.proj(x).chunk(2, dim=-1) + return x * F.gelu(gate) + + +class FeedForward(nn.Module): + def __init__(self, dim, dim_out=None, mult=4, glu=False, dropout=0.): + super().__init__() + inner_dim = int(dim * mult) + dim_out = default(dim_out, dim) + project_in = nn.Sequential( + nn.Linear(dim, inner_dim), + nn.GELU() + ) if not glu else GEGLU(dim, inner_dim) + + self.net = nn.Sequential( + project_in, + nn.Dropout(dropout), + nn.Linear(inner_dim, dim_out) + ) + + def forward(self, x): + return self.net(x) + + +# attention. +class Attention(nn.Module): + def __init__( + self, + dim, + dim_head=DEFAULT_DIM_HEAD, + heads=8, + causal=False, + mask=None, + talking_heads=False, + sparse_topk=None, + use_entmax15=False, + num_mem_kv=0, + dropout=0., + on_attn=False + ): + super().__init__() + if use_entmax15: + raise NotImplementedError("Check out entmax activation instead of softmax activation!") + self.scale = dim_head ** -0.5 + self.heads = heads + self.causal = causal + self.mask = mask + + inner_dim = dim_head * heads + + self.to_q = nn.Linear(dim, inner_dim, bias=False) + self.to_k = nn.Linear(dim, inner_dim, bias=False) + self.to_v = nn.Linear(dim, inner_dim, bias=False) + self.dropout = nn.Dropout(dropout) + + # talking heads + self.talking_heads = talking_heads + if talking_heads: + self.pre_softmax_proj = nn.Parameter(torch.randn(heads, heads)) + self.post_softmax_proj = nn.Parameter(torch.randn(heads, heads)) + + # explicit topk sparse attention + self.sparse_topk = sparse_topk + + # entmax + #self.attn_fn = entmax15 if use_entmax15 else F.softmax + self.attn_fn = F.softmax + + # add memory key / values + self.num_mem_kv = num_mem_kv + if num_mem_kv > 0: + self.mem_k = nn.Parameter(torch.randn(heads, num_mem_kv, dim_head)) + self.mem_v = nn.Parameter(torch.randn(heads, num_mem_kv, dim_head)) + + # attention on attention + self.attn_on_attn = on_attn + self.to_out = nn.Sequential(nn.Linear(inner_dim, dim * 2), nn.GLU()) if on_attn else nn.Linear(inner_dim, dim) + + def forward( + self, + x, + context=None, + mask=None, + context_mask=None, + rel_pos=None, + sinusoidal_emb=None, + prev_attn=None, + mem=None + ): + b, n, _, h, talking_heads, device = *x.shape, self.heads, self.talking_heads, x.device + kv_input = default(context, x) + + q_input = x + k_input = kv_input + v_input = kv_input + + if exists(mem): + k_input = torch.cat((mem, k_input), dim=-2) + v_input = torch.cat((mem, v_input), dim=-2) + + if exists(sinusoidal_emb): + # in shortformer, the query would start at a position offset depending on the past cached memory + offset = k_input.shape[-2] - q_input.shape[-2] + q_input = q_input + sinusoidal_emb(q_input, offset=offset) + k_input = k_input + sinusoidal_emb(k_input) + + q = self.to_q(q_input) + k = self.to_k(k_input) + v = self.to_v(v_input) + + q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> b h n d', h=h), (q, k, v)) + + input_mask = None + if any(map(exists, (mask, context_mask))): + q_mask = default(mask, lambda: torch.ones((b, n), device=device).bool()) + k_mask = q_mask if not exists(context) else context_mask + k_mask = default(k_mask, lambda: torch.ones((b, k.shape[-2]), device=device).bool()) + q_mask = rearrange(q_mask, 'b i -> b () i ()') + k_mask = rearrange(k_mask, 'b j -> b () () j') + input_mask = q_mask * k_mask + + if self.num_mem_kv > 0: + mem_k, mem_v = map(lambda t: repeat(t, 'h n d -> b h n d', b=b), (self.mem_k, self.mem_v)) + k = torch.cat((mem_k, k), dim=-2) + v = torch.cat((mem_v, v), dim=-2) + if exists(input_mask): + input_mask = F.pad(input_mask, (self.num_mem_kv, 0), value=True) + + dots = einsum('b h i d, b h j d -> b h i j', q, k) * self.scale + mask_value = max_neg_value(dots) + + if exists(prev_attn): + dots = dots + prev_attn + + pre_softmax_attn = dots + + if talking_heads: + dots = einsum('b h i j, h k -> b k i j', dots, self.pre_softmax_proj).contiguous() + + if exists(rel_pos): + dots = rel_pos(dots) + + if exists(input_mask): + dots.masked_fill_(~input_mask, mask_value) + del input_mask + + if self.causal: + i, j = dots.shape[-2:] + r = torch.arange(i, device=device) + mask = rearrange(r, 'i -> () () i ()') < rearrange(r, 'j -> () () () j') + mask = F.pad(mask, (j - i, 0), value=False) + dots.masked_fill_(mask, mask_value) + del mask + + if exists(self.sparse_topk) and self.sparse_topk < dots.shape[-1]: + top, _ = dots.topk(self.sparse_topk, dim=-1) + vk = top[..., -1].unsqueeze(-1).expand_as(dots) + mask = dots < vk + dots.masked_fill_(mask, mask_value) + del mask + + attn = self.attn_fn(dots, dim=-1) + post_softmax_attn = attn + + attn = self.dropout(attn) + + if talking_heads: + attn = einsum('b h i j, h k -> b k i j', attn, self.post_softmax_proj).contiguous() + + out = einsum('b h i j, b h j d -> b h i d', attn, v) + out = rearrange(out, 'b h n d -> b n (h d)') + + intermediates = Intermediates( + pre_softmax_attn=pre_softmax_attn, + post_softmax_attn=post_softmax_attn + ) + + return self.to_out(out), intermediates + + +class AttentionLayers(nn.Module): + def __init__( + self, + dim, + depth, + heads=8, + causal=False, + cross_attend=False, + only_cross=False, + use_scalenorm=False, + use_rmsnorm=False, + use_rezero=False, + rel_pos_num_buckets=32, + rel_pos_max_distance=128, + position_infused_attn=False, + custom_layers=None, + sandwich_coef=None, + par_ratio=None, + residual_attn=False, + cross_residual_attn=False, + macaron=False, + pre_norm=True, + gate_residual=False, + **kwargs + ): + super().__init__() + ff_kwargs, kwargs = groupby_prefix_and_trim('ff_', kwargs) + attn_kwargs, _ = groupby_prefix_and_trim('attn_', kwargs) + + dim_head = attn_kwargs.get('dim_head', DEFAULT_DIM_HEAD) + + self.dim = dim + self.depth = depth + self.layers = nn.ModuleList([]) + + self.has_pos_emb = position_infused_attn + self.pia_pos_emb = FixedPositionalEmbedding(dim) if position_infused_attn else None + self.rotary_pos_emb = always(None) + + assert rel_pos_num_buckets <= rel_pos_max_distance, 'number of relative position buckets must be less than the relative position max distance' + self.rel_pos = None + + self.pre_norm = pre_norm + + self.residual_attn = residual_attn + self.cross_residual_attn = cross_residual_attn + + norm_class = ScaleNorm if use_scalenorm else nn.LayerNorm + norm_class = RMSNorm if use_rmsnorm else norm_class + norm_fn = partial(norm_class, dim) + + norm_fn = nn.Identity if use_rezero else norm_fn + branch_fn = Rezero if use_rezero else None + + if cross_attend and not only_cross: + default_block = ('a', 'c', 'f') + elif cross_attend and only_cross: + default_block = ('c', 'f') + else: + default_block = ('a', 'f') + + if macaron: + default_block = ('f',) + default_block + + if exists(custom_layers): + layer_types = custom_layers + elif exists(par_ratio): + par_depth = depth * len(default_block) + assert 1 < par_ratio <= par_depth, 'par ratio out of range' + default_block = tuple(filter(not_equals('f'), default_block)) + par_attn = par_depth // par_ratio + depth_cut = par_depth * 2 // 3 # 2 / 3 attention layer cutoff suggested by PAR paper + par_width = (depth_cut + depth_cut // par_attn) // par_attn + assert len(default_block) <= par_width, 'default block is too large for par_ratio' + par_block = default_block + ('f',) * (par_width - len(default_block)) + par_head = par_block * par_attn + layer_types = par_head + ('f',) * (par_depth - len(par_head)) + elif exists(sandwich_coef): + assert sandwich_coef > 0 and sandwich_coef <= depth, 'sandwich coefficient should be less than the depth' + layer_types = ('a',) * sandwich_coef + default_block * (depth - sandwich_coef) + ('f',) * sandwich_coef + else: + layer_types = default_block * depth + + self.layer_types = layer_types + self.num_attn_layers = len(list(filter(equals('a'), layer_types))) + + for layer_type in self.layer_types: + if layer_type == 'a': + layer = Attention(dim, heads=heads, causal=causal, **attn_kwargs) + elif layer_type == 'c': + layer = Attention(dim, heads=heads, **attn_kwargs) + elif layer_type == 'f': + layer = FeedForward(dim, **ff_kwargs) + layer = layer if not macaron else Scale(0.5, layer) + else: + raise Exception(f'invalid layer type {layer_type}') + + if isinstance(layer, Attention) and exists(branch_fn): + layer = branch_fn(layer) + + if gate_residual: + residual_fn = GRUGating(dim) + else: + residual_fn = Residual() + + self.layers.append(nn.ModuleList([ + norm_fn(), + layer, + residual_fn + ])) + + def forward( + self, + x, + context=None, + mask=None, + context_mask=None, + mems=None, + return_hiddens=False + ): + hiddens = [] + intermediates = [] + prev_attn = None + prev_cross_attn = None + + mems = mems.copy() if exists(mems) else [None] * self.num_attn_layers + + for ind, (layer_type, (norm, block, residual_fn)) in enumerate(zip(self.layer_types, self.layers)): + is_last = ind == (len(self.layers) - 1) + + if layer_type == 'a': + hiddens.append(x) + layer_mem = mems.pop(0) + + residual = x + + if self.pre_norm: + x = norm(x) + + if layer_type == 'a': + out, inter = block(x, mask=mask, sinusoidal_emb=self.pia_pos_emb, rel_pos=self.rel_pos, + prev_attn=prev_attn, mem=layer_mem) + elif layer_type == 'c': + out, inter = block(x, context=context, mask=mask, context_mask=context_mask, prev_attn=prev_cross_attn) + elif layer_type == 'f': + out = block(x) + + x = residual_fn(out, residual) + + if layer_type in ('a', 'c'): + intermediates.append(inter) + + if layer_type == 'a' and self.residual_attn: + prev_attn = inter.pre_softmax_attn + elif layer_type == 'c' and self.cross_residual_attn: + prev_cross_attn = inter.pre_softmax_attn + + if not self.pre_norm and not is_last: + x = norm(x) + + if return_hiddens: + intermediates = LayerIntermediates( + hiddens=hiddens, + attn_intermediates=intermediates + ) + + return x, intermediates + + return x + + +class Encoder(AttentionLayers): + def __init__(self, **kwargs): + assert 'causal' not in kwargs, 'cannot set causality on encoder' + super().__init__(causal=False, **kwargs) + + + +class TransformerWrapper(nn.Module): + def __init__( + self, + *, + num_tokens, + max_seq_len, + attn_layers, + emb_dim=None, + max_mem_len=0., + emb_dropout=0., + num_memory_tokens=None, + tie_embedding=False, + use_pos_emb=True + ): + super().__init__() + assert isinstance(attn_layers, AttentionLayers), 'attention layers must be one of Encoder or Decoder' + + dim = attn_layers.dim + emb_dim = default(emb_dim, dim) + + self.max_seq_len = max_seq_len + self.max_mem_len = max_mem_len + self.num_tokens = num_tokens + + self.token_emb = nn.Embedding(num_tokens, emb_dim) + self.pos_emb = AbsolutePositionalEmbedding(emb_dim, max_seq_len) if ( + use_pos_emb and not attn_layers.has_pos_emb) else always(0) + self.emb_dropout = nn.Dropout(emb_dropout) + + self.project_emb = nn.Linear(emb_dim, dim) if emb_dim != dim else nn.Identity() + self.attn_layers = attn_layers + self.norm = nn.LayerNorm(dim) + + self.init_() + + self.to_logits = nn.Linear(dim, num_tokens) if not tie_embedding else lambda t: t @ self.token_emb.weight.t() + + # memory tokens (like [cls]) from Memory Transformers paper + num_memory_tokens = default(num_memory_tokens, 0) + self.num_memory_tokens = num_memory_tokens + if num_memory_tokens > 0: + self.memory_tokens = nn.Parameter(torch.randn(num_memory_tokens, dim)) + + # let funnel encoder know number of memory tokens, if specified + if hasattr(attn_layers, 'num_memory_tokens'): + attn_layers.num_memory_tokens = num_memory_tokens + + def init_(self): + nn.init.normal_(self.token_emb.weight, std=0.02) + + def forward( + self, + x, + return_embeddings=False, + mask=None, + return_mems=False, + return_attn=False, + mems=None, + **kwargs + ): + b, n, device, num_mem = *x.shape, x.device, self.num_memory_tokens + x = self.token_emb(x) + x += self.pos_emb(x) + x = self.emb_dropout(x) + + x = self.project_emb(x) + + if num_mem > 0: + mem = repeat(self.memory_tokens, 'n d -> b n d', b=b) + x = torch.cat((mem, x), dim=1) + + # auto-handle masking after appending memory tokens + if exists(mask): + mask = F.pad(mask, (num_mem, 0), value=True) + + x, intermediates = self.attn_layers(x, mask=mask, mems=mems, return_hiddens=True, **kwargs) + x = self.norm(x) + + mem, x = x[:, :num_mem], x[:, num_mem:] + + out = self.to_logits(x) if not return_embeddings else x + + if return_mems: + hiddens = intermediates.hiddens + new_mems = list(map(lambda pair: torch.cat(pair, dim=-2), zip(mems, hiddens))) if exists(mems) else hiddens + new_mems = list(map(lambda t: t[..., -self.max_mem_len:, :].detach(), new_mems)) + return out, new_mems + + if return_attn: + attn_maps = list(map(lambda t: t.post_softmax_attn, intermediates.attn_intermediates)) + return out, attn_maps + + return out + diff --git a/ldm/thirdp/psp/helpers.py b/ldm/thirdp/psp/helpers.py new file mode 100755 index 0000000..983baaa --- /dev/null +++ b/ldm/thirdp/psp/helpers.py @@ -0,0 +1,121 @@ +# https://github.com/eladrich/pixel2style2pixel + +from collections import namedtuple +import torch +from torch.nn import Conv2d, BatchNorm2d, PReLU, ReLU, Sigmoid, MaxPool2d, AdaptiveAvgPool2d, Sequential, Module + +""" +ArcFace implementation from [TreB1eN](https://github.com/TreB1eN/InsightFace_Pytorch) +""" + + +class Flatten(Module): + def forward(self, input): + return input.view(input.size(0), -1) + + +def l2_norm(input, axis=1): + norm = torch.norm(input, 2, axis, True) + output = torch.div(input, norm) + return output + + +class Bottleneck(namedtuple('Block', ['in_channel', 'depth', 'stride'])): + """ A named tuple describing a ResNet block. """ + + +def get_block(in_channel, depth, num_units, stride=2): + return [Bottleneck(in_channel, depth, stride)] + [Bottleneck(depth, depth, 1) for i in range(num_units - 1)] + + +def get_blocks(num_layers): + if num_layers == 50: + blocks = [ + get_block(in_channel=64, depth=64, num_units=3), + get_block(in_channel=64, depth=128, num_units=4), + get_block(in_channel=128, depth=256, num_units=14), + get_block(in_channel=256, depth=512, num_units=3) + ] + elif num_layers == 100: + blocks = [ + get_block(in_channel=64, depth=64, num_units=3), + get_block(in_channel=64, depth=128, num_units=13), + get_block(in_channel=128, depth=256, num_units=30), + get_block(in_channel=256, depth=512, num_units=3) + ] + elif num_layers == 152: + blocks = [ + get_block(in_channel=64, depth=64, num_units=3), + get_block(in_channel=64, depth=128, num_units=8), + get_block(in_channel=128, depth=256, num_units=36), + get_block(in_channel=256, depth=512, num_units=3) + ] + else: + raise ValueError("Invalid number of layers: {}. Must be one of [50, 100, 152]".format(num_layers)) + return blocks + + +class SEModule(Module): + def __init__(self, channels, reduction): + super(SEModule, self).__init__() + self.avg_pool = AdaptiveAvgPool2d(1) + self.fc1 = Conv2d(channels, channels // reduction, kernel_size=1, padding=0, bias=False) + self.relu = ReLU(inplace=True) + self.fc2 = Conv2d(channels // reduction, channels, kernel_size=1, padding=0, bias=False) + self.sigmoid = Sigmoid() + + def forward(self, x): + module_input = x + x = self.avg_pool(x) + x = self.fc1(x) + x = self.relu(x) + x = self.fc2(x) + x = self.sigmoid(x) + return module_input * x + + +class bottleneck_IR(Module): + def __init__(self, in_channel, depth, stride): + super(bottleneck_IR, self).__init__() + if in_channel == depth: + self.shortcut_layer = MaxPool2d(1, stride) + else: + self.shortcut_layer = Sequential( + Conv2d(in_channel, depth, (1, 1), stride, bias=False), + BatchNorm2d(depth) + ) + self.res_layer = Sequential( + BatchNorm2d(in_channel), + Conv2d(in_channel, depth, (3, 3), (1, 1), 1, bias=False), PReLU(depth), + Conv2d(depth, depth, (3, 3), stride, 1, bias=False), BatchNorm2d(depth) + ) + + def forward(self, x): + shortcut = self.shortcut_layer(x) + res = self.res_layer(x) + return res + shortcut + + +class bottleneck_IR_SE(Module): + def __init__(self, in_channel, depth, stride): + super(bottleneck_IR_SE, self).__init__() + if in_channel == depth: + self.shortcut_layer = MaxPool2d(1, stride) + else: + self.shortcut_layer = Sequential( + Conv2d(in_channel, depth, (1, 1), stride, bias=False), + BatchNorm2d(depth) + ) + self.res_layer = Sequential( + BatchNorm2d(in_channel), + Conv2d(in_channel, depth, (3, 3), (1, 1), 1, bias=False), + PReLU(depth), + Conv2d(depth, depth, (3, 3), stride, 1, bias=False), + BatchNorm2d(depth), + SEModule(depth, 16) + ) + + def forward(self, x): + shortcut = self.shortcut_layer(x) + res = self.res_layer(x) + return res + shortcut \ No newline at end of file diff --git a/ldm/thirdp/psp/id_loss.py b/ldm/thirdp/psp/id_loss.py new file mode 100755 index 0000000..e08ee09 --- /dev/null +++ b/ldm/thirdp/psp/id_loss.py @@ -0,0 +1,23 @@ +# https://github.com/eladrich/pixel2style2pixel +import torch +from torch import nn +from ldm.thirdp.psp.model_irse import Backbone + + +class IDFeatures(nn.Module): + def __init__(self, model_path): + super(IDFeatures, self).__init__() + print('Loading ResNet ArcFace') + self.facenet = Backbone(input_size=112, num_layers=50, drop_ratio=0.6, mode='ir_se') + self.facenet.load_state_dict(torch.load(model_path, map_location="cpu")) + self.face_pool = torch.nn.AdaptiveAvgPool2d((112, 112)) + self.facenet.eval() + + def forward(self, x, crop=False): + # Not sure of the image range here + if crop: + x = torch.nn.functional.interpolate(x, (256, 256), mode="area") + x = x[:, :, 35:223, 32:220] + x = self.face_pool(x) + x_feats = self.facenet(x) + return x_feats diff --git a/ldm/thirdp/psp/model_irse.py b/ldm/thirdp/psp/model_irse.py new file mode 100755 index 0000000..21cedd2 --- /dev/null +++ b/ldm/thirdp/psp/model_irse.py @@ -0,0 +1,86 @@ +# https://github.com/eladrich/pixel2style2pixel + +from torch.nn import Linear, Conv2d, BatchNorm1d, BatchNorm2d, PReLU, Dropout, Sequential, Module +from ldm.thirdp.psp.helpers import get_blocks, Flatten, bottleneck_IR, bottleneck_IR_SE, l2_norm + +""" +Modified Backbone implementation from [TreB1eN](https://github.com/TreB1eN/InsightFace_Pytorch) +""" + + +class Backbone(Module): + def __init__(self, input_size, num_layers, mode='ir', drop_ratio=0.4, affine=True): + super(Backbone, self).__init__() + assert input_size in [112, 224], "input_size should be 112 or 224" + assert num_layers in [50, 100, 152], "num_layers should be 50, 100 or 152" + assert mode in ['ir', 'ir_se'], "mode should be ir or ir_se" + blocks = get_blocks(num_layers) + if mode == 'ir': + unit_module = bottleneck_IR + elif mode == 'ir_se': + unit_module = bottleneck_IR_SE + self.input_layer = Sequential(Conv2d(3, 64, (3, 3), 1, 1, bias=False), + BatchNorm2d(64), + PReLU(64)) + if input_size == 112: + self.output_layer = Sequential(BatchNorm2d(512), + Dropout(drop_ratio), + Flatten(), + Linear(512 * 7 * 7, 512), + BatchNorm1d(512, affine=affine)) + else: + self.output_layer = Sequential(BatchNorm2d(512), + Dropout(drop_ratio), + Flatten(), + Linear(512 * 14 * 14, 512), + BatchNorm1d(512, affine=affine)) + + modules = [] + for block in blocks: + for bottleneck in block: + modules.append(unit_module(bottleneck.in_channel, + bottleneck.depth, + bottleneck.stride)) + self.body = Sequential(*modules) + + def forward(self, x): + x = self.input_layer(x) + x = self.body(x) + x = self.output_layer(x) + return l2_norm(x) + + +def IR_50(input_size): + """Constructs a ir-50 model.""" + model = Backbone(input_size, num_layers=50, mode='ir', drop_ratio=0.4, affine=False) + return model + + +def IR_101(input_size): + """Constructs a ir-101 model.""" + model = Backbone(input_size, num_layers=100, mode='ir', drop_ratio=0.4, affine=False) + return model + + +def IR_152(input_size): + """Constructs a ir-152 model.""" + model = Backbone(input_size, num_layers=152, mode='ir', drop_ratio=0.4, affine=False) + return model + + +def IR_SE_50(input_size): + """Constructs a ir_se-50 model.""" + model = Backbone(input_size, num_layers=50, mode='ir_se', drop_ratio=0.4, affine=False) + return model + + +def IR_SE_101(input_size): + """Constructs a ir_se-101 model.""" + model = Backbone(input_size, num_layers=100, mode='ir_se', drop_ratio=0.4, affine=False) + return model + + +def IR_SE_152(input_size): + """Constructs a ir_se-152 model.""" + model = Backbone(input_size, num_layers=152, mode='ir_se', drop_ratio=0.4, affine=False) + return model \ No newline at end of file diff --git a/ldm/util.py b/ldm/util.py new file mode 100755 index 0000000..7dcad70 --- /dev/null +++ b/ldm/util.py @@ -0,0 +1,227 @@ +import importlib + +import torchvision +import torch +from torch import optim +import numpy as np + +from inspect import isfunction +from PIL import Image, ImageDraw, ImageFont + +import os +import numpy as np +import matplotlib.pyplot as plt +from PIL import Image +import torch +import time +import cv2 + +import PIL + +def pil_rectangle_crop(im): + width, height = im.size # Get dimensions + + if width <= height: + left = 0 + right = width + top = (height - width)/2 + bottom = (height + width)/2 + else: + + top = 0 + bottom = height + left = (width - height) / 2 + bottom = (width + height) / 2 + + # Crop the center of the image + im = im.crop((left, top, right, bottom)) + return im + + +def log_txt_as_img(wh, xc, size=10): + # wh a tuple of (width, height) + # xc a list of captions to plot + b = len(xc) + txts = list() + for bi in range(b): + txt = Image.new("RGB", wh, color="white") + draw = ImageDraw.Draw(txt) + font = ImageFont.truetype('data/DejaVuSans.ttf', size=size) + nc = int(40 * (wh[0] / 256)) + lines = "\n".join(xc[bi][start:start + nc] for start in range(0, len(xc[bi]), nc)) + + try: + draw.text((0, 0), lines, fill="black", font=font) + except UnicodeEncodeError: + print("Cant encode string for logging. Skipping.") + + txt = np.array(txt).transpose(2, 0, 1) / 127.5 - 1.0 + txts.append(txt) + txts = np.stack(txts) + txts = torch.tensor(txts) + return txts + + +def ismap(x): + if not isinstance(x, torch.Tensor): + return False + return (len(x.shape) == 4) and (x.shape[1] > 3) + + +def isimage(x): + if not isinstance(x,torch.Tensor): + return False + return (len(x.shape) == 4) and (x.shape[1] == 3 or x.shape[1] == 1) + + +def exists(x): + return x is not None + + +def default(val, d): + if exists(val): + return val + return d() if isfunction(d) else d + + +def mean_flat(tensor): + """ + https://github.com/openai/guided-diffusion/blob/27c20a8fab9cb472df5d6bdd6c8d11c8f430b924/guided_diffusion/nn.py#L86 + Take the mean over all non-batch dimensions. + """ + return tensor.mean(dim=list(range(1, len(tensor.shape)))) + + +def count_params(model, verbose=False): + total_params = sum(p.numel() for p in model.parameters()) + if verbose: + print(f"{model.__class__.__name__} has {total_params*1.e-6:.2f} M params.") + return total_params + + +def instantiate_from_config(config): + if not "target" in config: + if config == '__is_first_stage__': + return None + elif config == "__is_unconditional__": + return None + raise KeyError("Expected key `target` to instantiate.") + return get_obj_from_str(config["target"])(**config.get("params", dict())) + + +def get_obj_from_str(string, reload=False): + module, cls = string.rsplit(".", 1) + if reload: + module_imp = importlib.import_module(module) + importlib.reload(module_imp) + return getattr(importlib.import_module(module, package=None), cls) + + +class AdamWwithEMAandWings(optim.Optimizer): + # credit to https://gist.github.com/crowsonkb/65f7265353f403714fce3b2595e0b298 + def __init__(self, params, lr=1.e-3, betas=(0.9, 0.999), eps=1.e-8, # TODO: check hyperparameters before using + weight_decay=1.e-2, amsgrad=False, ema_decay=0.9999, # ema decay to match previous code + ema_power=1., param_names=()): + """AdamW that saves EMA versions of the parameters.""" + if not 0.0 <= lr: + raise ValueError("Invalid learning rate: {}".format(lr)) + if not 0.0 <= eps: + raise ValueError("Invalid epsilon value: {}".format(eps)) + if not 0.0 <= betas[0] < 1.0: + raise ValueError("Invalid beta parameter at index 0: {}".format(betas[0])) + if not 0.0 <= betas[1] < 1.0: + raise ValueError("Invalid beta parameter at index 1: {}".format(betas[1])) + if not 0.0 <= weight_decay: + raise ValueError("Invalid weight_decay value: {}".format(weight_decay)) + if not 0.0 <= ema_decay <= 1.0: + raise ValueError("Invalid ema_decay value: {}".format(ema_decay)) + defaults = dict(lr=lr, betas=betas, eps=eps, + weight_decay=weight_decay, amsgrad=amsgrad, ema_decay=ema_decay, + ema_power=ema_power, param_names=param_names) + super().__init__(params, defaults) + + def __setstate__(self, state): + super().__setstate__(state) + for group in self.param_groups: + group.setdefault('amsgrad', False) + + @torch.no_grad() + def step(self, closure=None): + """Performs a single optimization step. + Args: + closure (callable, optional): A closure that reevaluates the model + and returns the loss. + """ + loss = None + if closure is not None: + with torch.enable_grad(): + loss = closure() + + for group in self.param_groups: + params_with_grad = [] + grads = [] + exp_avgs = [] + exp_avg_sqs = [] + ema_params_with_grad = [] + state_sums = [] + max_exp_avg_sqs = [] + state_steps = [] + amsgrad = group['amsgrad'] + beta1, beta2 = group['betas'] + ema_decay = group['ema_decay'] + ema_power = group['ema_power'] + + for p in group['params']: + if p.grad is None: + continue + params_with_grad.append(p) + if p.grad.is_sparse: + raise RuntimeError('AdamW does not support sparse gradients') + grads.append(p.grad) + + state = self.state[p] + + # State initialization + if len(state) == 0: + state['step'] = 0 + # Exponential moving average of gradient values + state['exp_avg'] = torch.zeros_like(p, memory_format=torch.preserve_format) + # Exponential moving average of squared gradient values + state['exp_avg_sq'] = torch.zeros_like(p, memory_format=torch.preserve_format) + if amsgrad: + # Maintains max of all exp. moving avg. of sq. grad. values + state['max_exp_avg_sq'] = torch.zeros_like(p, memory_format=torch.preserve_format) + # Exponential moving average of parameter values + state['param_exp_avg'] = p.detach().float().clone() + + exp_avgs.append(state['exp_avg']) + exp_avg_sqs.append(state['exp_avg_sq']) + ema_params_with_grad.append(state['param_exp_avg']) + + if amsgrad: + max_exp_avg_sqs.append(state['max_exp_avg_sq']) + + # update the steps for each param group update + state['step'] += 1 + # record the step after step update + state_steps.append(state['step']) + + optim._functional.adamw(params_with_grad, + grads, + exp_avgs, + exp_avg_sqs, + max_exp_avg_sqs, + state_steps, + amsgrad=amsgrad, + beta1=beta1, + beta2=beta2, + lr=group['lr'], + weight_decay=group['weight_decay'], + eps=group['eps'], + maximize=False) + + cur_ema_decay = min(ema_decay, 1 - state['step'] ** -ema_power) + for param, ema_param in zip(params_with_grad, ema_params_with_grad): + ema_param.mul_(cur_ema_decay).add_(param.float(), alpha=1 - cur_ema_decay) + + return loss \ No newline at end of file diff --git a/main.py b/main.py new file mode 100644 index 0000000..4e60676 --- /dev/null +++ b/main.py @@ -0,0 +1,630 @@ +import torch +import argparse +import sys +import os +import pandas as pd + +from nerf.provider import NeRFDataset, generate_grid_points +from nerf.utils import * + +import yaml +from easydict import EasyDict as edict +import dnnultis +import logging + +logger = logging.getLogger(__name__) + +# The first arg parser parses out only the --config argument, this argument is used to +# load a yaml file containing key-values that override the defaults for the main parser below +config_parser = parser = argparse.ArgumentParser( + description='Training Config', add_help=False) +parser.add_argument('-c', '--config', default='', type=str, metavar='FILE', + help='YAML config file specifying default arguments') +parser = argparse.ArgumentParser(description='3D AIGC Training') +parser.add_argument('--workspace', type=str, default='', help='path to log') +parser.add_argument('--text', default=None, help="text prompt") +parser.add_argument('--negative', default='', type=str, + help="negative text prompt") +parser.add_argument('--dir_texts_neg', action='store_true', + help="enable negative directional text") +parser.add_argument('--check_prompt', action='store_true', help="check prompt") +parser.add_argument('-O', action='store_true', help="equals --fp16 --cuda_ray") +parser.add_argument('-O2', action='store_true', + help="equals --backbone vanilla") +parser.add_argument('--test', action='store_true', help="test mode") +parser.add_argument('--six_views', action='store_true', + help="six_views mode: save the images of the six views") +parser.add_argument('--eval_interval', type=int, default=1, + help="evaluate on the valid set every interval epochs") +parser.add_argument('--test_interval', type=int, default=50, + help="test on the test set every interval epochs") +parser.add_argument('--seed', type=int, default=101) +parser.add_argument('--log_every', type=int, default=20, + help="log losses every X iterations") +parser.add_argument('--use_wandb', action='store_true', + help="log online into wandb") + +# guidance +parser.add_argument('--guidance', type=str, nargs='*', + default=['SD'], help='guidance model') +parser.add_argument('--guidance_scale', type=float, nargs='*', default=[100], + help="diffusion model classifier-free guidance scale") +parser.add_argument('--gudiance_spatial_weighting', + action='store_true', help="add spatial weighting to guidance") +parser.add_argument('--save_train_every', type=int, + default=-1, help="save sds guidance") + +# clip guidance +# lambda_clip, set to 1 if use clip loss outside sds +parser.add_argument('--lambda_clip', type=float, default=0, + help="loss scale for clip loss outside sds") +# set to 100 if use clip guidance in sds +parser.add_argument('--clip_version', type=str, + default='large', help="clip version, large is ued in stable diffusion") +parser.add_argument('--clip_guidance', type=float, default=0, + help="diffusion model classifier-free guidance scale") +parser.add_argument('--clip_t', type=float, default=0.4, + help="time step thresh started to use clip") +parser.add_argument('--clip_iterative', action='store_true', + help="use clipd iteratively with sds") +parser.add_argument('--clip_image_loss', action='store_true', + help="use image as reference in clip") +parser.add_argument('--save_guidance_every', type=int, + default=-1, help="save sds guidance") + +# 3D prior: Shap-E. Does not work. +parser.add_argument('--use_shape', action='store_true', + help="enable shap-e initization") +parser.add_argument('--shape_guidance', type=float, default=3, + help="guidance scaling for shap-e prior") +parser.add_argument('--shape_radius', type=float, default=4, + help="camera raidus for shap-e prior") +parser.add_argument('--shape_fovy', type=float, default=40, + help="fov for shap-e prior") +parser.add_argument('--shape_no_color', action='store_false', + dest='shape_init_color', help="do not use shap-E color for initization") +parser.add_argument('--shape_rpst', type=str, default='sdf', + help="use sdf to init NeRF/mesh by default") + +# image options. +parser.add_argument('--image', default=None, help="image prompt") +parser.add_argument('--image_config', default=None, help="image config csv") +parser.add_argument('--learned_embeds_path', type=str, + default=None, help="path to learned embeds of the given image") +parser.add_argument('--known_iters', type=int, default=100, + help="loss scale for alpha entropy") +parser.add_argument('--known_view_interval', type=int, default=4, + help="do reconstruction every X iterations to save on compute") +parser.add_argument('--bg_color_known', type=str, + default=None, help='pixelnoise, noise, None') # pixelnoise +parser.add_argument('--known_shading', type=str, default='lambertian') + +# DMTet and Mesh options +parser.add_argument('--save_mesh', action='store_true', + help="export an obj mesh with texture") +parser.add_argument('--mcubes_resolution', type=int, default=256, + help="mcubes resolution for extracting mesh") +parser.add_argument('--decimate_target', type=int, default=5e4, + help="target face number for mesh decimation") +parser.add_argument('--dmtet', action='store_true', + help="use dmtet finetuning") +parser.add_argument('--tet_mlp', action='store_true', + help="use tet_mlp finetuning") +parser.add_argument('--base_mesh', default=None, + help="base mesh for dmtet init") +parser.add_argument('--tet_grid_size', type=int, + default=256, help="tet grid size") +parser.add_argument('--init_ckpt', type=str, default='', + help="ckpt to init dmtet") +parser.add_argument('--lock_geo', action='store_true', + help="disable dmtet to learn geometry") + +# training options +parser.add_argument('--iters', type=int, default=5000, help="training iters") +parser.add_argument('--lr', type=float, default=1e-3, help="max learning rate") +parser.add_argument('--lr_scale_nerf', type=float, + default=1, help="max learning rate") +parser.add_argument('--lr_scale_texture', type=float, + default=1, help="max learning rate") +parser.add_argument('--ckpt', type=str, default='latest') +parser.add_argument('--cuda_ray', action='store_true', + help="use CUDA raymarching instead of pytorch") +parser.add_argument('--taichi_ray', action='store_true', + help="use taichi raymarching") +parser.add_argument('--max_steps', type=int, default=1024, + help="max num steps sampled per ray (only valid when using --cuda_ray)") +parser.add_argument('--num_steps', type=int, default=64, + help="num steps sampled per ray (only valid when not using --cuda_ray)") +parser.add_argument('--upsample_steps', type=int, default=32, + help="num steps up-sampled per ray (only valid when not using --cuda_ray)") +parser.add_argument('--update_extra_interval', type=int, default=16, + help="iter interval to update extra status (only valid when using --cuda_ray)") +parser.add_argument('--max_ray_batch', type=int, default=4096, + help="batch size of rays at inference to avoid OOM (only valid when not using --cuda_ray)") +parser.add_argument('--latent_iter_ratio', type=float, default=0.0, + help="training iters that only use latent normal shading") +parser.add_argument('--normal_iter_ratio', type=float, default=0.0, + help="training iters that only use normal shading") +parser.add_argument('--textureless_iter_ratio', type=float, default=0.0, + help="training iters that only use textureless shading") +parser.add_argument('--albedo_iter_ratio', type=float, default=0, + help="training iters that only use albedo shading") +parser.add_argument('--warmup_bg_color', type=str, default=None, + help="bg color [None | pixelnoise | noise | white]") +parser.add_argument('--bg_color', type=str, default=None) +parser.add_argument('--bg_color_test', default='white') +parser.add_argument('--ema_decay', type=float, default=0.95, + help="exponential moving average of model weights") +parser.add_argument('--jitter_pose', action='store_true', + help="add jitters to the randomly sampled camera poses") +parser.add_argument('--jitter_center', type=float, default=0.2, + help="amount of jitter to add to sampled camera pose's center (camera location)") +parser.add_argument('--jitter_target', type=float, default=0.2, + help="amount of jitter to add to sampled camera pose's target (i.e. 'look-at')") +parser.add_argument('--jitter_up', type=float, default=0.02, + help="amount of jitter to add to sampled camera pose's up-axis (i.e. 'camera roll')") +parser.add_argument('--uniform_sphere_rate', type=float, default=0.5, + help="likelihood of sampling camera location uniformly on the sphere surface area") +parser.add_argument('--grad_clip', type=float, default=-1, + help="clip grad of all grad to this limit, negative value disables it") +parser.add_argument('--grad_clip_rgb', type=float, default=-1, + help="clip grad of rgb space grad to this limit, negative value disables it") +parser.add_argument('--grid_levels_mask', type=int, default=8, + help="the number of levels in the feature grid to mask (to disable use 0)") +parser.add_argument('--grid_levels_mask_iters', type=int, default=3000, + help="the number of iterations for feature grid masking (to disable use 0)") + +# model options +parser.add_argument('--bg_radius', type=float, default=1.4, + help="if positive, use a background model at sphere(bg_radius)") +parser.add_argument('--density_activation', type=str, default='exp', + choices=['softplus', 'exp', 'relu'], help="density activation function") +parser.add_argument('--density_thresh', type=float, default=10, + help="threshold for density grid to be occupied") +# add more strength to the center, believe the center is more likely to have objects. +parser.add_argument('--blob_density', type=float, default=10, + help="max (center) density for the density blob") +parser.add_argument('--blob_radius', type=float, default=0.2, + help="control the radius for the density blob") +# network backbone +parser.add_argument('--backbone', type=str, default='grid', + choices=['grid', 'vanilla', 'grid_taichi'], help="nerf backbone") +parser.add_argument('--grid_type', type=str, + default='hashgrid', help="grid type") +parser.add_argument('--hidden_dim_bg', type=int, default=32, + help="channels for background network") +parser.add_argument('--optim', type=str, default='adam', + choices=['adan', 'adam'], help="optimizer") +parser.add_argument('--sd_version', type=str, default='1.5', + choices=['1.5', '2.0', '2.1'], help="stable diffusion version") +parser.add_argument('--hf_key', type=str, default=None, + help="hugging face Stable diffusion model key") +# try this if CUDA OOM +parser.add_argument('--fp16', action='store_true', + help="use float16 for training") +parser.add_argument('--vram_O', action='store_true', + help="optimization for low VRAM usage") +# rendering resolution in training, increase these for better quality / decrease these if CUDA OOM even if --vram_O enabled. +parser.add_argument('--w', type=int, default=128, + help="render width for NeRF in training") +parser.add_argument('--h', type=int, default=128, + help="render height for NeRF in training") +parser.add_argument('--known_view_scale', type=float, default=1.5, + help="multiply --h/w by this for known view rendering") +parser.add_argument('--known_view_noise_scale', type=float, default=1e-3, + help="random camera noise added to rays_o and rays_d") +parser.add_argument('--noise_known_camera_annealing', action='store_true', + help="anneal the noise to zero over the coarse of training") +parser.add_argument('--dmtet_reso_scale', type=float, default=8, + help="multiply --h/w by this for dmtet finetuning") +parser.add_argument('--rm_edge', action='store_true', + help="remove edge (ideally only enale for high resolution cases)") +parser.add_argument('--edge_threshold', type=float, default=0.1, + help="remove edges with value > threshold") +parser.add_argument('--edge_width', type=float, default=5, + help="edge width") +parser.add_argument('--batch_size', type=int, default=1, + help="images to render per batch using NeRF") + +# dataset options +parser.add_argument('--bound', type=float, default=1.0, + help="assume the scene is bounded in box(-bound, bound)") +parser.add_argument('--dt_gamma', type=float, default=0, + help="dt_gamma (>=0) for adaptive ray marching. set to 0 to disable, >0 to accelerate rendering (but usually with worse quality)") +parser.add_argument('--min_near', type=float, default=0.1, + help="minimum near distance for camera") + +parser.add_argument('--radius_range', type=float, nargs='*', + default=[1.8, 1.8], help="training camera radius range") +parser.add_argument('--theta_range', type=float, nargs='*', + default=[45, 135], help="training camera elevation/polar range, 90 is front") +parser.add_argument('--phi_range', type=float, nargs='*', + default=[-180, 180], help="training camera azimuth range") +parser.add_argument('--fovy_range', type=float, nargs='*', + default=[40, 40], help="training camera fovy range") + +parser.add_argument('--default_radius', type=float, default=1.8, + help="radius for the default view") +parser.add_argument('--default_polar', type=float, + default=90, help="polar for the default view") +parser.add_argument('--default_azimuth', type=float, + default=0, help="azimuth for the default view") +parser.add_argument('--default_fovy', type=float, default=40, + help="fovy for the default view") + +parser.add_argument('--progressive_view', action='store_true', + help="progressively expand view sampling range from default to full") +parser.add_argument('--progressive_level', action='store_true', + help="progressively increase gridencoder's max_level") + +parser.add_argument('--angle_overhead', type=float, default=30, + help="[0, angle_overhead] is the overhead region") +parser.add_argument('--angle_front', type=float, default=60, + help="[0, angle_front] is the front region, [180, 180+angle_front] the back region, otherwise the side region.") +parser.add_argument('--t_range', type=float, nargs='*', + default=[0.2, 0.6], help="stable diffusion time steps range") + +# regularizations +parser.add_argument('--lambda_entropy', type=float, default=1e-3, + help="loss scale for alpha entropy, favors 0 or 1") +# Try increasing/decreasing lambda_opacity if your scene is stuffed with floaters/becoming empty. +parser.add_argument('--lambda_opacity', type=float, default=0., + help="loss scale for alpha value, avoid uncessary filling") +# Try increasing/decreasing lambda_orient if you object is foggy/over-smoothed. +parser.add_argument('--lambda_orient', type=float, + default=1e-2, help="loss scale for orientation") +parser.add_argument('--lambda_tv', type=float, default=0, + help="loss scale for total variation of grad") +parser.add_argument('--lambda_wd', type=float, default=0, + help="loss scale for weight decay of grad") +parser.add_argument('--lambda_normal_smooth', type=float, default=0.5, + help="loss scale for first-order 2D normal image smoothness") +parser.add_argument('--lambda_normal_smooth2d', type=float, default=0.5, + help="loss scale for second-order 2D normal image smoothness") +parser.add_argument('--lambda_3d_normal_smooth', type=float, default=0.0, + help="loss scale for second-order 2D normal image smoothness") +parser.add_argument('--lambda_guidance', type=float, nargs='*', + default=[1], help="loss scale for SDS") +parser.add_argument('--lambda_rgb', type=float, + default=5, help="loss scale for RGB") +parser.add_argument('--lambda_mask', type=float, default=0.5, + help="loss scale for mask (alpha)") +parser.add_argument('--lambda_depth', type=float, default=0.01, + help="loss scale for relative depth of the known view") +parser.add_argument('--lambda_normal', type=float, + default=0.0, help="loss scale for normals of the known view") +parser.add_argument('--lambda_depth_mse', type=float, default=0.0, + help="loss scale for depth of the known view") +parser.add_argument('--no_normalize_depth', action='store_false', dest='normalize_depth', help="normalize depth") + +# for DMTet +parser.add_argument('--lambda_mesh_normal', type=float, + default=0.1, help="loss scale for mesh normal smoothness") +parser.add_argument('--lambda_mesh_lap', type=float, + default=0.1, help="loss scale for mesh laplacian") + +# GUI options +parser.add_argument('--gui', action='store_true', help="start a GUI") +parser.add_argument('--W', type=int, default=800, help="GUI width") +parser.add_argument('--H', type=int, default=800, help="GUI height") +parser.add_argument('--radius', type=float, default=1.8, + help="default GUI camera radius from center") +parser.add_argument('--fovy', type=float, default=40, + help="default GUI camera fovy") +parser.add_argument('--light_theta', type=float, default=60, + help="default GUI light direction in [0, 180], corresponding to elevation [90, -90]") +parser.add_argument('--light_phi', type=float, default=0, + help="default GUI light direction in [0, 360), azimuth") +parser.add_argument('--max_spp', type=int, default=1, + help="GUI rendering max sample per pixel") +parser.add_argument('--zero123_config', type=str, + default='./pretrained/zero123/sd-objaverse-finetune-c_concat-256.yaml', help="config file for zero123") +parser.add_argument('--zero123_ckpt', type=str, + default='./pretrained/zero123/105000.ckpt', help="ckpt for zero123") +parser.add_argument('--zero123_grad_scale', type=str, default='angle', + help="whether to scale the gradients based on 'angle' or 'None'") + +parser.add_argument('--dataset_size_train', type=int, default=100, + help="Length of train dataset i.e. # of iterations per epoch") +parser.add_argument('--dataset_size_valid', type=int, default=8, + help="# of frames to render in the turntable video in validation") +parser.add_argument('--dataset_size_test', type=int, default=100, + help="# of frames to render in the turntable video at test time") + + +def _parse_args(): + args_config, remaining = config_parser.parse_known_args() + if args_config.config: + with open(args_config.config, 'r') as f: + cfg = yaml.safe_load(f) + parser.set_defaults(**cfg) + + # The main arg parser parses the rest of the args, the usual + # defaults will have been overridden if config file specified. + args = parser.parse_args(remaining) + + # Cache the args as a text string to save them in the output dir later + args_text = yaml.safe_dump(args.__dict__, default_flow_style=False) + return args, args_text + + +if __name__ == '__main__': + args, args_text = _parse_args() + opt = edict(vars(args)) + + if opt.O: + opt.fp16 = True + opt.cuda_ray = True + + elif opt.O2: + opt.fp16 = True + opt.backbone = 'vanilla' + + opt.images, opt.ref_radii, opt.ref_polars, opt.ref_azimuths, opt.zero123_ws = [], [], [], [], [] + opt.default_zero123_w = 1 + + # parameters for image-conditioned generation + if opt.image is not None or opt.image_config is not None: + if 'zero123' in opt.guidance: + # fix fov as zero123 doesn't support changing fov + opt.fovy_range = [opt.default_fovy, opt.default_fovy] + else: + opt.known_view_interval = 2 + + if 'SD' in opt.guidance: + opt.t_range = [0.2, 0.6] + opt.bg_radius = -1 + + # latent warmup is not needed + opt.latent_iter_ratio = 0 + opt.albedo_iter_ratio = 0 + + if opt.image is not None: + opt.images += [opt.image] + opt.ref_radii += [opt.default_radius] + opt.ref_polars += [opt.default_polar] + opt.ref_azimuths += [opt.default_azimuth] + opt.zero123_ws += [opt.default_zero123_w] + + if opt.image_config is not None: + # for multiview (zero123) + conf = pd.read_csv(opt.image_config, skipinitialspace=True) + opt.images += list(conf.image) + opt.ref_radii += list(conf.radius) + opt.ref_polars += list(conf.polar) + opt.ref_azimuths += list(conf.azimuth) + opt.zero123_ws += list(conf.zero123_weight) + if opt.image is None: + opt.default_radius = opt.ref_radii[0] + opt.default_polar = opt.ref_polars[0] + opt.default_azimuth = opt.ref_azimuths[0] + opt.default_zero123_w = opt.zero123_ws[0] + + # reset to None + if len(opt.images) == 0: + opt.images = None + + # default parameters for finetuning + if opt.dmtet: + opt.h = int(opt.h * opt.dmtet_reso_scale) + opt.w = int(opt.w * opt.dmtet_reso_scale) + opt.known_view_scale = 1 + opt.grid_levels_mask = -1 # disable corse nerf (fine to keep, not necesary) + opt.t_range = [0.02, 0.50] # ref: magic3D + + if opt.images is not None: + opt.lambda_normal = 0 + opt.lambda_depth = 0 + + # assume finetuning + opt.latent_iter_ratio = 0 + opt.textureless_iter_ratio = 0 + opt.albedo_iter_ratio = 0 + opt.normal_iter_ratio = 0 + opt.progressive_view = False + opt.progressive_level = False + + # record full range for progressive view expansion + if opt.progressive_view: + # disable as they disturb progressive view + opt.jitter_pose = False + opt.uniform_sphere_rate = 0 + # back up full range + opt.full_radius_range = opt.radius_range + opt.full_theta_range = opt.theta_range + opt.full_phi_range = opt.phi_range + opt.full_fovy_range = opt.fovy_range + + opt.use_clip = opt.clip_guidance > 0 or opt.lambda_clip > 0 + # Do not support Shap-E for NeRF yet. + opt.use_shape = False if not opt.dmtet else opt.use_shape + + # workspace prepare + setup_workspace(opt) + dnnultis.setup_logging(opt.log_path) + + if opt.seed < 0: + opt.seed = random.randint(0, 10000) + seed_everything(int(opt.seed)) + + if opt.backbone == 'vanilla': + from nerf.network import NeRFNetwork + elif opt.backbone == 'grid': + from nerf.network_grid import NeRFNetwork + elif opt.backbone == 'grid_tcnn': + from nerf.network_grid_tcnn import NeRFNetwork + elif opt.backbone == 'grid_taichi': + opt.cuda_ray = False + opt.taichi_ray = True + import taichi as ti + from nerf.network_grid_taichi import NeRFNetwork + taichi_half2_opt = True + taichi_init_args = {"arch": ti.cuda, "device_memory_GB": 4.0} + if taichi_half2_opt: + taichi_init_args["half2_vectorization"] = True + ti.init(**taichi_init_args) + else: + raise NotImplementedError( + f'--backbone {opt.backbone} is not implemented!') + + device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') + opt.device = device + model = NeRFNetwork(opt).to(device) + + if opt.init_ckpt != '': + if not os.path.exists(opt.init_ckpt): + logger.warning(f'ckpt {opt.init_ckpt} is not found') + else: + # load pretrained weights to init dmtet + state_dict = torch.load(opt.init_ckpt, map_location=device) + model.load_state_dict(state_dict['model'], strict=False) + if opt.cuda_ray: + model.mean_density = state_dict['mean_density'] + logger.info(f'init from {opt.init_ckpt}...') + # if init ckpt is provided, we assume the color network is well learned and do not need base_mesh init + opt.shape_init_color = False + opt.base_mesh = None + + if opt.use_shape and opt.dmtet: + # now only supports shape for dmtet init + from guidance.shape_utils import get_shape_from_image + + opt.points = generate_grid_points( + 128, device=device) if not opt.dmtet else model.dmtet.verts + opt.rpsts, opt.colors = get_shape_from_image( + opt.image.replace('rgba', 'rgb'), + opt.points, + rpst_type=opt.shape_rpst, + get_color=opt.shape_init_color, + shape_guidance=opt.shape_guidance, device=device) + scale = opt.default_radius / opt.shape_radius * \ + np.tan(np.deg2rad(opt.default_fovy / 2)) / \ + np.tan(np.deg2rad(opt.shape_fovy / 2)) + if opt.dmtet: + model.dmtet.reset_tet_scale(scale) + else: + opt.points *= scale + logger.info(f'Got sdf from Shap-E init...') + + logger.info(model) + + if opt.six_views: + guidance = None # no need to load guidance model at test + + trainer = Trainer(' '.join(sys.argv), 'df', opt, model, guidance, device=device, + workspace=opt.workspace, fp16=opt.fp16, use_checkpoint=opt.ckpt) + + test_loader = NeRFDataset( + opt, device=device, type='six_views', H=opt.H, W=opt.W, size=6).dataloader(batch_size=1) + trainer.test(test_loader, write_video=False) + + if opt.save_mesh: + trainer.save_mesh() + + elif opt.test: + guidance = None # no need to load guidance model at test + trainer = Trainer(' '.join(sys.argv), os.path.basename(opt.workspace), opt, model, guidance, + device=device, workspace=opt.workspace, fp16=opt.fp16, use_checkpoint=opt.ckpt) + if opt.gui: + from nerf.gui import NeRFGUI + gui = NeRFGUI(opt, trainer) + gui.render() + + else: + test_loader = NeRFDataset( + opt, device=device, type='test', H=opt.H, W=opt.W, size=opt.dataset_size_test).dataloader() + trainer.test(test_loader) + trainer.test(test_loader, shading='normal') # save normal + if opt.save_mesh: + try: + trainer.save_mesh() + except: + pass + else: + train_loader = NeRFDataset( + opt, device=device, type='train', H=opt.h, W=opt.w, size=opt.dataset_size_train * opt.batch_size).dataloader() + + if opt.optim == 'adan': + from optimizer import Adan + # Adan usually requires a larger LR + + def optimizer(model): return Adan(model.get_params( + 5 * opt.lr), eps=1e-8, weight_decay=2e-5, max_grad_norm=5.0, foreach=False) + else: # adam + def optimizer(model): return torch.optim.Adam( + model.get_params(opt.lr), betas=(0.9, 0.99), eps=1e-15) + + if opt.backbone == 'vanilla': + def scheduler(optimizer): return optim.lr_scheduler.LambdaLR( + optimizer, lambda iter: 0.1 ** min(iter / opt.iters, 1)) + else: + def scheduler(optimizer): return optim.lr_scheduler.LambdaLR( + optimizer, lambda iter: 1) # fixed + + guidance = nn.ModuleDict() + lambda_guidance, guidance_scale = {}, {} + for idx, guidance_type in enumerate(opt.guidance): + lambda_guidance[guidance_type] = opt.lambda_guidance[idx] if idx < len( + opt.lambda_guidance) else opt.lambda_guidance[-1] + guidance_scale[guidance_type] = opt.guidance_scale[idx] if idx < len( + opt.guidance_scale) else opt.guidance_scale[-1] + if 'SD' == guidance_type: + from guidance.sd_utils import StableDiffusion, token_replace + guidance['SD'] = StableDiffusion(device, opt.fp16, opt.vram_O, opt.sd_version, opt.hf_key, opt.t_range, + learned_embeds_path=opt.learned_embeds_path, + use_clip=opt.use_clip, clip_t=opt.clip_t, clip_iterative=opt.clip_iterative, clip_version=opt.clip_version, + ) + if opt.learned_embeds_path is not None and os.path.exists(opt.learned_embeds_path): # add textual inversion tokens to model + opt.text, opt.negative = token_replace( + opt.text, opt.negative, opt.learned_embeds_path) + logger.info( + f'prompt: {opt.text}, negative: {opt.negative}') + if opt.check_prompt: + guidance['SD'].check_prompt(opt) + else: + opt.text = opt.text.replace('', os.path.basename(os.path.dirname(opt.image))) + logger.warning('No learned_embeds_path provided, using the folowing pure text prompt with degraded performance: ' + opt.text) + + if 'IF' == guidance_type: + from guidance.if_utils import IF + guidance['IF'] = IF(device, opt.vram_O, opt.t_range) + + if 'zero123' == guidance_type: + from guidance.zero123_utils import Zero123 + guidance['zero123'] = Zero123(device=device, fp16=opt.fp16, config=opt.zero123_config, + ckpt=opt.zero123_ckpt, vram_O=opt.vram_O, t_range=opt.t_range, opt=opt) + + if 'clip' == guidance_type: + from guidance.clip_utils import CLIP + guidance['clip'] = CLIP(device) + opt.lambda_guidance = lambda_guidance + opt.guidance_scale = guidance_scale + + logger.info(opt) + trainer = Trainer(' '.join(sys.argv), os.path.basename(opt.workspace), opt, model, + guidance, + device=device, workspace=opt.workspace, optimizer=optimizer, + ema_decay=opt.ema_decay, fp16=opt.fp16, lr_scheduler=scheduler, use_checkpoint=opt.ckpt, scheduler_update_every_step=True) + trainer.default_view_data = train_loader._data.get_default_view_data() + + if opt.gui: + from nerf.gui import NeRFGUI + gui = NeRFGUI(opt, trainer, train_loader) + gui.render() + + else: + valid_loader = NeRFDataset( + opt, device=device, type='val', H=opt.H, W=opt.W, size=opt.dataset_size_valid).dataloader() + test_loader = NeRFDataset( + opt, device=device, type='test', H=opt.H, W=opt.W, size=opt.dataset_size_test).dataloader() + max_epoch = np.ceil(opt.iters / len(train_loader)).astype(np.int32) + + trainer.train(train_loader, valid_loader, test_loader, max_epoch) + + trainer.test(test_loader) + trainer.test(test_loader, shading='normal') # save normal + if opt.save_mesh: + try: + trainer.save_mesh() + except: + pass \ No newline at end of file diff --git a/meshutils.py b/meshutils.py new file mode 100644 index 0000000..4d1c53d --- /dev/null +++ b/meshutils.py @@ -0,0 +1,117 @@ +import numpy as np +import pymeshlab as pml + +def poisson_mesh_reconstruction(points, normals=None): + # points/normals: [N, 3] np.ndarray + + import open3d as o3d + + pcd = o3d.geometry.PointCloud() + pcd.points = o3d.utility.Vector3dVector(points) + + # outlier removal + pcd, ind = pcd.remove_statistical_outlier(nb_neighbors=20, std_ratio=10) + + # normals + if normals is None: + pcd.estimate_normals() + else: + pcd.normals = o3d.utility.Vector3dVector(normals[ind]) + + # visualize + o3d.visualization.draw_geometries([pcd], point_show_normal=False) + + mesh, densities = o3d.geometry.TriangleMesh.create_from_point_cloud_poisson(pcd, depth=9) + vertices_to_remove = densities < np.quantile(densities, 0.1) + mesh.remove_vertices_by_mask(vertices_to_remove) + + # visualize + o3d.visualization.draw_geometries([mesh]) + + vertices = np.asarray(mesh.vertices) + triangles = np.asarray(mesh.triangles) + + print(f'[INFO] poisson mesh reconstruction: {points.shape} --> {vertices.shape} / {triangles.shape}') + + return vertices, triangles + + +def decimate_mesh(verts, faces, target, backend='pymeshlab', remesh=False, optimalplacement=True): + # optimalplacement: default is True, but for flat mesh must turn False to prevent spike artifect. + + _ori_vert_shape = verts.shape + _ori_face_shape = faces.shape + + if backend == 'pyfqmr': + import pyfqmr + solver = pyfqmr.Simplify() + solver.setMesh(verts, faces) + solver.simplify_mesh(target_count=target, preserve_border=False, verbose=False) + verts, faces, normals = solver.getMesh() + else: + + m = pml.Mesh(verts, faces) + ms = pml.MeshSet() + ms.add_mesh(m, 'mesh') # will copy! + + # filters + # ms.meshing_decimation_clustering(threshold=pml.Percentage(1)) + ms.meshing_decimation_quadric_edge_collapse(targetfacenum=int(target), optimalplacement=optimalplacement) + + if remesh: + # ms.apply_coord_taubin_smoothing() + ms.meshing_isotropic_explicit_remeshing(iterations=3, targetlen=pml.Percentage(1)) + + # extract mesh + m = ms.current_mesh() + verts = m.vertex_matrix() + faces = m.face_matrix() + + print(f'[INFO] mesh decimation: {_ori_vert_shape} --> {verts.shape}, {_ori_face_shape} --> {faces.shape}') + + return verts, faces + + +def clean_mesh(verts, faces, v_pct=1, min_f=8, min_d=5, repair=True, remesh=True, remesh_size=0.01): + # verts: [N, 3] + # faces: [N, 3] + + _ori_vert_shape = verts.shape + _ori_face_shape = faces.shape + + m = pml.Mesh(verts, faces) + ms = pml.MeshSet() + ms.add_mesh(m, 'mesh') # will copy! + + # filters + ms.meshing_remove_unreferenced_vertices() # verts not refed by any faces + + if v_pct > 0: + ms.meshing_merge_close_vertices(threshold=pml.Percentage(v_pct)) # 1/10000 of bounding box diagonal + + ms.meshing_remove_duplicate_faces() # faces defined by the same verts + ms.meshing_remove_null_faces() # faces with area == 0 + + if min_d > 0: + ms.meshing_remove_connected_component_by_diameter(mincomponentdiag=pml.Percentage(min_d)) + + if min_f > 0: + ms.meshing_remove_connected_component_by_face_number(mincomponentsize=min_f) + + if repair: + # ms.meshing_remove_t_vertices(method=0, threshold=40, repeat=True) + ms.meshing_repair_non_manifold_edges(method=0) + ms.meshing_repair_non_manifold_vertices(vertdispratio=0) + + if remesh: + # ms.apply_coord_taubin_smoothing() + ms.meshing_isotropic_explicit_remeshing(iterations=3, targetlen=pml.AbsoluteValue(remesh_size)) + + # extract mesh + m = ms.current_mesh() + verts = m.vertex_matrix() + faces = m.face_matrix() + + print(f'[INFO] mesh cleaning: {_ori_vert_shape} --> {verts.shape}, {_ori_face_shape} --> {faces.shape}') + + return verts, faces \ No newline at end of file diff --git a/midas/__init__.py b/midas/__init__.py new file mode 100644 index 0000000..07398fb --- /dev/null +++ b/midas/__init__.py @@ -0,0 +1 @@ +from .model_loader import load_model, default_models \ No newline at end of file diff --git a/midas/backbones/beit.py b/midas/backbones/beit.py new file mode 100644 index 0000000..7a24e02 --- /dev/null +++ b/midas/backbones/beit.py @@ -0,0 +1,196 @@ +import timm +import torch +import types + +import numpy as np +import torch.nn.functional as F + +from .utils import forward_adapted_unflatten, make_backbone_default +from timm.models.beit import gen_relative_position_index +from torch.utils.checkpoint import checkpoint +from typing import Optional + + +def forward_beit(pretrained, x): + return forward_adapted_unflatten(pretrained, x, "forward_features") + + +def patch_embed_forward(self, x): + """ + Modification of timm.models.layers.patch_embed.py: PatchEmbed.forward to support arbitrary window sizes. + """ + x = self.proj(x) + if self.flatten: + x = x.flatten(2).transpose(1, 2) + x = self.norm(x) + return x + + +def _get_rel_pos_bias(self, window_size): + """ + Modification of timm.models.beit.py: Attention._get_rel_pos_bias to support arbitrary window sizes. + """ + old_height = 2 * self.window_size[0] - 1 + old_width = 2 * self.window_size[1] - 1 + + new_height = 2 * window_size[0] - 1 + new_width = 2 * window_size[1] - 1 + + old_relative_position_bias_table = self.relative_position_bias_table + + old_num_relative_distance = self.num_relative_distance + new_num_relative_distance = new_height * new_width + 3 + + old_sub_table = old_relative_position_bias_table[:old_num_relative_distance - 3] + + old_sub_table = old_sub_table.reshape(1, old_width, old_height, -1).permute(0, 3, 1, 2) + new_sub_table = F.interpolate(old_sub_table, size=(new_height, new_width), mode="bilinear") + new_sub_table = new_sub_table.permute(0, 2, 3, 1).reshape(new_num_relative_distance - 3, -1) + + new_relative_position_bias_table = torch.cat( + [new_sub_table, old_relative_position_bias_table[old_num_relative_distance - 3:]]) + + key = str(window_size[1]) + "," + str(window_size[0]) + if key not in self.relative_position_indices.keys(): + self.relative_position_indices[key] = gen_relative_position_index(window_size) + + relative_position_bias = new_relative_position_bias_table[ + self.relative_position_indices[key].view(-1)].view( + window_size[0] * window_size[1] + 1, + window_size[0] * window_size[1] + 1, -1) # Wh*Ww,Wh*Ww,nH + relative_position_bias = relative_position_bias.permute(2, 0, 1).contiguous() # nH, Wh*Ww, Wh*Ww + return relative_position_bias.unsqueeze(0) + + +def attention_forward(self, x, resolution, shared_rel_pos_bias: Optional[torch.Tensor] = None): + """ + Modification of timm.models.beit.py: Attention.forward to support arbitrary window sizes. + """ + B, N, C = x.shape + + qkv_bias = torch.cat((self.q_bias, self.k_bias, self.v_bias)) if self.q_bias is not None else None + qkv = F.linear(input=x, weight=self.qkv.weight, bias=qkv_bias) + qkv = qkv.reshape(B, N, 3, self.num_heads, -1).permute(2, 0, 3, 1, 4) + q, k, v = qkv.unbind(0) # make torchscript happy (cannot use tensor as tuple) + + q = q * self.scale + attn = (q @ k.transpose(-2, -1)) + + if self.relative_position_bias_table is not None: + window_size = tuple(np.array(resolution) // 16) + attn = attn + self._get_rel_pos_bias(window_size) + if shared_rel_pos_bias is not None: + attn = attn + shared_rel_pos_bias + + attn = attn.softmax(dim=-1) + attn = self.attn_drop(attn) + + x = (attn @ v).transpose(1, 2).reshape(B, N, -1) + x = self.proj(x) + x = self.proj_drop(x) + return x + + +def block_forward(self, x, resolution, shared_rel_pos_bias: Optional[torch.Tensor] = None): + """ + Modification of timm.models.beit.py: Block.forward to support arbitrary window sizes. + """ + if self.gamma_1 is None: + x = x + self.drop_path(self.attn(self.norm1(x), resolution, shared_rel_pos_bias=shared_rel_pos_bias)) + x = x + self.drop_path(self.mlp(self.norm2(x))) + else: + x = x + self.drop_path(self.gamma_1 * self.attn(self.norm1(x), resolution, + shared_rel_pos_bias=shared_rel_pos_bias)) + x = x + self.drop_path(self.gamma_2 * self.mlp(self.norm2(x))) + return x + + +def beit_forward_features(self, x): + """ + Modification of timm.models.beit.py: Beit.forward_features to support arbitrary window sizes. + """ + resolution = x.shape[2:] + + x = self.patch_embed(x) + x = torch.cat((self.cls_token.expand(x.shape[0], -1, -1), x), dim=1) + if self.pos_embed is not None: + x = x + self.pos_embed + x = self.pos_drop(x) + + rel_pos_bias = self.rel_pos_bias() if self.rel_pos_bias is not None else None + for blk in self.blocks: + if self.grad_checkpointing and not torch.jit.is_scripting(): + x = checkpoint(blk, x, shared_rel_pos_bias=rel_pos_bias) + else: + x = blk(x, resolution, shared_rel_pos_bias=rel_pos_bias) + x = self.norm(x) + return x + + +def _make_beit_backbone( + model, + features=[96, 192, 384, 768], + size=[384, 384], + hooks=[0, 4, 8, 11], + vit_features=768, + use_readout="ignore", + start_index=1, + start_index_readout=1, +): + backbone = make_backbone_default(model, features, size, hooks, vit_features, use_readout, start_index, + start_index_readout) + + backbone.model.patch_embed.forward = types.MethodType(patch_embed_forward, backbone.model.patch_embed) + backbone.model.forward_features = types.MethodType(beit_forward_features, backbone.model) + + for block in backbone.model.blocks: + attn = block.attn + attn._get_rel_pos_bias = types.MethodType(_get_rel_pos_bias, attn) + attn.forward = types.MethodType(attention_forward, attn) + attn.relative_position_indices = {} + + block.forward = types.MethodType(block_forward, block) + + return backbone + + +def _make_pretrained_beitl16_512(pretrained, use_readout="ignore", hooks=None): + model = timm.create_model("beit_large_patch16_512", pretrained=pretrained) + + hooks = [5, 11, 17, 23] if hooks is None else hooks + + features = [256, 512, 1024, 1024] + + return _make_beit_backbone( + model, + features=features, + size=[512, 512], + hooks=hooks, + vit_features=1024, + use_readout=use_readout, + ) + + +def _make_pretrained_beitl16_384(pretrained, use_readout="ignore", hooks=None): + model = timm.create_model("beit_large_patch16_384", pretrained=pretrained) + + hooks = [5, 11, 17, 23] if hooks is None else hooks + return _make_beit_backbone( + model, + features=[256, 512, 1024, 1024], + hooks=hooks, + vit_features=1024, + use_readout=use_readout, + ) + + +def _make_pretrained_beitb16_384(pretrained, use_readout="ignore", hooks=None): + model = timm.create_model("beit_base_patch16_384", pretrained=pretrained) + + hooks = [2, 5, 8, 11] if hooks is None else hooks + return _make_beit_backbone( + model, + features=[96, 192, 384, 768], + hooks=hooks, + use_readout=use_readout, + ) diff --git a/midas/backbones/levit.py b/midas/backbones/levit.py new file mode 100644 index 0000000..6d023a9 --- /dev/null +++ b/midas/backbones/levit.py @@ -0,0 +1,106 @@ +import timm +import torch +import torch.nn as nn +import numpy as np + +from .utils import activations, get_activation, Transpose + + +def forward_levit(pretrained, x): + pretrained.model.forward_features(x) + + layer_1 = pretrained.activations["1"] + layer_2 = pretrained.activations["2"] + layer_3 = pretrained.activations["3"] + + layer_1 = pretrained.act_postprocess1(layer_1) + layer_2 = pretrained.act_postprocess2(layer_2) + layer_3 = pretrained.act_postprocess3(layer_3) + + return layer_1, layer_2, layer_3 + + +def _make_levit_backbone( + model, + hooks=[3, 11, 21], + patch_grid=[14, 14] +): + pretrained = nn.Module() + + pretrained.model = model + pretrained.model.blocks[hooks[0]].register_forward_hook(get_activation("1")) + pretrained.model.blocks[hooks[1]].register_forward_hook(get_activation("2")) + pretrained.model.blocks[hooks[2]].register_forward_hook(get_activation("3")) + + pretrained.activations = activations + + patch_grid_size = np.array(patch_grid, dtype=int) + + pretrained.act_postprocess1 = nn.Sequential( + Transpose(1, 2), + nn.Unflatten(2, torch.Size(patch_grid_size.tolist())) + ) + pretrained.act_postprocess2 = nn.Sequential( + Transpose(1, 2), + nn.Unflatten(2, torch.Size((np.ceil(patch_grid_size / 2).astype(int)).tolist())) + ) + pretrained.act_postprocess3 = nn.Sequential( + Transpose(1, 2), + nn.Unflatten(2, torch.Size((np.ceil(patch_grid_size / 4).astype(int)).tolist())) + ) + + return pretrained + + +class ConvTransposeNorm(nn.Sequential): + """ + Modification of + https://github.com/rwightman/pytorch-image-models/blob/master/timm/models/levit.py: ConvNorm + such that ConvTranspose2d is used instead of Conv2d. + """ + + def __init__( + self, in_chs, out_chs, kernel_size=1, stride=1, pad=0, dilation=1, + groups=1, bn_weight_init=1): + super().__init__() + self.add_module('c', + nn.ConvTranspose2d(in_chs, out_chs, kernel_size, stride, pad, dilation, groups, bias=False)) + self.add_module('bn', nn.BatchNorm2d(out_chs)) + + nn.init.constant_(self.bn.weight, bn_weight_init) + + @torch.no_grad() + def fuse(self): + c, bn = self._modules.values() + w = bn.weight / (bn.running_var + bn.eps) ** 0.5 + w = c.weight * w[:, None, None, None] + b = bn.bias - bn.running_mean * bn.weight / (bn.running_var + bn.eps) ** 0.5 + m = nn.ConvTranspose2d( + w.size(1), w.size(0), w.shape[2:], stride=self.c.stride, + padding=self.c.padding, dilation=self.c.dilation, groups=self.c.groups) + m.weight.data.copy_(w) + m.bias.data.copy_(b) + return m + + +def stem_b4_transpose(in_chs, out_chs, activation): + """ + Modification of + https://github.com/rwightman/pytorch-image-models/blob/master/timm/models/levit.py: stem_b16 + such that ConvTranspose2d is used instead of Conv2d and stem is also reduced to the half. + """ + return nn.Sequential( + ConvTransposeNorm(in_chs, out_chs, 3, 2, 1), + activation(), + ConvTransposeNorm(out_chs, out_chs // 2, 3, 2, 1), + activation()) + + +def _make_pretrained_levit_384(pretrained, hooks=None): + model = timm.create_model("levit_384", pretrained=pretrained) + + hooks = [3, 11, 21] if hooks == None else hooks + return _make_levit_backbone( + model, + hooks=hooks + ) diff --git a/midas/backbones/next_vit.py b/midas/backbones/next_vit.py new file mode 100644 index 0000000..8afdd8b --- /dev/null +++ b/midas/backbones/next_vit.py @@ -0,0 +1,39 @@ +import timm + +import torch.nn as nn + +from pathlib import Path +from .utils import activations, forward_default, get_activation + +from ..external.next_vit.classification.nextvit import * + + +def forward_next_vit(pretrained, x): + return forward_default(pretrained, x, "forward") + + +def _make_next_vit_backbone( + model, + hooks=[2, 6, 36, 39], +): + pretrained = nn.Module() + + pretrained.model = model + pretrained.model.features[hooks[0]].register_forward_hook(get_activation("1")) + pretrained.model.features[hooks[1]].register_forward_hook(get_activation("2")) + pretrained.model.features[hooks[2]].register_forward_hook(get_activation("3")) + pretrained.model.features[hooks[3]].register_forward_hook(get_activation("4")) + + pretrained.activations = activations + + return pretrained + + +def _make_pretrained_next_vit_large_6m(hooks=None): + model = timm.create_model("nextvit_large") + + hooks = [2, 6, 36, 39] if hooks == None else hooks + return _make_next_vit_backbone( + model, + hooks=hooks, + ) diff --git a/midas/backbones/swin.py b/midas/backbones/swin.py new file mode 100644 index 0000000..f8c7136 --- /dev/null +++ b/midas/backbones/swin.py @@ -0,0 +1,13 @@ +import timm + +from .swin_common import _make_swin_backbone + + +def _make_pretrained_swinl12_384(pretrained, hooks=None): + model = timm.create_model("swin_large_patch4_window12_384", pretrained=pretrained) + + hooks = [1, 1, 17, 1] if hooks == None else hooks + return _make_swin_backbone( + model, + hooks=hooks + ) diff --git a/midas/backbones/swin2.py b/midas/backbones/swin2.py new file mode 100644 index 0000000..ce4c8f1 --- /dev/null +++ b/midas/backbones/swin2.py @@ -0,0 +1,34 @@ +import timm + +from .swin_common import _make_swin_backbone + + +def _make_pretrained_swin2l24_384(pretrained, hooks=None): + model = timm.create_model("swinv2_large_window12to24_192to384_22kft1k", pretrained=pretrained) + + hooks = [1, 1, 17, 1] if hooks == None else hooks + return _make_swin_backbone( + model, + hooks=hooks + ) + + +def _make_pretrained_swin2b24_384(pretrained, hooks=None): + model = timm.create_model("swinv2_base_window12to24_192to384_22kft1k", pretrained=pretrained) + + hooks = [1, 1, 17, 1] if hooks == None else hooks + return _make_swin_backbone( + model, + hooks=hooks + ) + + +def _make_pretrained_swin2t16_256(pretrained, hooks=None): + model = timm.create_model("swinv2_tiny_window16_256", pretrained=pretrained) + + hooks = [1, 1, 5, 1] if hooks == None else hooks + return _make_swin_backbone( + model, + hooks=hooks, + patch_grid=[64, 64] + ) diff --git a/midas/backbones/swin_common.py b/midas/backbones/swin_common.py new file mode 100644 index 0000000..94d63d4 --- /dev/null +++ b/midas/backbones/swin_common.py @@ -0,0 +1,52 @@ +import torch + +import torch.nn as nn +import numpy as np + +from .utils import activations, forward_default, get_activation, Transpose + + +def forward_swin(pretrained, x): + return forward_default(pretrained, x) + + +def _make_swin_backbone( + model, + hooks=[1, 1, 17, 1], + patch_grid=[96, 96] +): + pretrained = nn.Module() + + pretrained.model = model + pretrained.model.layers[0].blocks[hooks[0]].register_forward_hook(get_activation("1")) + pretrained.model.layers[1].blocks[hooks[1]].register_forward_hook(get_activation("2")) + pretrained.model.layers[2].blocks[hooks[2]].register_forward_hook(get_activation("3")) + pretrained.model.layers[3].blocks[hooks[3]].register_forward_hook(get_activation("4")) + + pretrained.activations = activations + + if hasattr(model, "patch_grid"): + used_patch_grid = model.patch_grid + else: + used_patch_grid = patch_grid + + patch_grid_size = np.array(used_patch_grid, dtype=int) + + pretrained.act_postprocess1 = nn.Sequential( + Transpose(1, 2), + nn.Unflatten(2, torch.Size(patch_grid_size.tolist())) + ) + pretrained.act_postprocess2 = nn.Sequential( + Transpose(1, 2), + nn.Unflatten(2, torch.Size((patch_grid_size // 2).tolist())) + ) + pretrained.act_postprocess3 = nn.Sequential( + Transpose(1, 2), + nn.Unflatten(2, torch.Size((patch_grid_size // 4).tolist())) + ) + pretrained.act_postprocess4 = nn.Sequential( + Transpose(1, 2), + nn.Unflatten(2, torch.Size((patch_grid_size // 8).tolist())) + ) + + return pretrained diff --git a/midas/backbones/utils.py b/midas/backbones/utils.py new file mode 100644 index 0000000..0558899 --- /dev/null +++ b/midas/backbones/utils.py @@ -0,0 +1,249 @@ +import torch + +import torch.nn as nn + + +class Slice(nn.Module): + def __init__(self, start_index=1): + super(Slice, self).__init__() + self.start_index = start_index + + def forward(self, x): + return x[:, self.start_index:] + + +class AddReadout(nn.Module): + def __init__(self, start_index=1): + super(AddReadout, self).__init__() + self.start_index = start_index + + def forward(self, x): + if self.start_index == 2: + readout = (x[:, 0] + x[:, 1]) / 2 + else: + readout = x[:, 0] + return x[:, self.start_index:] + readout.unsqueeze(1) + + +class ProjectReadout(nn.Module): + def __init__(self, in_features, start_index=1): + super(ProjectReadout, self).__init__() + self.start_index = start_index + + self.project = nn.Sequential(nn.Linear(2 * in_features, in_features), nn.GELU()) + + def forward(self, x): + readout = x[:, 0].unsqueeze(1).expand_as(x[:, self.start_index:]) + features = torch.cat((x[:, self.start_index:], readout), -1) + + return self.project(features) + + +class Transpose(nn.Module): + def __init__(self, dim0, dim1): + super(Transpose, self).__init__() + self.dim0 = dim0 + self.dim1 = dim1 + + def forward(self, x): + x = x.transpose(self.dim0, self.dim1) + return x + + +activations = {} + + +def get_activation(name): + def hook(model, input, output): + activations[name] = output + + return hook + + +def forward_default(pretrained, x, function_name="forward_features"): + exec(f"pretrained.model.{function_name}(x)") + + layer_1 = pretrained.activations["1"] + layer_2 = pretrained.activations["2"] + layer_3 = pretrained.activations["3"] + layer_4 = pretrained.activations["4"] + + if hasattr(pretrained, "act_postprocess1"): + layer_1 = pretrained.act_postprocess1(layer_1) + if hasattr(pretrained, "act_postprocess2"): + layer_2 = pretrained.act_postprocess2(layer_2) + if hasattr(pretrained, "act_postprocess3"): + layer_3 = pretrained.act_postprocess3(layer_3) + if hasattr(pretrained, "act_postprocess4"): + layer_4 = pretrained.act_postprocess4(layer_4) + + return layer_1, layer_2, layer_3, layer_4 + + +def forward_adapted_unflatten(pretrained, x, function_name="forward_features"): + b, c, h, w = x.shape + + exec(f"glob = pretrained.model.{function_name}(x)") + + layer_1 = pretrained.activations["1"] + layer_2 = pretrained.activations["2"] + layer_3 = pretrained.activations["3"] + layer_4 = pretrained.activations["4"] + + layer_1 = pretrained.act_postprocess1[0:2](layer_1) + layer_2 = pretrained.act_postprocess2[0:2](layer_2) + layer_3 = pretrained.act_postprocess3[0:2](layer_3) + layer_4 = pretrained.act_postprocess4[0:2](layer_4) + + unflatten = nn.Sequential( + nn.Unflatten( + 2, + torch.Size( + [ + h // pretrained.model.patch_size[1], + w // pretrained.model.patch_size[0], + ] + ), + ) + ) + + if layer_1.ndim == 3: + layer_1 = unflatten(layer_1) + if layer_2.ndim == 3: + layer_2 = unflatten(layer_2) + if layer_3.ndim == 3: + layer_3 = unflatten(layer_3) + if layer_4.ndim == 3: + layer_4 = unflatten(layer_4) + + layer_1 = pretrained.act_postprocess1[3: len(pretrained.act_postprocess1)](layer_1) + layer_2 = pretrained.act_postprocess2[3: len(pretrained.act_postprocess2)](layer_2) + layer_3 = pretrained.act_postprocess3[3: len(pretrained.act_postprocess3)](layer_3) + layer_4 = pretrained.act_postprocess4[3: len(pretrained.act_postprocess4)](layer_4) + + return layer_1, layer_2, layer_3, layer_4 + + +def get_readout_oper(vit_features, features, use_readout, start_index=1): + if use_readout == "ignore": + readout_oper = [Slice(start_index)] * len(features) + elif use_readout == "add": + readout_oper = [AddReadout(start_index)] * len(features) + elif use_readout == "project": + readout_oper = [ + ProjectReadout(vit_features, start_index) for out_feat in features + ] + else: + assert ( + False + ), "wrong operation for readout token, use_readout can be 'ignore', 'add', or 'project'" + + return readout_oper + + +def make_backbone_default( + model, + features=[96, 192, 384, 768], + size=[384, 384], + hooks=[2, 5, 8, 11], + vit_features=768, + use_readout="ignore", + start_index=1, + start_index_readout=1, +): + pretrained = nn.Module() + + pretrained.model = model + pretrained.model.blocks[hooks[0]].register_forward_hook(get_activation("1")) + pretrained.model.blocks[hooks[1]].register_forward_hook(get_activation("2")) + pretrained.model.blocks[hooks[2]].register_forward_hook(get_activation("3")) + pretrained.model.blocks[hooks[3]].register_forward_hook(get_activation("4")) + + pretrained.activations = activations + + readout_oper = get_readout_oper(vit_features, features, use_readout, start_index_readout) + + # 32, 48, 136, 384 + pretrained.act_postprocess1 = nn.Sequential( + readout_oper[0], + Transpose(1, 2), + nn.Unflatten(2, torch.Size([size[0] // 16, size[1] // 16])), + nn.Conv2d( + in_channels=vit_features, + out_channels=features[0], + kernel_size=1, + stride=1, + padding=0, + ), + nn.ConvTranspose2d( + in_channels=features[0], + out_channels=features[0], + kernel_size=4, + stride=4, + padding=0, + bias=True, + dilation=1, + groups=1, + ), + ) + + pretrained.act_postprocess2 = nn.Sequential( + readout_oper[1], + Transpose(1, 2), + nn.Unflatten(2, torch.Size([size[0] // 16, size[1] // 16])), + nn.Conv2d( + in_channels=vit_features, + out_channels=features[1], + kernel_size=1, + stride=1, + padding=0, + ), + nn.ConvTranspose2d( + in_channels=features[1], + out_channels=features[1], + kernel_size=2, + stride=2, + padding=0, + bias=True, + dilation=1, + groups=1, + ), + ) + + pretrained.act_postprocess3 = nn.Sequential( + readout_oper[2], + Transpose(1, 2), + nn.Unflatten(2, torch.Size([size[0] // 16, size[1] // 16])), + nn.Conv2d( + in_channels=vit_features, + out_channels=features[2], + kernel_size=1, + stride=1, + padding=0, + ), + ) + + pretrained.act_postprocess4 = nn.Sequential( + readout_oper[3], + Transpose(1, 2), + nn.Unflatten(2, torch.Size([size[0] // 16, size[1] // 16])), + nn.Conv2d( + in_channels=vit_features, + out_channels=features[3], + kernel_size=1, + stride=1, + padding=0, + ), + nn.Conv2d( + in_channels=features[3], + out_channels=features[3], + kernel_size=3, + stride=2, + padding=1, + ), + ) + + pretrained.model.start_index = start_index + pretrained.model.patch_size = [16, 16] + + return pretrained diff --git a/midas/backbones/vit.py b/midas/backbones/vit.py new file mode 100644 index 0000000..413f969 --- /dev/null +++ b/midas/backbones/vit.py @@ -0,0 +1,221 @@ +import torch +import torch.nn as nn +import timm +import types +import math +import torch.nn.functional as F + +from .utils import (activations, forward_adapted_unflatten, get_activation, get_readout_oper, + make_backbone_default, Transpose) + + +def forward_vit(pretrained, x): + return forward_adapted_unflatten(pretrained, x, "forward_flex") + + +def _resize_pos_embed(self, posemb, gs_h, gs_w): + posemb_tok, posemb_grid = ( + posemb[:, : self.start_index], + posemb[0, self.start_index:], + ) + + gs_old = int(math.sqrt(len(posemb_grid))) + + posemb_grid = posemb_grid.reshape(1, gs_old, gs_old, -1).permute(0, 3, 1, 2) + posemb_grid = F.interpolate(posemb_grid, size=(gs_h, gs_w), mode="bilinear") + posemb_grid = posemb_grid.permute(0, 2, 3, 1).reshape(1, gs_h * gs_w, -1) + + posemb = torch.cat([posemb_tok, posemb_grid], dim=1) + + return posemb + + +def forward_flex(self, x): + b, c, h, w = x.shape + + pos_embed = self._resize_pos_embed( + self.pos_embed, h // self.patch_size[1], w // self.patch_size[0] + ) + + B = x.shape[0] + + if hasattr(self.patch_embed, "backbone"): + x = self.patch_embed.backbone(x) + if isinstance(x, (list, tuple)): + x = x[-1] # last feature if backbone outputs list/tuple of features + + x = self.patch_embed.proj(x).flatten(2).transpose(1, 2) + + if getattr(self, "dist_token", None) is not None: + cls_tokens = self.cls_token.expand( + B, -1, -1 + ) # stole cls_tokens impl from Phil Wang, thanks + dist_token = self.dist_token.expand(B, -1, -1) + x = torch.cat((cls_tokens, dist_token, x), dim=1) + else: + if self.no_embed_class: + x = x + pos_embed + cls_tokens = self.cls_token.expand( + B, -1, -1 + ) # stole cls_tokens impl from Phil Wang, thanks + x = torch.cat((cls_tokens, x), dim=1) + + if not self.no_embed_class: + x = x + pos_embed + x = self.pos_drop(x) + + for blk in self.blocks: + x = blk(x) + + x = self.norm(x) + + return x + + +def _make_vit_b16_backbone( + model, + features=[96, 192, 384, 768], + size=[384, 384], + hooks=[2, 5, 8, 11], + vit_features=768, + use_readout="ignore", + start_index=1, + start_index_readout=1, +): + pretrained = make_backbone_default(model, features, size, hooks, vit_features, use_readout, start_index, + start_index_readout) + + # We inject this function into the VisionTransformer instances so that + # we can use it with interpolated position embeddings without modifying the library source. + pretrained.model.forward_flex = types.MethodType(forward_flex, pretrained.model) + pretrained.model._resize_pos_embed = types.MethodType( + _resize_pos_embed, pretrained.model + ) + + return pretrained + + +def _make_pretrained_vitl16_384(pretrained, use_readout="ignore", hooks=None): + model = timm.create_model("vit_large_patch16_384", pretrained=pretrained) + + hooks = [5, 11, 17, 23] if hooks == None else hooks + return _make_vit_b16_backbone( + model, + features=[256, 512, 1024, 1024], + hooks=hooks, + vit_features=1024, + use_readout=use_readout, + ) + + +def _make_pretrained_vitb16_384(pretrained, use_readout="ignore", hooks=None): + model = timm.create_model("vit_base_patch16_384", pretrained=pretrained) + + hooks = [2, 5, 8, 11] if hooks == None else hooks + return _make_vit_b16_backbone( + model, features=[96, 192, 384, 768], hooks=hooks, use_readout=use_readout + ) + + +def _make_vit_b_rn50_backbone( + model, + features=[256, 512, 768, 768], + size=[384, 384], + hooks=[0, 1, 8, 11], + vit_features=768, + patch_size=[16, 16], + number_stages=2, + use_vit_only=False, + use_readout="ignore", + start_index=1, +): + pretrained = nn.Module() + + pretrained.model = model + + used_number_stages = 0 if use_vit_only else number_stages + for s in range(used_number_stages): + pretrained.model.patch_embed.backbone.stages[s].register_forward_hook( + get_activation(str(s + 1)) + ) + for s in range(used_number_stages, 4): + pretrained.model.blocks[hooks[s]].register_forward_hook(get_activation(str(s + 1))) + + pretrained.activations = activations + + readout_oper = get_readout_oper(vit_features, features, use_readout, start_index) + + for s in range(used_number_stages): + value = nn.Sequential(nn.Identity(), nn.Identity(), nn.Identity()) + exec(f"pretrained.act_postprocess{s + 1}=value") + for s in range(used_number_stages, 4): + if s < number_stages: + final_layer = nn.ConvTranspose2d( + in_channels=features[s], + out_channels=features[s], + kernel_size=4 // (2 ** s), + stride=4 // (2 ** s), + padding=0, + bias=True, + dilation=1, + groups=1, + ) + elif s > number_stages: + final_layer = nn.Conv2d( + in_channels=features[3], + out_channels=features[3], + kernel_size=3, + stride=2, + padding=1, + ) + else: + final_layer = None + + layers = [ + readout_oper[s], + Transpose(1, 2), + nn.Unflatten(2, torch.Size([size[0] // 16, size[1] // 16])), + nn.Conv2d( + in_channels=vit_features, + out_channels=features[s], + kernel_size=1, + stride=1, + padding=0, + ), + ] + if final_layer is not None: + layers.append(final_layer) + + value = nn.Sequential(*layers) + exec(f"pretrained.act_postprocess{s + 1}=value") + + pretrained.model.start_index = start_index + pretrained.model.patch_size = patch_size + + # We inject this function into the VisionTransformer instances so that + # we can use it with interpolated position embeddings without modifying the library source. + pretrained.model.forward_flex = types.MethodType(forward_flex, pretrained.model) + + # We inject this function into the VisionTransformer instances so that + # we can use it with interpolated position embeddings without modifying the library source. + pretrained.model._resize_pos_embed = types.MethodType( + _resize_pos_embed, pretrained.model + ) + + return pretrained + + +def _make_pretrained_vitb_rn50_384( + pretrained, use_readout="ignore", hooks=None, use_vit_only=False +): + model = timm.create_model("vit_base_resnet50_384", pretrained=pretrained) + + hooks = [0, 1, 8, 11] if hooks == None else hooks + return _make_vit_b_rn50_backbone( + model, + features=[256, 512, 768, 768], + size=[384, 384], + hooks=hooks, + use_vit_only=use_vit_only, + use_readout=use_readout, + ) diff --git a/midas/base_model.py b/midas/base_model.py new file mode 100644 index 0000000..5cf4302 --- /dev/null +++ b/midas/base_model.py @@ -0,0 +1,16 @@ +import torch + + +class BaseModel(torch.nn.Module): + def load(self, path): + """Load model from file. + + Args: + path (str): file path + """ + parameters = torch.load(path, map_location=torch.device('cpu')) + + if "optimizer" in parameters: + parameters = parameters["model"] + + self.load_state_dict(parameters) diff --git a/midas/blocks.py b/midas/blocks.py new file mode 100644 index 0000000..6d87a00 --- /dev/null +++ b/midas/blocks.py @@ -0,0 +1,439 @@ +import torch +import torch.nn as nn + +from .backbones.beit import ( + _make_pretrained_beitl16_512, + _make_pretrained_beitl16_384, + _make_pretrained_beitb16_384, + forward_beit, +) +from .backbones.swin_common import ( + forward_swin, +) +from .backbones.swin2 import ( + _make_pretrained_swin2l24_384, + _make_pretrained_swin2b24_384, + _make_pretrained_swin2t16_256, +) +from .backbones.swin import ( + _make_pretrained_swinl12_384, +) +from .backbones.levit import ( + _make_pretrained_levit_384, + forward_levit, +) +from .backbones.vit import ( + _make_pretrained_vitb_rn50_384, + _make_pretrained_vitl16_384, + _make_pretrained_vitb16_384, + forward_vit, +) + +def _make_encoder(backbone, features, use_pretrained, groups=1, expand=False, exportable=True, hooks=None, + use_vit_only=False, use_readout="ignore", in_features=[96, 256, 512, 1024]): + if backbone == "beitl16_512": + pretrained = _make_pretrained_beitl16_512( + use_pretrained, hooks=hooks, use_readout=use_readout + ) + scratch = _make_scratch( + [256, 512, 1024, 1024], features, groups=groups, expand=expand + ) # BEiT_512-L (backbone) + elif backbone == "beitl16_384": + pretrained = _make_pretrained_beitl16_384( + use_pretrained, hooks=hooks, use_readout=use_readout + ) + scratch = _make_scratch( + [256, 512, 1024, 1024], features, groups=groups, expand=expand + ) # BEiT_384-L (backbone) + elif backbone == "beitb16_384": + pretrained = _make_pretrained_beitb16_384( + use_pretrained, hooks=hooks, use_readout=use_readout + ) + scratch = _make_scratch( + [96, 192, 384, 768], features, groups=groups, expand=expand + ) # BEiT_384-B (backbone) + elif backbone == "swin2l24_384": + pretrained = _make_pretrained_swin2l24_384( + use_pretrained, hooks=hooks + ) + scratch = _make_scratch( + [192, 384, 768, 1536], features, groups=groups, expand=expand + ) # Swin2-L/12to24 (backbone) + elif backbone == "swin2b24_384": + pretrained = _make_pretrained_swin2b24_384( + use_pretrained, hooks=hooks + ) + scratch = _make_scratch( + [128, 256, 512, 1024], features, groups=groups, expand=expand + ) # Swin2-B/12to24 (backbone) + elif backbone == "swin2t16_256": + pretrained = _make_pretrained_swin2t16_256( + use_pretrained, hooks=hooks + ) + scratch = _make_scratch( + [96, 192, 384, 768], features, groups=groups, expand=expand + ) # Swin2-T/16 (backbone) + elif backbone == "swinl12_384": + pretrained = _make_pretrained_swinl12_384( + use_pretrained, hooks=hooks + ) + scratch = _make_scratch( + [192, 384, 768, 1536], features, groups=groups, expand=expand + ) # Swin-L/12 (backbone) + elif backbone == "next_vit_large_6m": + from .backbones.next_vit import _make_pretrained_next_vit_large_6m + pretrained = _make_pretrained_next_vit_large_6m(hooks=hooks) + scratch = _make_scratch( + in_features, features, groups=groups, expand=expand + ) # Next-ViT-L on ImageNet-1K-6M (backbone) + elif backbone == "levit_384": + pretrained = _make_pretrained_levit_384( + use_pretrained, hooks=hooks + ) + scratch = _make_scratch( + [384, 512, 768], features, groups=groups, expand=expand + ) # LeViT 384 (backbone) + elif backbone == "vitl16_384": + pretrained = _make_pretrained_vitl16_384( + use_pretrained, hooks=hooks, use_readout=use_readout + ) + scratch = _make_scratch( + [256, 512, 1024, 1024], features, groups=groups, expand=expand + ) # ViT-L/16 - 85.0% Top1 (backbone) + elif backbone == "vitb_rn50_384": + pretrained = _make_pretrained_vitb_rn50_384( + use_pretrained, + hooks=hooks, + use_vit_only=use_vit_only, + use_readout=use_readout, + ) + scratch = _make_scratch( + [256, 512, 768, 768], features, groups=groups, expand=expand + ) # ViT-H/16 - 85.0% Top1 (backbone) + elif backbone == "vitb16_384": + pretrained = _make_pretrained_vitb16_384( + use_pretrained, hooks=hooks, use_readout=use_readout + ) + scratch = _make_scratch( + [96, 192, 384, 768], features, groups=groups, expand=expand + ) # ViT-B/16 - 84.6% Top1 (backbone) + elif backbone == "resnext101_wsl": + pretrained = _make_pretrained_resnext101_wsl(use_pretrained) + scratch = _make_scratch([256, 512, 1024, 2048], features, groups=groups, expand=expand) # efficientnet_lite3 + elif backbone == "efficientnet_lite3": + pretrained = _make_pretrained_efficientnet_lite3(use_pretrained, exportable=exportable) + scratch = _make_scratch([32, 48, 136, 384], features, groups=groups, expand=expand) # efficientnet_lite3 + else: + print(f"Backbone '{backbone}' not implemented") + assert False + + return pretrained, scratch + + +def _make_scratch(in_shape, out_shape, groups=1, expand=False): + scratch = nn.Module() + + out_shape1 = out_shape + out_shape2 = out_shape + out_shape3 = out_shape + if len(in_shape) >= 4: + out_shape4 = out_shape + + if expand: + out_shape1 = out_shape + out_shape2 = out_shape*2 + out_shape3 = out_shape*4 + if len(in_shape) >= 4: + out_shape4 = out_shape*8 + + scratch.layer1_rn = nn.Conv2d( + in_shape[0], out_shape1, kernel_size=3, stride=1, padding=1, bias=False, groups=groups + ) + scratch.layer2_rn = nn.Conv2d( + in_shape[1], out_shape2, kernel_size=3, stride=1, padding=1, bias=False, groups=groups + ) + scratch.layer3_rn = nn.Conv2d( + in_shape[2], out_shape3, kernel_size=3, stride=1, padding=1, bias=False, groups=groups + ) + if len(in_shape) >= 4: + scratch.layer4_rn = nn.Conv2d( + in_shape[3], out_shape4, kernel_size=3, stride=1, padding=1, bias=False, groups=groups + ) + + return scratch + + +def _make_pretrained_efficientnet_lite3(use_pretrained, exportable=False): + efficientnet = torch.hub.load( + "rwightman/gen-efficientnet-pytorch", + "tf_efficientnet_lite3", + pretrained=use_pretrained, + exportable=exportable + ) + return _make_efficientnet_backbone(efficientnet) + + +def _make_efficientnet_backbone(effnet): + pretrained = nn.Module() + + pretrained.layer1 = nn.Sequential( + effnet.conv_stem, effnet.bn1, effnet.act1, *effnet.blocks[0:2] + ) + pretrained.layer2 = nn.Sequential(*effnet.blocks[2:3]) + pretrained.layer3 = nn.Sequential(*effnet.blocks[3:5]) + pretrained.layer4 = nn.Sequential(*effnet.blocks[5:9]) + + return pretrained + + +def _make_resnet_backbone(resnet): + pretrained = nn.Module() + pretrained.layer1 = nn.Sequential( + resnet.conv1, resnet.bn1, resnet.relu, resnet.maxpool, resnet.layer1 + ) + + pretrained.layer2 = resnet.layer2 + pretrained.layer3 = resnet.layer3 + pretrained.layer4 = resnet.layer4 + + return pretrained + + +def _make_pretrained_resnext101_wsl(use_pretrained): + resnet = torch.hub.load("facebookresearch/WSL-Images", "resnext101_32x8d_wsl") + return _make_resnet_backbone(resnet) + + + +class Interpolate(nn.Module): + """Interpolation module. + """ + + def __init__(self, scale_factor, mode, align_corners=False): + """Init. + + Args: + scale_factor (float): scaling + mode (str): interpolation mode + """ + super(Interpolate, self).__init__() + + self.interp = nn.functional.interpolate + self.scale_factor = scale_factor + self.mode = mode + self.align_corners = align_corners + + def forward(self, x): + """Forward pass. + + Args: + x (tensor): input + + Returns: + tensor: interpolated data + """ + + x = self.interp( + x, scale_factor=self.scale_factor, mode=self.mode, align_corners=self.align_corners + ) + + return x + + +class ResidualConvUnit(nn.Module): + """Residual convolution module. + """ + + def __init__(self, features): + """Init. + + Args: + features (int): number of features + """ + super().__init__() + + self.conv1 = nn.Conv2d( + features, features, kernel_size=3, stride=1, padding=1, bias=True + ) + + self.conv2 = nn.Conv2d( + features, features, kernel_size=3, stride=1, padding=1, bias=True + ) + + self.relu = nn.ReLU(inplace=True) + + def forward(self, x): + """Forward pass. + + Args: + x (tensor): input + + Returns: + tensor: output + """ + out = self.relu(x) + out = self.conv1(out) + out = self.relu(out) + out = self.conv2(out) + + return out + x + + +class FeatureFusionBlock(nn.Module): + """Feature fusion block. + """ + + def __init__(self, features): + """Init. + + Args: + features (int): number of features + """ + super(FeatureFusionBlock, self).__init__() + + self.resConfUnit1 = ResidualConvUnit(features) + self.resConfUnit2 = ResidualConvUnit(features) + + def forward(self, *xs): + """Forward pass. + + Returns: + tensor: output + """ + output = xs[0] + + if len(xs) == 2: + output += self.resConfUnit1(xs[1]) + + output = self.resConfUnit2(output) + + output = nn.functional.interpolate( + output, scale_factor=2, mode="bilinear", align_corners=True + ) + + return output + + + + +class ResidualConvUnit_custom(nn.Module): + """Residual convolution module. + """ + + def __init__(self, features, activation, bn): + """Init. + + Args: + features (int): number of features + """ + super().__init__() + + self.bn = bn + + self.groups=1 + + self.conv1 = nn.Conv2d( + features, features, kernel_size=3, stride=1, padding=1, bias=True, groups=self.groups + ) + + self.conv2 = nn.Conv2d( + features, features, kernel_size=3, stride=1, padding=1, bias=True, groups=self.groups + ) + + if self.bn==True: + self.bn1 = nn.BatchNorm2d(features) + self.bn2 = nn.BatchNorm2d(features) + + self.activation = activation + + self.skip_add = nn.quantized.FloatFunctional() + + def forward(self, x): + """Forward pass. + + Args: + x (tensor): input + + Returns: + tensor: output + """ + + out = self.activation(x) + out = self.conv1(out) + if self.bn==True: + out = self.bn1(out) + + out = self.activation(out) + out = self.conv2(out) + if self.bn==True: + out = self.bn2(out) + + if self.groups > 1: + out = self.conv_merge(out) + + return self.skip_add.add(out, x) + + # return out + x + + +class FeatureFusionBlock_custom(nn.Module): + """Feature fusion block. + """ + + def __init__(self, features, activation, deconv=False, bn=False, expand=False, align_corners=True, size=None): + """Init. + + Args: + features (int): number of features + """ + super(FeatureFusionBlock_custom, self).__init__() + + self.deconv = deconv + self.align_corners = align_corners + + self.groups=1 + + self.expand = expand + out_features = features + if self.expand==True: + out_features = features//2 + + self.out_conv = nn.Conv2d(features, out_features, kernel_size=1, stride=1, padding=0, bias=True, groups=1) + + self.resConfUnit1 = ResidualConvUnit_custom(features, activation, bn) + self.resConfUnit2 = ResidualConvUnit_custom(features, activation, bn) + + self.skip_add = nn.quantized.FloatFunctional() + + self.size=size + + def forward(self, *xs, size=None): + """Forward pass. + + Returns: + tensor: output + """ + output = xs[0] + + if len(xs) == 2: + res = self.resConfUnit1(xs[1]) + output = self.skip_add.add(output, res) + # output += res + + output = self.resConfUnit2(output) + + if (size is None) and (self.size is None): + modifier = {"scale_factor": 2} + elif size is None: + modifier = {"size": self.size} + else: + modifier = {"size": size} + + output = nn.functional.interpolate( + output, **modifier, mode="bilinear", align_corners=self.align_corners + ) + + output = self.out_conv(output) + + return output + diff --git a/midas/dpt_depth.py b/midas/dpt_depth.py new file mode 100644 index 0000000..3129d09 --- /dev/null +++ b/midas/dpt_depth.py @@ -0,0 +1,166 @@ +import torch +import torch.nn as nn + +from .base_model import BaseModel +from .blocks import ( + FeatureFusionBlock_custom, + Interpolate, + _make_encoder, + forward_beit, + forward_swin, + forward_levit, + forward_vit, +) +from .backbones.levit import stem_b4_transpose +from timm.models.layers import get_act_layer + + +def _make_fusion_block(features, use_bn, size = None): + return FeatureFusionBlock_custom( + features, + nn.ReLU(False), + deconv=False, + bn=use_bn, + expand=False, + align_corners=True, + size=size, + ) + + +class DPT(BaseModel): + def __init__( + self, + head, + features=256, + backbone="vitb_rn50_384", + readout="project", + channels_last=False, + use_bn=False, + **kwargs + ): + + super(DPT, self).__init__() + + self.channels_last = channels_last + + # For the Swin, Swin 2, LeViT and Next-ViT Transformers, the hierarchical architectures prevent setting the + # hooks freely. Instead, the hooks have to be chosen according to the ranges specified in the comments. + hooks = { + "beitl16_512": [5, 11, 17, 23], + "beitl16_384": [5, 11, 17, 23], + "beitb16_384": [2, 5, 8, 11], + "swin2l24_384": [1, 1, 17, 1], # Allowed ranges: [0, 1], [0, 1], [ 0, 17], [ 0, 1] + "swin2b24_384": [1, 1, 17, 1], # [0, 1], [0, 1], [ 0, 17], [ 0, 1] + "swin2t16_256": [1, 1, 5, 1], # [0, 1], [0, 1], [ 0, 5], [ 0, 1] + "swinl12_384": [1, 1, 17, 1], # [0, 1], [0, 1], [ 0, 17], [ 0, 1] + "next_vit_large_6m": [2, 6, 36, 39], # [0, 2], [3, 6], [ 7, 36], [37, 39] + "levit_384": [3, 11, 21], # [0, 3], [6, 11], [14, 21] + "vitb_rn50_384": [0, 1, 8, 11], + "vitb16_384": [2, 5, 8, 11], + "vitl16_384": [5, 11, 17, 23], + }[backbone] + + if "next_vit" in backbone: + in_features = { + "next_vit_large_6m": [96, 256, 512, 1024], + }[backbone] + else: + in_features = None + + # Instantiate backbone and reassemble blocks + self.pretrained, self.scratch = _make_encoder( + backbone, + features, + False, # Set to true of you want to train from scratch, uses ImageNet weights + groups=1, + expand=False, + exportable=False, + hooks=hooks, + use_readout=readout, + in_features=in_features, + ) + + self.number_layers = len(hooks) if hooks is not None else 4 + size_refinenet3 = None + self.scratch.stem_transpose = None + + if "beit" in backbone: + self.forward_transformer = forward_beit + elif "swin" in backbone: + self.forward_transformer = forward_swin + elif "next_vit" in backbone: + from .backbones.next_vit import forward_next_vit + self.forward_transformer = forward_next_vit + elif "levit" in backbone: + self.forward_transformer = forward_levit + size_refinenet3 = 7 + self.scratch.stem_transpose = stem_b4_transpose(256, 128, get_act_layer("hard_swish")) + else: + self.forward_transformer = forward_vit + + self.scratch.refinenet1 = _make_fusion_block(features, use_bn) + self.scratch.refinenet2 = _make_fusion_block(features, use_bn) + self.scratch.refinenet3 = _make_fusion_block(features, use_bn, size_refinenet3) + if self.number_layers >= 4: + self.scratch.refinenet4 = _make_fusion_block(features, use_bn) + + self.scratch.output_conv = head + + + def forward(self, x): + if self.channels_last == True: + x.contiguous(memory_format=torch.channels_last) + + layers = self.forward_transformer(self.pretrained, x) + if self.number_layers == 3: + layer_1, layer_2, layer_3 = layers + else: + layer_1, layer_2, layer_3, layer_4 = layers + + layer_1_rn = self.scratch.layer1_rn(layer_1) + layer_2_rn = self.scratch.layer2_rn(layer_2) + layer_3_rn = self.scratch.layer3_rn(layer_3) + if self.number_layers >= 4: + layer_4_rn = self.scratch.layer4_rn(layer_4) + + if self.number_layers == 3: + path_3 = self.scratch.refinenet3(layer_3_rn, size=layer_2_rn.shape[2:]) + else: + path_4 = self.scratch.refinenet4(layer_4_rn, size=layer_3_rn.shape[2:]) + path_3 = self.scratch.refinenet3(path_4, layer_3_rn, size=layer_2_rn.shape[2:]) + path_2 = self.scratch.refinenet2(path_3, layer_2_rn, size=layer_1_rn.shape[2:]) + path_1 = self.scratch.refinenet1(path_2, layer_1_rn) + + if self.scratch.stem_transpose is not None: + path_1 = self.scratch.stem_transpose(path_1) + + out = self.scratch.output_conv(path_1) + + return out + + +class DPTDepthModel(DPT): + def __init__(self, path=None, non_negative=True, **kwargs): + features = kwargs["features"] if "features" in kwargs else 256 + head_features_1 = kwargs["head_features_1"] if "head_features_1" in kwargs else features + head_features_2 = kwargs["head_features_2"] if "head_features_2" in kwargs else 32 + kwargs.pop("head_features_1", None) + kwargs.pop("head_features_2", None) + + head = nn.Sequential( + nn.Conv2d(head_features_1, head_features_1 // 2, kernel_size=3, stride=1, padding=1), + Interpolate(scale_factor=2, mode="bilinear", align_corners=True), + nn.Conv2d(head_features_1 // 2, head_features_2, kernel_size=3, stride=1, padding=1), + nn.ReLU(True), + nn.Conv2d(head_features_2, 1, kernel_size=1, stride=1, padding=0), + nn.ReLU(True) if non_negative else nn.Identity(), + nn.Identity(), + ) + + super().__init__(head, **kwargs) + + if path is not None: + self.load(path) + + def forward(self, x): + return super().forward(x).squeeze(dim=1) diff --git a/midas/midas_net.py b/midas/midas_net.py new file mode 100644 index 0000000..8a95497 --- /dev/null +++ b/midas/midas_net.py @@ -0,0 +1,76 @@ +"""MidashNet: Network for monocular depth estimation trained by mixing several datasets. +This file contains code that is adapted from +https://github.com/thomasjpfan/pytorch_refinenet/blob/master/pytorch_refinenet/refinenet/refinenet_4cascade.py +""" +import torch +import torch.nn as nn + +from .base_model import BaseModel +from .blocks import FeatureFusionBlock, Interpolate, _make_encoder + + +class MidasNet(BaseModel): + """Network for monocular depth estimation. + """ + + def __init__(self, path=None, features=256, non_negative=True): + """Init. + + Args: + path (str, optional): Path to saved model. Defaults to None. + features (int, optional): Number of features. Defaults to 256. + backbone (str, optional): Backbone network for encoder. Defaults to resnet50 + """ + print("Loading weights: ", path) + + super(MidasNet, self).__init__() + + use_pretrained = False if path is None else True + + self.pretrained, self.scratch = _make_encoder(backbone="resnext101_wsl", features=features, use_pretrained=use_pretrained) + + self.scratch.refinenet4 = FeatureFusionBlock(features) + self.scratch.refinenet3 = FeatureFusionBlock(features) + self.scratch.refinenet2 = FeatureFusionBlock(features) + self.scratch.refinenet1 = FeatureFusionBlock(features) + + self.scratch.output_conv = nn.Sequential( + nn.Conv2d(features, 128, kernel_size=3, stride=1, padding=1), + Interpolate(scale_factor=2, mode="bilinear"), + nn.Conv2d(128, 32, kernel_size=3, stride=1, padding=1), + nn.ReLU(True), + nn.Conv2d(32, 1, kernel_size=1, stride=1, padding=0), + nn.ReLU(True) if non_negative else nn.Identity(), + ) + + if path: + self.load(path) + + def forward(self, x): + """Forward pass. + + Args: + x (tensor): input data (image) + + Returns: + tensor: depth + """ + + layer_1 = self.pretrained.layer1(x) + layer_2 = self.pretrained.layer2(layer_1) + layer_3 = self.pretrained.layer3(layer_2) + layer_4 = self.pretrained.layer4(layer_3) + + layer_1_rn = self.scratch.layer1_rn(layer_1) + layer_2_rn = self.scratch.layer2_rn(layer_2) + layer_3_rn = self.scratch.layer3_rn(layer_3) + layer_4_rn = self.scratch.layer4_rn(layer_4) + + path_4 = self.scratch.refinenet4(layer_4_rn) + path_3 = self.scratch.refinenet3(path_4, layer_3_rn) + path_2 = self.scratch.refinenet2(path_3, layer_2_rn) + path_1 = self.scratch.refinenet1(path_2, layer_1_rn) + + out = self.scratch.output_conv(path_1) + + return torch.squeeze(out, dim=1) diff --git a/midas/midas_net_custom.py b/midas/midas_net_custom.py new file mode 100644 index 0000000..50e4acb --- /dev/null +++ b/midas/midas_net_custom.py @@ -0,0 +1,128 @@ +"""MidashNet: Network for monocular depth estimation trained by mixing several datasets. +This file contains code that is adapted from +https://github.com/thomasjpfan/pytorch_refinenet/blob/master/pytorch_refinenet/refinenet/refinenet_4cascade.py +""" +import torch +import torch.nn as nn + +from .base_model import BaseModel +from .blocks import FeatureFusionBlock, FeatureFusionBlock_custom, Interpolate, _make_encoder + + +class MidasNet_small(BaseModel): + """Network for monocular depth estimation. + """ + + def __init__(self, path=None, features=64, backbone="efficientnet_lite3", non_negative=True, exportable=True, channels_last=False, align_corners=True, + blocks={'expand': True}): + """Init. + + Args: + path (str, optional): Path to saved model. Defaults to None. + features (int, optional): Number of features. Defaults to 256. + backbone (str, optional): Backbone network for encoder. Defaults to resnet50 + """ + print("Loading weights: ", path) + + super(MidasNet_small, self).__init__() + + use_pretrained = False if path else True + + self.channels_last = channels_last + self.blocks = blocks + self.backbone = backbone + + self.groups = 1 + + features1=features + features2=features + features3=features + features4=features + self.expand = False + if "expand" in self.blocks and self.blocks['expand'] == True: + self.expand = True + features1=features + features2=features*2 + features3=features*4 + features4=features*8 + + self.pretrained, self.scratch = _make_encoder(self.backbone, features, use_pretrained, groups=self.groups, expand=self.expand, exportable=exportable) + + self.scratch.activation = nn.ReLU(False) + + self.scratch.refinenet4 = FeatureFusionBlock_custom(features4, self.scratch.activation, deconv=False, bn=False, expand=self.expand, align_corners=align_corners) + self.scratch.refinenet3 = FeatureFusionBlock_custom(features3, self.scratch.activation, deconv=False, bn=False, expand=self.expand, align_corners=align_corners) + self.scratch.refinenet2 = FeatureFusionBlock_custom(features2, self.scratch.activation, deconv=False, bn=False, expand=self.expand, align_corners=align_corners) + self.scratch.refinenet1 = FeatureFusionBlock_custom(features1, self.scratch.activation, deconv=False, bn=False, align_corners=align_corners) + + + self.scratch.output_conv = nn.Sequential( + nn.Conv2d(features, features//2, kernel_size=3, stride=1, padding=1, groups=self.groups), + Interpolate(scale_factor=2, mode="bilinear"), + nn.Conv2d(features//2, 32, kernel_size=3, stride=1, padding=1), + self.scratch.activation, + nn.Conv2d(32, 1, kernel_size=1, stride=1, padding=0), + nn.ReLU(True) if non_negative else nn.Identity(), + nn.Identity(), + ) + + if path: + self.load(path) + + + def forward(self, x): + """Forward pass. + + Args: + x (tensor): input data (image) + + Returns: + tensor: depth + """ + if self.channels_last==True: + print("self.channels_last = ", self.channels_last) + x.contiguous(memory_format=torch.channels_last) + + + layer_1 = self.pretrained.layer1(x) + layer_2 = self.pretrained.layer2(layer_1) + layer_3 = self.pretrained.layer3(layer_2) + layer_4 = self.pretrained.layer4(layer_3) + + layer_1_rn = self.scratch.layer1_rn(layer_1) + layer_2_rn = self.scratch.layer2_rn(layer_2) + layer_3_rn = self.scratch.layer3_rn(layer_3) + layer_4_rn = self.scratch.layer4_rn(layer_4) + + + path_4 = self.scratch.refinenet4(layer_4_rn) + path_3 = self.scratch.refinenet3(path_4, layer_3_rn) + path_2 = self.scratch.refinenet2(path_3, layer_2_rn) + path_1 = self.scratch.refinenet1(path_2, layer_1_rn) + + out = self.scratch.output_conv(path_1) + + return torch.squeeze(out, dim=1) + + + +def fuse_model(m): + prev_previous_type = nn.Identity() + prev_previous_name = '' + previous_type = nn.Identity() + previous_name = '' + for name, module in m.named_modules(): + if prev_previous_type == nn.Conv2d and previous_type == nn.BatchNorm2d and type(module) == nn.ReLU: + # print("FUSED ", prev_previous_name, previous_name, name) + torch.quantization.fuse_modules(m, [prev_previous_name, previous_name, name], inplace=True) + elif prev_previous_type == nn.Conv2d and previous_type == nn.BatchNorm2d: + # print("FUSED ", prev_previous_name, previous_name) + torch.quantization.fuse_modules(m, [prev_previous_name, previous_name], inplace=True) + # elif previous_type == nn.Conv2d and type(module) == nn.ReLU: + # print("FUSED ", previous_name, name) + # torch.quantization.fuse_modules(m, [previous_name, name], inplace=True) + + prev_previous_type = previous_type + prev_previous_name = previous_name + previous_type = type(module) + previous_name = name \ No newline at end of file diff --git a/midas/model_loader.py b/midas/model_loader.py new file mode 100644 index 0000000..f1cd1f2 --- /dev/null +++ b/midas/model_loader.py @@ -0,0 +1,242 @@ +import cv2 +import torch + +from midas.dpt_depth import DPTDepthModel +from midas.midas_net import MidasNet +from midas.midas_net_custom import MidasNet_small +from midas.transforms import Resize, NormalizeImage, PrepareForNet + +from torchvision.transforms import Compose + +default_models = { + "dpt_beit_large_512": "weights/dpt_beit_large_512.pt", + "dpt_beit_large_384": "weights/dpt_beit_large_384.pt", + "dpt_beit_base_384": "weights/dpt_beit_base_384.pt", + "dpt_swin2_large_384": "weights/dpt_swin2_large_384.pt", + "dpt_swin2_base_384": "weights/dpt_swin2_base_384.pt", + "dpt_swin2_tiny_256": "weights/dpt_swin2_tiny_256.pt", + "dpt_swin_large_384": "weights/dpt_swin_large_384.pt", + "dpt_next_vit_large_384": "weights/dpt_next_vit_large_384.pt", + "dpt_levit_224": "weights/dpt_levit_224.pt", + "dpt_large_384": "weights/dpt_large_384.pt", + "dpt_hybrid_384": "weights/dpt_hybrid_384.pt", + "midas_v21_384": "weights/midas_v21_384.pt", + "midas_v21_small_256": "weights/midas_v21_small_256.pt", + "openvino_midas_v21_small_256": "weights/openvino_midas_v21_small_256.xml", +} + + +def load_model(device, model_path, model_type="dpt_large_384", optimize=True, height=None, square=False): + """Load the specified network. + + Args: + device (device): the torch device used + model_path (str): path to saved model + model_type (str): the type of the model to be loaded + optimize (bool): optimize the model to half-integer on CUDA? + height (int): inference encoder image height + square (bool): resize to a square resolution? + + Returns: + The loaded network, the transform which prepares images as input to the network and the dimensions of the + network input + """ + if "openvino" in model_type: + from openvino.runtime import Core + + keep_aspect_ratio = not square + + if model_type == "dpt_beit_large_512": + model = DPTDepthModel( + path=model_path, + backbone="beitl16_512", + non_negative=True, + ) + net_w, net_h = 512, 512 + resize_mode = "minimal" + normalization = NormalizeImage(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]) + + elif model_type == "dpt_beit_large_384": + model = DPTDepthModel( + path=model_path, + backbone="beitl16_384", + non_negative=True, + ) + net_w, net_h = 384, 384 + resize_mode = "minimal" + normalization = NormalizeImage(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]) + + elif model_type == "dpt_beit_base_384": + model = DPTDepthModel( + path=model_path, + backbone="beitb16_384", + non_negative=True, + ) + net_w, net_h = 384, 384 + resize_mode = "minimal" + normalization = NormalizeImage(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]) + + elif model_type == "dpt_swin2_large_384": + model = DPTDepthModel( + path=model_path, + backbone="swin2l24_384", + non_negative=True, + ) + net_w, net_h = 384, 384 + keep_aspect_ratio = False + resize_mode = "minimal" + normalization = NormalizeImage(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]) + + elif model_type == "dpt_swin2_base_384": + model = DPTDepthModel( + path=model_path, + backbone="swin2b24_384", + non_negative=True, + ) + net_w, net_h = 384, 384 + keep_aspect_ratio = False + resize_mode = "minimal" + normalization = NormalizeImage(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]) + + elif model_type == "dpt_swin2_tiny_256": + model = DPTDepthModel( + path=model_path, + backbone="swin2t16_256", + non_negative=True, + ) + net_w, net_h = 256, 256 + keep_aspect_ratio = False + resize_mode = "minimal" + normalization = NormalizeImage(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]) + + elif model_type == "dpt_swin_large_384": + model = DPTDepthModel( + path=model_path, + backbone="swinl12_384", + non_negative=True, + ) + net_w, net_h = 384, 384 + keep_aspect_ratio = False + resize_mode = "minimal" + normalization = NormalizeImage(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]) + + elif model_type == "dpt_next_vit_large_384": + model = DPTDepthModel( + path=model_path, + backbone="next_vit_large_6m", + non_negative=True, + ) + net_w, net_h = 384, 384 + resize_mode = "minimal" + normalization = NormalizeImage(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]) + + # We change the notation from dpt_levit_224 (MiDaS notation) to levit_384 (timm notation) here, where the 224 refers + # to the resolution 224x224 used by LeViT and 384 is the first entry of the embed_dim, see _cfg and model_cfgs of + # https://github.com/rwightman/pytorch-image-models/blob/main/timm/models/levit.py + # (commit id: 927f031293a30afb940fff0bee34b85d9c059b0e) + elif model_type == "dpt_levit_224": + model = DPTDepthModel( + path=model_path, + backbone="levit_384", + non_negative=True, + head_features_1=64, + head_features_2=8, + ) + net_w, net_h = 224, 224 + keep_aspect_ratio = False + resize_mode = "minimal" + normalization = NormalizeImage(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]) + + elif model_type == "dpt_large_384": + model = DPTDepthModel( + path=model_path, + backbone="vitl16_384", + non_negative=True, + ) + net_w, net_h = 384, 384 + resize_mode = "minimal" + normalization = NormalizeImage(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]) + + elif model_type == "dpt_hybrid_384": + model = DPTDepthModel( + path=model_path, + backbone="vitb_rn50_384", + non_negative=True, + ) + net_w, net_h = 384, 384 + resize_mode = "minimal" + normalization = NormalizeImage(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]) + + elif model_type == "midas_v21_384": + model = MidasNet(model_path, non_negative=True) + net_w, net_h = 384, 384 + resize_mode = "upper_bound" + normalization = NormalizeImage( + mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225] + ) + + elif model_type == "midas_v21_small_256": + model = MidasNet_small(model_path, features=64, backbone="efficientnet_lite3", exportable=True, + non_negative=True, blocks={'expand': True}) + net_w, net_h = 256, 256 + resize_mode = "upper_bound" + normalization = NormalizeImage( + mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225] + ) + + elif model_type == "openvino_midas_v21_small_256": + ie = Core() + uncompiled_model = ie.read_model(model=model_path) + model = ie.compile_model(uncompiled_model, "CPU") + net_w, net_h = 256, 256 + resize_mode = "upper_bound" + normalization = NormalizeImage( + mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225] + ) + + else: + print(f"model_type '{model_type}' not implemented, use: --model_type large") + assert False + + if not "openvino" in model_type: + print("Model loaded, number of parameters = {:.0f}M".format(sum(p.numel() for p in model.parameters()) / 1e6)) + else: + print("Model loaded, optimized with OpenVINO") + + if "openvino" in model_type: + keep_aspect_ratio = False + + if height is not None: + net_w, net_h = height, height + + transform = Compose( + [ + Resize( + net_w, + net_h, + resize_target=None, + keep_aspect_ratio=keep_aspect_ratio, + ensure_multiple_of=32, + resize_method=resize_mode, + image_interpolation_method=cv2.INTER_CUBIC, + ), + normalization, + PrepareForNet(), + ] + ) + + if not "openvino" in model_type: + model.eval() + + if optimize and (device == torch.device("cuda")): + if not "openvino" in model_type: + model = model.to(memory_format=torch.channels_last) + model = model.half() + else: + print("Error: OpenVINO models are already optimized. No optimization to half-float possible.") + exit() + + if not "openvino" in model_type: + model.to(device) + + return model, transform, net_w, net_h diff --git a/midas/transforms.py b/midas/transforms.py new file mode 100644 index 0000000..350cbc1 --- /dev/null +++ b/midas/transforms.py @@ -0,0 +1,234 @@ +import numpy as np +import cv2 +import math + + +def apply_min_size(sample, size, image_interpolation_method=cv2.INTER_AREA): + """Rezise the sample to ensure the given size. Keeps aspect ratio. + + Args: + sample (dict): sample + size (tuple): image size + + Returns: + tuple: new size + """ + shape = list(sample["disparity"].shape) + + if shape[0] >= size[0] and shape[1] >= size[1]: + return sample + + scale = [0, 0] + scale[0] = size[0] / shape[0] + scale[1] = size[1] / shape[1] + + scale = max(scale) + + shape[0] = math.ceil(scale * shape[0]) + shape[1] = math.ceil(scale * shape[1]) + + # resize + sample["image"] = cv2.resize( + sample["image"], tuple(shape[::-1]), interpolation=image_interpolation_method + ) + + sample["disparity"] = cv2.resize( + sample["disparity"], tuple(shape[::-1]), interpolation=cv2.INTER_NEAREST + ) + sample["mask"] = cv2.resize( + sample["mask"].astype(np.float32), + tuple(shape[::-1]), + interpolation=cv2.INTER_NEAREST, + ) + sample["mask"] = sample["mask"].astype(bool) + + return tuple(shape) + + +class Resize(object): + """Resize sample to given size (width, height). + """ + + def __init__( + self, + width, + height, + resize_target=True, + keep_aspect_ratio=False, + ensure_multiple_of=1, + resize_method="lower_bound", + image_interpolation_method=cv2.INTER_AREA, + ): + """Init. + + Args: + width (int): desired output width + height (int): desired output height + resize_target (bool, optional): + True: Resize the full sample (image, mask, target). + False: Resize image only. + Defaults to True. + keep_aspect_ratio (bool, optional): + True: Keep the aspect ratio of the input sample. + Output sample might not have the given width and height, and + resize behaviour depends on the parameter 'resize_method'. + Defaults to False. + ensure_multiple_of (int, optional): + Output width and height is constrained to be multiple of this parameter. + Defaults to 1. + resize_method (str, optional): + "lower_bound": Output will be at least as large as the given size. + "upper_bound": Output will be at max as large as the given size. (Output size might be smaller than given size.) + "minimal": Scale as least as possible. (Output size might be smaller than given size.) + Defaults to "lower_bound". + """ + self.__width = width + self.__height = height + + self.__resize_target = resize_target + self.__keep_aspect_ratio = keep_aspect_ratio + self.__multiple_of = ensure_multiple_of + self.__resize_method = resize_method + self.__image_interpolation_method = image_interpolation_method + + def constrain_to_multiple_of(self, x, min_val=0, max_val=None): + y = (np.round(x / self.__multiple_of) * self.__multiple_of).astype(int) + + if max_val is not None and y > max_val: + y = (np.floor(x / self.__multiple_of) * self.__multiple_of).astype(int) + + if y < min_val: + y = (np.ceil(x / self.__multiple_of) * self.__multiple_of).astype(int) + + return y + + def get_size(self, width, height): + # determine new height and width + scale_height = self.__height / height + scale_width = self.__width / width + + if self.__keep_aspect_ratio: + if self.__resize_method == "lower_bound": + # scale such that output size is lower bound + if scale_width > scale_height: + # fit width + scale_height = scale_width + else: + # fit height + scale_width = scale_height + elif self.__resize_method == "upper_bound": + # scale such that output size is upper bound + if scale_width < scale_height: + # fit width + scale_height = scale_width + else: + # fit height + scale_width = scale_height + elif self.__resize_method == "minimal": + # scale as least as possbile + if abs(1 - scale_width) < abs(1 - scale_height): + # fit width + scale_height = scale_width + else: + # fit height + scale_width = scale_height + else: + raise ValueError( + f"resize_method {self.__resize_method} not implemented" + ) + + if self.__resize_method == "lower_bound": + new_height = self.constrain_to_multiple_of( + scale_height * height, min_val=self.__height + ) + new_width = self.constrain_to_multiple_of( + scale_width * width, min_val=self.__width + ) + elif self.__resize_method == "upper_bound": + new_height = self.constrain_to_multiple_of( + scale_height * height, max_val=self.__height + ) + new_width = self.constrain_to_multiple_of( + scale_width * width, max_val=self.__width + ) + elif self.__resize_method == "minimal": + new_height = self.constrain_to_multiple_of(scale_height * height) + new_width = self.constrain_to_multiple_of(scale_width * width) + else: + raise ValueError(f"resize_method {self.__resize_method} not implemented") + + return (new_width, new_height) + + def __call__(self, sample): + width, height = self.get_size( + sample["image"].shape[1], sample["image"].shape[0] + ) + + # resize sample + sample["image"] = cv2.resize( + sample["image"], + (width, height), + interpolation=self.__image_interpolation_method, + ) + + if self.__resize_target: + if "disparity" in sample: + sample["disparity"] = cv2.resize( + sample["disparity"], + (width, height), + interpolation=cv2.INTER_NEAREST, + ) + + if "depth" in sample: + sample["depth"] = cv2.resize( + sample["depth"], (width, height), interpolation=cv2.INTER_NEAREST + ) + + sample["mask"] = cv2.resize( + sample["mask"].astype(np.float32), + (width, height), + interpolation=cv2.INTER_NEAREST, + ) + sample["mask"] = sample["mask"].astype(bool) + + return sample + + +class NormalizeImage(object): + """Normlize image by given mean and std. + """ + + def __init__(self, mean, std): + self.__mean = mean + self.__std = std + + def __call__(self, sample): + sample["image"] = (sample["image"] - self.__mean) / self.__std + + return sample + + +class PrepareForNet(object): + """Prepare sample for usage as network input. + """ + + def __init__(self): + pass + + def __call__(self, sample): + image = np.transpose(sample["image"], (2, 0, 1)) + sample["image"] = np.ascontiguousarray(image).astype(np.float32) + + if "mask" in sample: + sample["mask"] = sample["mask"].astype(np.float32) + sample["mask"] = np.ascontiguousarray(sample["mask"]) + + if "disparity" in sample: + disparity = sample["disparity"].astype(np.float32) + sample["disparity"] = np.ascontiguousarray(disparity) + + if "depth" in sample: + depth = sample["depth"].astype(np.float32) + sample["depth"] = np.ascontiguousarray(depth) + + return sample diff --git a/nerf/clip.py b/nerf/clip.py new file mode 100644 index 0000000..2895474 --- /dev/null +++ b/nerf/clip.py @@ -0,0 +1,127 @@ +import torch +import torch.nn as nn + +import torchvision.transforms as T +import torchvision.transforms.functional as TF + +# import clip +from transformers import CLIPFeatureExtractor, CLIPModel, CLIPTokenizer, CLIPProcessor +from torchvision import transforms + +import torch.nn.functional as F + + +def spherical_dist_loss(x, y): + x = F.normalize(x, dim=-1) + y = F.normalize(y, dim=-1) + # print(x.shape, y.shape) + return (x - y).norm(dim=-1).div(2).arcsin().pow(2).mul(2) + + +class CLIP(nn.Module): + def __init__(self, device, + # clip_name = 'laion/CLIP-ViT-B-32-laion2B-s34B-b79K' + clip_name = 'openai/clip-vit-large-patch14' + ): + super().__init__() + + self.device = device + + clip_name = clip_name + + # self.feature_extractor = CLIPFeatureExtractor.from_pretrained(clip_name) + self.clip_model = CLIPModel.from_pretrained(clip_name).cuda() + self.tokenizer = CLIPTokenizer.from_pretrained('openai/clip-vit-large-patch14') + # self.tokenizer = CLIPTokenizer.from_pretrained('openai/clip-vit-base-patch32') + self.processor = CLIPProcessor.from_pretrained("openai/clip-vit-large-patch14") + + # self.normalize = transforms.Normalize(mean=self.feature_extractor.image_mean, std=self.feature_extractor.image_std) + + # self.resize = transforms.Resize(224) + + # # image augmentation + # self.aug = T.Compose([ + # T.Resize((224, 224)), + # T.Normalize((0.48145466, 0.4578275, 0.40821073), (0.26862954, 0.26130258, 0.27577711)), + # ]) + + + def get_text_embeds(self, prompt, neg_prompt=None, dir=None): + + clip_text_input = self.tokenizer( + prompt, + padding="max_length", + max_length=self.tokenizer.model_max_length, + truncation=True, + return_tensors="pt", + ).input_ids.cuda() + text_z = self.clip_model.get_text_features(clip_text_input) + # text = clip.tokenize(prompt).to(self.device) + # text_z = self.clip_model.encode_text(text) + text_z = text_z / text_z.norm(dim=-1, keepdim=True) + + return text_z + + def set_epoch(self, epoch): + pass + + def get_img_embeds(self, img): + img = self.aug(img) + image_z = self.clip_model.get_image_features(img) + image_z = image_z / image_z.norm(dim=-1, keepdim=True) # normalize features + return image_z + + + # def train_step(self, text_z, pred_rgb, image_ref_clip, **kwargs): + + # pred_rgb = self.resize(pred_rgb) + # pred_rgb = self.normalize(pred_rgb) + + # image_z = self.clip_model.get_image_features(pred_rgb) + # image_z = image_z / image_z.norm(dim=-1, keepdim=True) # normalize features + + # # print(image_z.shape, text_z.shape) + # loss = spherical_dist_loss(image_z, image_ref_clip) + + # # loss = - (image_z * text_z).sum(-1).mean() + + # return loss + + def train_step(self, text_z, pred_rgb): + + pred_rgb = self.aug(pred_rgb) + + image_z = self.clip_model.encode_image(pred_rgb) + image_z = image_z / image_z.norm(dim=-1, keepdim=True) # normalize features + + loss = - (image_z * text_z).sum(-1).mean() + # loss = spherical_dist_loss(image_z, text_z) + return loss + + def text_loss(self, text_z, pred_rgb): + + pred_rgb = self.resize(pred_rgb) + pred_rgb = self.normalize(pred_rgb) + + image_z = self.clip_model.get_image_features(pred_rgb) + image_z = image_z / image_z.norm(dim=-1, keepdim=True) # normalize features + + # print(image_z.shape, text_z.shape) + loss = spherical_dist_loss(image_z, text_z) + + # loss = - (image_z * text_z).sum(-1).mean() + + return loss + + def img_loss(self, img_ref_z, pred_rgb): + # pred_rgb = self.aug(pred_rgb) + pred_rgb = self.resize(pred_rgb) + pred_rgb = self.normalize(pred_rgb) + + image_z = self.clip_model.get_image_features(pred_rgb) + image_z = image_z / image_z.norm(dim=-1, keepdim=True) # normalize features + + # loss = - (image_z * img_ref_z).sum(-1).mean() + loss = spherical_dist_loss(image_z, img_ref_z) + + return loss diff --git a/nerf/gui.py b/nerf/gui.py new file mode 100644 index 0000000..65faa5c --- /dev/null +++ b/nerf/gui.py @@ -0,0 +1,485 @@ +import math +import torch +import numpy as np +import dearpygui.dearpygui as dpg +from scipy.spatial.transform import Rotation as R + +from nerf.utils import * + + +class OrbitCamera: + def __init__(self, W, H, r=2, fovy=60): + self.W = W + self.H = H + self.radius = r # camera distance from center + self.fovy = fovy # in degree + self.center = np.array([0, 0, 0], dtype=np.float32) # look at this point + self.rot = R.from_matrix(np.eye(3)) + self.up = np.array([0, 1, 0], dtype=np.float32) # need to be normalized! + self.near = 0.001 + self.far = 1000 + + # pose + @property + def pose(self): + # first move camera to radius + res = np.eye(4, dtype=np.float32) + res[2, 3] = self.radius + # rotate + rot = np.eye(4, dtype=np.float32) + rot[:3, :3] = self.rot.as_matrix() + res = rot @ res + # translate + res[:3, 3] -= self.center + return res + + # intrinsics + @property + def intrinsics(self): + focal = self.H / (2 * np.tan(np.deg2rad(self.fovy) / 2)) + return np.array([focal, focal, self.W // 2, self.H // 2]) + + @property + def mvp(self): + focal = self.H / (2 * np.tan(np.deg2rad(self.fovy) / 2)) + projection = np.array([ + [2*focal/self.W, 0, 0, 0], + [0, -2*focal/self.H, 0, 0], + [0, 0, -(self.far+self.near)/(self.far-self.near), -(2*self.far*self.near)/(self.far-self.near)], + [0, 0, -1, 0] + ], dtype=np.float32) + + return projection @ np.linalg.inv(self.pose) # [4, 4] + + def orbit(self, dx, dy): + # rotate along camera up/side axis! + side = self.rot.as_matrix()[:3, 0] # why this is side --> ? # already normalized. + rotvec_x = self.up * np.deg2rad(-0.1 * dx) + rotvec_y = side * np.deg2rad(-0.1 * dy) + self.rot = R.from_rotvec(rotvec_x) * R.from_rotvec(rotvec_y) * self.rot + + def scale(self, delta): + self.radius *= 1.1 ** (-delta) + + def pan(self, dx, dy, dz=0): + # pan in camera coordinate system (careful on the sensitivity!) + self.center += 0.0005 * self.rot.as_matrix()[:3, :3] @ np.array([dx, -dy, dz]) + + +class NeRFGUI: + def __init__(self, opt, trainer, loader=None, debug=True): + self.opt = opt # shared with the trainer's opt to support in-place modification of rendering parameters. + self.W = opt.W + self.H = opt.H + self.cam = OrbitCamera(opt.W, opt.H, r=opt.radius, fovy=opt.fovy) + self.debug = debug + self.bg_color = torch.ones(3, dtype=torch.float32) # default white bg + self.training = False + self.step = 0 # training step + + self.trainer = trainer + self.loader = loader + self.render_buffer = np.zeros((self.W, self.H, 3), dtype=np.float32) + self.need_update = True # camera moved, should reset accumulation + self.spp = 1 # sample per pixel + self.light_dir = np.array([opt.light_theta, opt.light_phi]) + self.ambient_ratio = 1.0 + self.mode = 'image' # choose from ['image', 'depth'] + self.shading = 'albedo' + + self.dynamic_resolution = True if not self.opt.dmtet else False + self.downscale = 1 + self.train_steps = 16 + + dpg.create_context() + self.register_dpg() + self.test_step() + + + def __del__(self): + dpg.destroy_context() + + + def train_step(self): + + starter, ender = torch.cuda.Event(enable_timing=True), torch.cuda.Event(enable_timing=True) + starter.record() + + outputs = self.trainer.train_gui(self.loader, step=self.train_steps) + + ender.record() + torch.cuda.synchronize() + t = starter.elapsed_time(ender) + + self.step += self.train_steps + self.need_update = True + + dpg.set_value("_log_train_time", f'{t:.4f}ms ({int(1000/t)} FPS)') + dpg.set_value("_log_train_log", f'step = {self.step: 5d} (+{self.train_steps: 2d}), loss = {outputs["loss"]:.4f}, lr = {outputs["lr"]:.5f}') + + # dynamic train steps + # max allowed train time per-frame is 500 ms + full_t = t / self.train_steps * 16 + train_steps = min(16, max(4, int(16 * 500 / full_t))) + if train_steps > self.train_steps * 1.2 or train_steps < self.train_steps * 0.8: + self.train_steps = train_steps + + + def prepare_buffer(self, outputs): + if self.mode == 'image': + return outputs['image'].astype(np.float32) + else: + depth = outputs['depth'].astype(np.float32) + depth = (depth - depth.min()) / (depth.max() - depth.min() + 1e-6) + return np.expand_dims(depth, -1).repeat(3, -1) + + + def test_step(self): + + if self.need_update or self.spp < self.opt.max_spp: + + starter, ender = torch.cuda.Event(enable_timing=True), torch.cuda.Event(enable_timing=True) + starter.record() + + outputs = self.trainer.test_gui(self.cam.pose, self.cam.intrinsics, self.cam.mvp, self.W, self.H, self.bg_color, self.spp, self.downscale, self.light_dir, self.ambient_ratio, self.shading) + + ender.record() + torch.cuda.synchronize() + t = starter.elapsed_time(ender) + + # update dynamic resolution + if self.dynamic_resolution: + # max allowed infer time per-frame is 200 ms + full_t = t / (self.downscale ** 2) + downscale = min(1, max(1/4, math.sqrt(200 / full_t))) + if downscale > self.downscale * 1.2 or downscale < self.downscale * 0.8: + self.downscale = downscale + + if self.need_update: + self.render_buffer = self.prepare_buffer(outputs) + self.spp = 1 + self.need_update = False + else: + self.render_buffer = (self.render_buffer * self.spp + self.prepare_buffer(outputs)) / (self.spp + 1) + self.spp += 1 + + dpg.set_value("_log_infer_time", f'{t:.4f}ms ({int(1000/t)} FPS)') + dpg.set_value("_log_resolution", f'{int(self.downscale * self.W)}x{int(self.downscale * self.H)}') + dpg.set_value("_log_spp", self.spp) + dpg.set_value("_texture", self.render_buffer) + + + def register_dpg(self): + + ### register texture + + with dpg.texture_registry(show=False): + dpg.add_raw_texture(self.W, self.H, self.render_buffer, format=dpg.mvFormat_Float_rgb, tag="_texture") + + ### register window + + # the rendered image, as the primary window + with dpg.window(tag="_primary_window", width=self.W, height=self.H): + + # add the texture + dpg.add_image("_texture") + + dpg.set_primary_window("_primary_window", True) + + # control window + with dpg.window(label="Control", tag="_control_window", width=400, height=300): + + # text prompt + if self.opt.text is not None: + dpg.add_text("text: " + self.opt.text, tag="_log_prompt_text") + + if self.opt.negative != '': + dpg.add_text("negative text: " + self.opt.negative, tag="_log_prompt_negative_text") + + # button theme + with dpg.theme() as theme_button: + with dpg.theme_component(dpg.mvButton): + dpg.add_theme_color(dpg.mvThemeCol_Button, (23, 3, 18)) + dpg.add_theme_color(dpg.mvThemeCol_ButtonHovered, (51, 3, 47)) + dpg.add_theme_color(dpg.mvThemeCol_ButtonActive, (83, 18, 83)) + dpg.add_theme_style(dpg.mvStyleVar_FrameRounding, 5) + dpg.add_theme_style(dpg.mvStyleVar_FramePadding, 3, 3) + + # time + if not self.opt.test: + with dpg.group(horizontal=True): + dpg.add_text("Train time: ") + dpg.add_text("no data", tag="_log_train_time") + + with dpg.group(horizontal=True): + dpg.add_text("Infer time: ") + dpg.add_text("no data", tag="_log_infer_time") + + with dpg.group(horizontal=True): + dpg.add_text("SPP: ") + dpg.add_text("1", tag="_log_spp") + + # train button + if not self.opt.test: + with dpg.collapsing_header(label="Train", default_open=True): + with dpg.group(horizontal=True): + dpg.add_text("Train: ") + + def callback_train(sender, app_data): + if self.training: + self.training = False + dpg.configure_item("_button_train", label="start") + else: + self.training = True + dpg.configure_item("_button_train", label="stop") + + dpg.add_button(label="start", tag="_button_train", callback=callback_train) + dpg.bind_item_theme("_button_train", theme_button) + + def callback_reset(sender, app_data): + @torch.no_grad() + def weight_reset(m: nn.Module): + reset_parameters = getattr(m, "reset_parameters", None) + if callable(reset_parameters): + m.reset_parameters() + self.trainer.model.apply(fn=weight_reset) + self.trainer.model.reset_extra_state() # for cuda_ray density_grid and step_counter + self.need_update = True + + dpg.add_button(label="reset", tag="_button_reset", callback=callback_reset) + dpg.bind_item_theme("_button_reset", theme_button) + + + with dpg.group(horizontal=True): + dpg.add_text("Checkpoint: ") + + def callback_save(sender, app_data): + self.trainer.save_checkpoint(full=True, best=False) + dpg.set_value("_log_ckpt", "saved " + os.path.basename(self.trainer.stats["checkpoints"][-1])) + self.trainer.epoch += 1 # use epoch to indicate different calls. + + dpg.add_button(label="save", tag="_button_save", callback=callback_save) + dpg.bind_item_theme("_button_save", theme_button) + + dpg.add_text("", tag="_log_ckpt") + + # save mesh + with dpg.group(horizontal=True): + dpg.add_text("Marching Cubes: ") + + def callback_mesh(sender, app_data): + self.trainer.save_mesh() + dpg.set_value("_log_mesh", "saved " + f'{self.trainer.name}_{self.trainer.epoch}.ply') + self.trainer.epoch += 1 # use epoch to indicate different calls. + + dpg.add_button(label="mesh", tag="_button_mesh", callback=callback_mesh) + dpg.bind_item_theme("_button_mesh", theme_button) + + dpg.add_text("", tag="_log_mesh") + + with dpg.group(horizontal=True): + dpg.add_text("", tag="_log_train_log") + + + # rendering options + with dpg.collapsing_header(label="Options", default_open=True): + + # dynamic rendering resolution + with dpg.group(horizontal=True): + + def callback_set_dynamic_resolution(sender, app_data): + if self.dynamic_resolution: + self.dynamic_resolution = False + self.downscale = 1 + else: + self.dynamic_resolution = True + self.need_update = True + + dpg.add_checkbox(label="dynamic resolution", default_value=self.dynamic_resolution, callback=callback_set_dynamic_resolution) + dpg.add_text(f"{self.W}x{self.H}", tag="_log_resolution") + + # mode combo + def callback_change_mode(sender, app_data): + self.mode = app_data + self.need_update = True + + dpg.add_combo(('image', 'depth'), label='mode', default_value=self.mode, callback=callback_change_mode) + + # bg_color picker + def callback_change_bg(sender, app_data): + self.bg_color = torch.tensor(app_data[:3], dtype=torch.float32) # only need RGB in [0, 1] + self.need_update = True + + dpg.add_color_edit((255, 255, 255), label="Background Color", width=200, tag="_color_editor", no_alpha=True, callback=callback_change_bg) + + # fov slider + def callback_set_fovy(sender, app_data): + self.cam.fovy = app_data + self.need_update = True + + dpg.add_slider_int(label="FoV (vertical)", min_value=1, max_value=120, format="%d deg", default_value=self.cam.fovy, callback=callback_set_fovy) + + # dt_gamma slider + def callback_set_dt_gamma(sender, app_data): + self.opt.dt_gamma = app_data + self.need_update = True + + dpg.add_slider_float(label="dt_gamma", min_value=0, max_value=0.1, format="%.5f", default_value=self.opt.dt_gamma, callback=callback_set_dt_gamma) + + # max_steps slider + def callback_set_max_steps(sender, app_data): + self.opt.max_steps = app_data + self.need_update = True + + dpg.add_slider_int(label="max steps", min_value=1, max_value=1024, format="%d", default_value=self.opt.max_steps, callback=callback_set_max_steps) + + # aabb slider + def callback_set_aabb(sender, app_data, user_data): + # user_data is the dimension for aabb (xmin, ymin, zmin, xmax, ymax, zmax) + self.trainer.model.aabb_infer[user_data] = app_data + + # also change train aabb ? [better not...] + #self.trainer.model.aabb_train[user_data] = app_data + + self.need_update = True + + dpg.add_separator() + dpg.add_text("Axis-aligned bounding box:") + + with dpg.group(horizontal=True): + dpg.add_slider_float(label="x", width=150, min_value=-self.opt.bound, max_value=0, format="%.2f", default_value=-self.opt.bound, callback=callback_set_aabb, user_data=0) + dpg.add_slider_float(label="", width=150, min_value=0, max_value=self.opt.bound, format="%.2f", default_value=self.opt.bound, callback=callback_set_aabb, user_data=3) + + with dpg.group(horizontal=True): + dpg.add_slider_float(label="y", width=150, min_value=-self.opt.bound, max_value=0, format="%.2f", default_value=-self.opt.bound, callback=callback_set_aabb, user_data=1) + dpg.add_slider_float(label="", width=150, min_value=0, max_value=self.opt.bound, format="%.2f", default_value=self.opt.bound, callback=callback_set_aabb, user_data=4) + + with dpg.group(horizontal=True): + dpg.add_slider_float(label="z", width=150, min_value=-self.opt.bound, max_value=0, format="%.2f", default_value=-self.opt.bound, callback=callback_set_aabb, user_data=2) + dpg.add_slider_float(label="", width=150, min_value=0, max_value=self.opt.bound, format="%.2f", default_value=self.opt.bound, callback=callback_set_aabb, user_data=5) + + # light dir + def callback_set_light_dir(sender, app_data, user_data): + self.light_dir[user_data] = app_data + self.need_update = True + + dpg.add_separator() + dpg.add_text("Plane Light Direction:") + + with dpg.group(horizontal=True): + dpg.add_slider_float(label="theta", min_value=0, max_value=180, format="%.2f", default_value=self.opt.light_theta, callback=callback_set_light_dir, user_data=0) + + with dpg.group(horizontal=True): + dpg.add_slider_float(label="phi", min_value=0, max_value=360, format="%.2f", default_value=self.opt.light_phi, callback=callback_set_light_dir, user_data=1) + + # ambient ratio + def callback_set_abm_ratio(sender, app_data): + self.ambient_ratio = app_data + self.need_update = True + + dpg.add_slider_float(label="ambient", min_value=0, max_value=1.0, format="%.5f", default_value=self.ambient_ratio, callback=callback_set_abm_ratio) + + # shading mode + def callback_change_shading(sender, app_data): + self.shading = app_data + self.need_update = True + + dpg.add_combo(('albedo', 'lambertian', 'textureless', 'normal'), label='shading', default_value=self.shading, callback=callback_change_shading) + + + # debug info + if self.debug: + with dpg.collapsing_header(label="Debug"): + # pose + dpg.add_separator() + dpg.add_text("Camera Pose:") + dpg.add_text(str(self.cam.pose), tag="_log_pose") + + + ### register camera handler + + def callback_camera_drag_rotate(sender, app_data): + + if not dpg.is_item_focused("_primary_window"): + return + + dx = app_data[1] + dy = app_data[2] + + self.cam.orbit(dx, dy) + self.need_update = True + + if self.debug: + dpg.set_value("_log_pose", str(self.cam.pose)) + + + def callback_camera_wheel_scale(sender, app_data): + + if not dpg.is_item_focused("_primary_window"): + return + + delta = app_data + + self.cam.scale(delta) + self.need_update = True + + if self.debug: + dpg.set_value("_log_pose", str(self.cam.pose)) + + + def callback_camera_drag_pan(sender, app_data): + + if not dpg.is_item_focused("_primary_window"): + return + + dx = app_data[1] + dy = app_data[2] + + self.cam.pan(dx, dy) + self.need_update = True + + if self.debug: + dpg.set_value("_log_pose", str(self.cam.pose)) + + + with dpg.handler_registry(): + dpg.add_mouse_drag_handler(button=dpg.mvMouseButton_Left, callback=callback_camera_drag_rotate) + dpg.add_mouse_wheel_handler(callback=callback_camera_wheel_scale) + dpg.add_mouse_drag_handler(button=dpg.mvMouseButton_Right, callback=callback_camera_drag_pan) + + + dpg.create_viewport(title='torch-ngp', width=self.W, height=self.H, resizable=False) + + # TODO: seems dearpygui doesn't support resizing texture... + # def callback_resize(sender, app_data): + # self.W = app_data[0] + # self.H = app_data[1] + # # how to reload texture ??? + + # dpg.set_viewport_resize_callback(callback_resize) + + ### global theme + with dpg.theme() as theme_no_padding: + with dpg.theme_component(dpg.mvAll): + # set all padding to 0 to avoid scroll bar + dpg.add_theme_style(dpg.mvStyleVar_WindowPadding, 0, 0, category=dpg.mvThemeCat_Core) + dpg.add_theme_style(dpg.mvStyleVar_FramePadding, 0, 0, category=dpg.mvThemeCat_Core) + dpg.add_theme_style(dpg.mvStyleVar_CellPadding, 0, 0, category=dpg.mvThemeCat_Core) + + dpg.bind_item_theme("_primary_window", theme_no_padding) + + dpg.setup_dearpygui() + + #dpg.show_metrics() + + dpg.show_viewport() + + + def render(self): + + while dpg.is_dearpygui_running(): + # update texture every frame + if self.training: + self.train_step() + self.test_step() + dpg.render_dearpygui_frame() \ No newline at end of file diff --git a/nerf/network.py b/nerf/network.py new file mode 100644 index 0000000..685e8f9 --- /dev/null +++ b/nerf/network.py @@ -0,0 +1,238 @@ +import torch +import torch.nn as nn +import torch.nn.functional as F + +from activation import trunc_exp +from .renderer import NeRFRenderer + +import numpy as np +from encoding import get_encoder + +from .utils import safe_normalize +from tqdm import tqdm + + +class ResBlock(nn.Module): + def __init__(self, dim_in, dim_out, bias=True): + super().__init__() + self.dim_in = dim_in + self.dim_out = dim_out + + self.dense = nn.Linear(self.dim_in, self.dim_out, bias=bias) + self.norm = nn.LayerNorm(self.dim_out) + self.activation = nn.SiLU(inplace=True) + + if self.dim_in != self.dim_out: + self.skip = nn.Linear(self.dim_in, self.dim_out, bias=False) + else: + self.skip = None + + def forward(self, x): + # x: [B, C] + identity = x + + out = self.dense(x) + out = self.norm(out) + + if self.skip is not None: + identity = self.skip(identity) + + out += identity + out = self.activation(out) + + return out + +class BasicBlock(nn.Module): + def __init__(self, dim_in, dim_out, bias=True): + super().__init__() + self.dim_in = dim_in + self.dim_out = dim_out + + self.dense = nn.Linear(self.dim_in, self.dim_out, bias=bias) + self.activation = nn.ReLU(inplace=True) + + def forward(self, x): + # x: [B, C] + + out = self.dense(x) + out = self.activation(out) + + return out + +class MLP(nn.Module): + def __init__(self, dim_in, dim_out, dim_hidden, num_layers, bias=True, block=BasicBlock): + super().__init__() + self.dim_in = dim_in + self.dim_out = dim_out + self.dim_hidden = dim_hidden + self.num_layers = num_layers + + net = [] + for l in range(num_layers): + if l == 0: + net.append(BasicBlock(self.dim_in, self.dim_hidden, bias=bias)) + elif l != num_layers - 1: + net.append(block(self.dim_hidden, self.dim_hidden, bias=bias)) + else: + net.append(nn.Linear(self.dim_hidden, self.dim_out, bias=bias)) + + self.net = nn.ModuleList(net) + + def reset_parameters(self): + @torch.no_grad() + def weight_init(m): + if isinstance(m, nn.Linear): + nn.init.xavier_uniform_(m.weight, gain=nn.init.calculate_gain('relu')) + nn.init.zeros_(m.bias) + self.apply(weight_init) + + def forward(self, x): + + for l in range(self.num_layers): + x = self.net[l](x) + + return x + + +class NeRFNetwork(NeRFRenderer): + def __init__(self, + opt, + num_layers=5, # 5 in paper + hidden_dim=64, # 128 in paper + num_layers_bg=2, # 3 in paper + hidden_dim_bg=32, # 64 in paper + encoding='frequency_torch', # pure pytorch + output_dim=4, # 7 for DMTet (sdf 1 + color 3 + deform 3), 4 for NeRF + ): + + super().__init__(opt) + self.num_layers = opt.num_layers if hasattr(opt, 'num_layers') else num_layers + self.hidden_dim = opt.hidden_dim if hasattr(opt, 'hidden_dim') else hidden_dim + num_layers_bg = opt.num_layers_bg if hasattr(opt, 'num_layers_bg') else num_layers_bg + hidden_dim_bg = opt.hidden_dim_bg if hasattr(opt, 'hidden_dim_bg') else hidden_dim_bg + + self.encoder, self.in_dim = get_encoder(encoding, input_dim=3, multires=6) + self.sigma_net = MLP(self.in_dim, output_dim, hidden_dim, num_layers, bias=True, block=ResBlock) + + self.grid_levels_mask = 0 + + # background network + if self.opt.bg_radius > 0: + self.num_layers_bg = num_layers_bg + self.hidden_dim_bg = hidden_dim_bg + self.encoder_bg, self.in_dim_bg = get_encoder(encoding, input_dim=3, multires=4) + self.bg_net = MLP(self.in_dim_bg, 3, hidden_dim_bg, num_layers_bg, bias=True) + + else: + self.bg_net = None + + def common_forward(self, x): + # x: [N, 3], in [-bound, bound] + + # sigma + h = self.encoder(x, bound=self.bound, max_level=self.max_level) + + # Feature masking for coarse-to-fine training + if self.grid_levels_mask > 0: + h_mask: torch.Tensor = torch.arange(self.in_dim, device=h.device) < self.in_dim - self.grid_levels_mask * self.level_dim # (self.in_dim) + h_mask = h_mask.reshape(1, self.in_dim).float() # (1, self.in_dim) + h = h * h_mask # (N, self.in_dim) + + h = self.sigma_net(h) + + sigma = self.density_activation(h[..., 0] + self.density_blob(x)) + albedo = torch.sigmoid(h[..., 1:]) + + return sigma, albedo + + def normal(self, x): + + with torch.enable_grad(): + x.requires_grad_(True) + sigma, albedo = self.common_forward(x) + # query gradient + normal = - torch.autograd.grad(torch.sum(sigma), x, create_graph=True)[0] # [N, 3] + + # normal = self.finite_difference_normal(x) + normal = safe_normalize(normal) + # normal = torch.nan_to_num(normal) + + return normal + + def forward(self, x, d, l=None, ratio=1, shading='albedo'): + # x: [N, 3], in [-bound, bound] + # d: [N, 3], view direction, nomalized in [-1, 1] + # l: [3], plane light direction, nomalized in [-1, 1] + # ratio: scalar, ambient ratio, 1 == no shading (albedo only), 0 == only shading (textureless) + + if shading == 'albedo': + # no need to query normal + sigma, color = self.common_forward(x) + normal = None + + else: + # query normal + + # sigma, albedo = self.common_forward(x) + # normal = self.normal(x) + + with torch.enable_grad(): + x.requires_grad_(True) + sigma, albedo = self.common_forward(x) + # query gradient + normal = - torch.autograd.grad(torch.sum(sigma), x, create_graph=True)[0] # [N, 3] + normal = safe_normalize(normal) + # normal = torch.nan_to_num(normal) + # normal = normal.detach() + + # lambertian shading + lambertian = ratio + (1 - ratio) * (normal * l).sum(-1).clamp(min=0) # [N,] + + if shading == 'textureless': + color = lambertian.unsqueeze(-1).repeat(1, 3) + elif shading == 'normal': + color = (normal + 1) / 2 + else: # 'lambertian' + color = albedo * lambertian.unsqueeze(-1) + + return sigma, color, normal + + + def density(self, x): + # x: [N, 3], in [-bound, bound] + + sigma, albedo = self.common_forward(x) + + return { + 'sigma': sigma, + 'albedo': albedo, + } + + + def background(self, d): + + h = self.encoder_bg(d) # [N, C] + + h = self.bg_net(h) + + # sigmoid activation for rgb + rgbs = torch.sigmoid(h) + + return rgbs + + # optimizer utils + def get_params(self, lr): + + params = [ + # {'params': self.encoder.parameters(), 'lr': lr * 10}, + {'params': self.sigma_net.parameters(), 'lr': lr * self.opt.lr_scale_nerf}, + ] + + if self.opt.bg_radius > 0: + # params.append({'params': self.encoder_bg.parameters(), 'lr': lr * 10}) + params.append({'params': self.bg_net.parameters(), 'lr': lr}) + + if self.opt.dmtet: + params.append({'params': self.dmtet.parameters(), 'lr': lr}) + + return params \ No newline at end of file diff --git a/nerf/network_grid.py b/nerf/network_grid.py new file mode 100644 index 0000000..3ad56d1 --- /dev/null +++ b/nerf/network_grid.py @@ -0,0 +1,216 @@ +import torch +import torch.nn as nn +import torch.nn.functional as F + +from activation import trunc_exp, biased_softplus +from .renderer import NeRFRenderer, MLP + +import numpy as np +from encoding import get_encoder + +from .utils import safe_normalize +from tqdm import tqdm +import logging + + +logger = logging.getLogger(__name__) + + +class NeRFNetwork(NeRFRenderer): + def __init__(self, + opt, + num_layers=3, + hidden_dim=64, + num_layers_bg=2, + hidden_dim_bg=32, + level_dim=2 + ): + + super().__init__(opt) + + self.num_layers = opt.num_layers if hasattr(opt, 'num_layers') else num_layers + self.hidden_dim = opt.hidden_dim if hasattr(opt, 'hidden_dim') else hidden_dim + self.level_dim = opt.level_dim if hasattr(opt, 'level_dim') else level_dim + num_layers_bg = opt.num_layers_bg if hasattr(opt, 'num_layers_bg') else num_layers_bg + hidden_dim_bg = opt.hidden_dim_bg if hasattr(opt, 'hidden_dim_bg') else hidden_dim_bg + + if self.opt.grid_type == 'hashgrid': + self.encoder, self.in_dim = get_encoder('hashgrid', input_dim=3, log2_hashmap_size=19, desired_resolution=2048 * self.bound, interpolation='smoothstep') + elif self.opt.grid_type == 'tilegrid': + self.encoder, self.in_dim = get_encoder( + 'tiledgrid', + input_dim=3, + level_dim=self.level_dim, + log2_hashmap_size=16, + num_levels=16, + desired_resolution= 2048 * self.bound, + ) + self.sigma_net = MLP(self.in_dim, 4, hidden_dim, num_layers, bias=True) + # self.normal_net = MLP(self.in_dim, 3, hidden_dim, num_layers, bias=True) + + # masking + self.grid_levels_mask = 0 + + # background network + if self.opt.bg_radius > 0: + self.num_layers_bg = num_layers_bg + self.hidden_dim_bg = hidden_dim_bg + + # use a very simple network to avoid it learning the prompt... + self.encoder_bg, self.in_dim_bg = get_encoder('frequency', input_dim=3, multires=6) + self.bg_net = MLP(self.in_dim_bg, 3, hidden_dim_bg, num_layers_bg, bias=True) + + else: + self.bg_net = None + + def common_forward(self, x): + + # sigma + h = self.encoder(x, bound=self.bound, max_level=self.max_level) + + # Feature masking for coarse-to-fine training + if self.grid_levels_mask > 0: + h_mask: torch.Tensor = torch.arange(self.in_dim, device=h.device) < self.in_dim - self.grid_levels_mask * self.level_dim # (self.in_dim) + h_mask = h_mask.reshape(1, self.in_dim).float() # (1, self.in_dim) + h = h * h_mask # (N, self.in_dim) + + h = self.sigma_net(h) + + sigma = self.density_activation(h[..., 0] + self.density_blob(x)) + albedo = torch.sigmoid(h[..., 1:]) + + return sigma, albedo + + + def forward(self, x, d, l=None, ratio=1, shading='albedo'): + # x: [N, 3], in [-bound, bound] + # d: [N, 3], view direction, nomalized in [-1, 1] + # l: [3], plane light direction, nomalized in [-1, 1] + # ratio: scalar, ambient ratio, 1 == no shading (albedo only), 0 == only shading (textureless) + + sigma, albedo = self.common_forward(x) + + if shading == 'albedo': + normal = None + color = albedo + + else: # lambertian shading + + normal = self.normal(x) + if shading == 'normal': + color = (normal + 1) / 2 + else: + lambertian = ratio + (1 - ratio) * (normal * l).sum(-1).clamp(min=0) # [N,] + if shading == 'textureless': + color = lambertian.unsqueeze(-1).repeat(1, 3) + else: # 'lambertian' + color = albedo * lambertian.unsqueeze(-1) + + return sigma, color, normal + + + def density(self, x): + # x: [N, 3], in [-bound, bound] + + sigma, albedo = self.common_forward(x) + + return { + 'sigma': sigma, + 'albedo': albedo, + } + + + def background(self, d): + + h = self.encoder_bg(d) # [N, C] + + h = self.bg_net(h) + + # sigmoid activation for rgb + rgbs = torch.sigmoid(h) + + return rgbs + + # optimizer utils + def get_params(self, lr): + + params = [ + {'params': self.encoder.parameters(), 'lr': lr * 10}, + {'params': self.sigma_net.parameters(), 'lr': lr * self.opt.lr_scale_nerf}, + # {'params': self.normal_net.parameters(), 'lr': lr}, + ] + + if self.opt.bg_radius > 0: + # params.append({'params': self.encoder_bg.parameters(), 'lr': lr * 10}) + params.append({'params': self.bg_net.parameters(), 'lr': lr}) + + if self.opt.dmtet: + params.append({'params': self.dmtet.parameters(), 'lr': lr}) + + return params + + def reset_sigmanet(self): + self.sigma_net.reset_parameters() + + def init_nerf_from_sdf_color(self, rpst, albedo, + points=None, pretrain_iters=10000, lr=0.001, rpst_type='sdf', + ): + self.reset_sigmanet() + # matching optimization + self.train() + self.grid_levels_mask = 0 + loss_fn = torch.nn.MSELoss() + optimizer = torch.optim.Adam(list(self.parameters()), lr=lr) + + milestones = [int(0.4 * pretrain_iters), int(0.8 * pretrain_iters)] + scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones=milestones, gamma=0.1) + + rpst = rpst.squeeze().clamp(0, 1) + + # rpst = torch.ones_like(rpst) * 0.4 + pbar = tqdm(range(pretrain_iters), desc="NeRF sigma optimization") + rgb_loss = torch.tensor(0, device=rpst.device) + for i in pbar: + output = self.density(points) + if rpst_type == 'sdf': + pred_rpst = output['sigma'] - self.density_thresh + else: + pred_rpst = output['sigma'] + sdf_loss = loss_fn(pred_rpst, rpst) + + if albedo is not None: + pred_albedo = output['albedo'] + rgb_loss = loss_fn(pred_albedo, albedo) + loss = 10 * sdf_loss + rgb_loss + else: + loss = sdf_loss + + optimizer.zero_grad() + loss.backward() + optimizer.step() + scheduler.step() + pbar.set_postfix(loss=loss.item(), rgb_loss=rgb_loss.item(), sdf_loss=sdf_loss.item()) + logger.info(f'lr: {lr} Accuracy: (pred_rpst[rpst>0]>0).sum() / (rpst>0).sum()') + pbar = tqdm(range(pretrain_iters), desc="NeRF color optimization") + + + def init_tet_from_sdf_color(self, sdf, colors=None, pretrain_iters=5000, lr=0.01): + self.train() + self.grid_levels_mask = 0 + + self.dmtet.reset_tet(reset_scale=False) + self.dmtet.init_tet_from_sdf(sdf, pretrain_iters=pretrain_iters, lr=lr) + + if colors is not None: + self.reset_sigmanet() + loss_fn = torch.nn.MSELoss() + pretrain_iters = 5000 + optimizer = torch.optim.Adam(list(self.parameters()), lr=0.01) + pbar = tqdm(range(pretrain_iters), desc="NeRF color optimization") + for i in pbar: + pred_albedo = self.density(self.dmtet.verts)['albedo'] + loss = loss_fn(pred_albedo, colors) + optimizer.zero_grad() + loss.backward() + optimizer.step() + pbar.set_postfix(loss=loss.item()) diff --git a/nerf/network_grid_taichi.py b/nerf/network_grid_taichi.py new file mode 100644 index 0000000..586faff --- /dev/null +++ b/nerf/network_grid_taichi.py @@ -0,0 +1,161 @@ +import torch +import torch.nn as nn +import torch.nn.functional as F + +from activation import trunc_exp +from .renderer import NeRFRenderer + +import numpy as np +from encoding import get_encoder + +from .utils import safe_normalize +from tqdm import tqdm + + +class MLP(nn.Module): + def __init__(self, dim_in, dim_out, dim_hidden, num_layers, bias=True): + super().__init__() + self.dim_in = dim_in + self.dim_out = dim_out + self.dim_hidden = dim_hidden + self.num_layers = num_layers + + net = [] + for l in range(num_layers): + net.append(nn.Linear(self.dim_in if l == 0 else self.dim_hidden, self.dim_out if l == num_layers - 1 else self.dim_hidden, bias=bias)) + + self.net = nn.ModuleList(net) + + def forward(self, x): + for l in range(self.num_layers): + x = self.net[l](x) + if l != self.num_layers - 1: + x = F.relu(x, inplace=True) + return x + + def reset_parameters(self): + @torch.no_grad() + def weight_init(m): + if isinstance(m, nn.Linear): + nn.init.xavier_uniform_(m.weight, gain=nn.init.calculate_gain('relu')) + nn.init.zeros_(m.bias) + self.apply(weight_init) + + +class NeRFNetwork(NeRFRenderer): + def __init__(self, + opt, + num_layers=2, + hidden_dim=32, + num_layers_bg=2, + hidden_dim_bg=16, + ): + + super().__init__(opt) + self.num_layers = opt.num_layers if hasattr(opt, 'num_layers') else num_layers + self.hidden_dim = opt.hidden_dim if hasattr(opt, 'hidden_dim') else hidden_dim + num_layers_bg = opt.num_layers_bg if hasattr(opt, 'num_layers_bg') else num_layers_bg + hidden_dim_bg = opt.hidden_dim_bg if hasattr(opt, 'hidden_dim_bg') else hidden_dim_bg + + self.encoder, self.in_dim = get_encoder('hashgrid_taichi', input_dim=3, log2_hashmap_size=19, desired_resolution=2048 * self.bound, interpolation='smoothstep') + + self.sigma_net = MLP(self.in_dim, 4, hidden_dim, num_layers, bias=True) + # self.normal_net = MLP(self.in_dim, 3, hidden_dim, num_layers, bias=True) + + self.grid_levels_mask = 0 + + # background network + if self.opt.bg_radius > 0: + self.num_layers_bg = num_layers_bg + self.hidden_dim_bg = hidden_dim_bg + # use a very simple network to avoid it learning the prompt... + self.encoder_bg, self.in_dim_bg = get_encoder('frequency_torch', input_dim=3, multires=4) # TODO: freq encoder can be replaced by a Taichi implementation + self.bg_net = MLP(self.in_dim_bg, 3, hidden_dim_bg, num_layers_bg, bias=True) + + else: + self.bg_net = None + + def common_forward(self, x): + + # sigma + h = self.encoder(x, bound=self.bound) + + # Feature masking for coarse-to-fine training + if self.grid_levels_mask > 0: + h_mask: torch.Tensor = torch.arange(self.in_dim, device=h.device) < self.in_dim - self.grid_levels_mask * self.level_dim # (self.in_dim) + h_mask = h_mask.reshape(1, self.in_dim).float() # (1, self.in_dim) + h = h * h_mask # (N, self.in_dim) + + h = self.sigma_net(h) + + sigma = self.density_activation(h[..., 0] + self.density_blob(x)) + albedo = torch.sigmoid(h[..., 1:]) + + return sigma, albedo + + def forward(self, x, d, l=None, ratio=1, shading='albedo'): + # x: [N, 3], in [-bound, bound] + # d: [N, 3], view direction, nomalized in [-1, 1] + # l: [3], plane light direction, nomalized in [-1, 1] + # ratio: scalar, ambient ratio, 1 == no shading (albedo only), 0 == only shading (textureless) + + sigma, albedo = self.common_forward(x) + + if shading == 'albedo': + normal = None + color = albedo + + else: # lambertian shading + normal = self.normal(x) + + lambertian = ratio + (1 - ratio) * (normal * l).sum(-1).clamp(min=0) # [N,] + + if shading == 'textureless': + color = lambertian.unsqueeze(-1).repeat(1, 3) + elif shading == 'normal': + color = (normal + 1) / 2 + else: # 'lambertian' + color = albedo * lambertian.unsqueeze(-1) + + return sigma, color, normal + + + def density(self, x): + # x: [N, 3], in [-bound, bound] + + sigma, albedo = self.common_forward(x) + + return { + 'sigma': sigma, + 'albedo': albedo, + } + + + def background(self, d): + + h = self.encoder_bg(d) # [N, C] + + h = self.bg_net(h) + + # sigmoid activation for rgb + rgbs = torch.sigmoid(h) + + return rgbs + + # optimizer utils + def get_params(self, lr): + + params = [ + {'params': self.encoder.parameters(), 'lr': lr * 10}, + {'params': self.sigma_net.parameters(), 'lr': lr * self.opt.lr_scale_nerf}, + # {'params': self.normal_net.parameters(), 'lr': lr}, + ] + + if self.opt.bg_radius > 0: + # params.append({'params': self.encoder_bg.parameters(), 'lr': lr * 10}) + params.append({'params': self.bg_net.parameters(), 'lr': lr}) + + if self.opt.dmtet: + params.append({'params': self.dmtet.parameters(), 'lr': lr}) + + return params diff --git a/nerf/network_grid_tcnn.py b/nerf/network_grid_tcnn.py new file mode 100644 index 0000000..22ae1ff --- /dev/null +++ b/nerf/network_grid_tcnn.py @@ -0,0 +1,178 @@ +import torch +import torch.nn as nn +import torch.nn.functional as F + +from activation import trunc_exp, biased_softplus +from .renderer import NeRFRenderer + +import numpy as np +from encoding import get_encoder + +from .utils import safe_normalize + +import tinycudann as tcnn + +class MLP(nn.Module): + def __init__(self, dim_in, dim_out, dim_hidden, num_layers, bias=True): + super().__init__() + self.dim_in = dim_in + self.dim_out = dim_out + self.dim_hidden = dim_hidden + self.num_layers = num_layers + + net = [] + for l in range(num_layers): + net.append(nn.Linear(self.dim_in if l == 0 else self.dim_hidden, self.dim_out if l == num_layers - 1 else self.dim_hidden, bias=bias)) + + self.net = nn.ModuleList(net) + + def forward(self, x): + for l in range(self.num_layers): + x = self.net[l](x) + if l != self.num_layers - 1: + x = F.relu(x, inplace=True) + return x + + +class NeRFNetwork(NeRFRenderer): + def __init__(self, + opt, + num_layers=3, + hidden_dim=64, + num_layers_bg=2, + hidden_dim_bg=32, + ): + + super().__init__(opt) + + self.num_layers = num_layers + self.hidden_dim = hidden_dim + + self.encoder = tcnn.Encoding( + n_input_dims=3, + encoding_config={ + "otype": "HashGrid", + "n_levels": 16, + "n_features_per_level": 2, + "log2_hashmap_size": 19, + "base_resolution": 16, + "interpolation": "Smoothstep", + "per_level_scale": np.exp2(np.log2(2048 * self.bound / 16) / (16 - 1)), + }, + dtype=torch.float32, # ENHANCE: default float16 seems unstable... + ) + self.in_dim = self.encoder.n_output_dims + # use torch MLP, as tcnn MLP doesn't impl second-order derivative + self.sigma_net = MLP(self.in_dim, 4, hidden_dim, num_layers, bias=True) + + self.density_activation = trunc_exp if self.opt.density_activation == 'exp' else biased_softplus + + # background network + if self.opt.bg_radius > 0: + self.num_layers_bg = num_layers_bg + self.hidden_dim_bg = hidden_dim_bg + + # use a very simple network to avoid it learning the prompt... + self.encoder_bg, self.in_dim_bg = get_encoder('frequency', input_dim=3, multires=6) + self.bg_net = MLP(self.in_dim_bg, 3, hidden_dim_bg, num_layers_bg, bias=True) + + else: + self.bg_net = None + + def common_forward(self, x): + + # sigma + enc = self.encoder((x + self.bound) / (2 * self.bound)).float() + h = self.sigma_net(enc) + + sigma = self.density_activation(h[..., 0] + self.density_blob(x)) + albedo = torch.sigmoid(h[..., 1:]) + + return sigma, albedo + + def normal(self, x): + + with torch.enable_grad(): + with torch.cuda.amp.autocast(enabled=False): + x.requires_grad_(True) + sigma, albedo = self.common_forward(x) + # query gradient + normal = - torch.autograd.grad(torch.sum(sigma), x, create_graph=True)[0] # [N, 3] + + # normal = self.finite_difference_normal(x) + normal = safe_normalize(normal) + normal = torch.nan_to_num(normal) + + return normal + + def forward(self, x, d, l=None, ratio=1, shading='albedo'): + # x: [N, 3], in [-bound, bound] + # d: [N, 3], view direction, nomalized in [-1, 1] + # l: [3], plane light direction, nomalized in [-1, 1] + # ratio: scalar, ambient ratio, 1 == no shading (albedo only), 0 == only shading (textureless) + + + if shading == 'albedo': + sigma, albedo = self.common_forward(x) + normal = None + color = albedo + + else: # lambertian shading + with torch.enable_grad(): + with torch.cuda.amp.autocast(enabled=False): + x.requires_grad_(True) + sigma, albedo = self.common_forward(x) + normal = - torch.autograd.grad(torch.sum(sigma), x, create_graph=True)[0] # [N, 3] + normal = safe_normalize(normal) + normal = torch.nan_to_num(normal) + + lambertian = ratio + (1 - ratio) * (normal * l).sum(-1).clamp(min=0) # [N,] + + if shading == 'textureless': + color = lambertian.unsqueeze(-1).repeat(1, 3) + elif shading == 'normal': + color = (normal + 1) / 2 + else: # 'lambertian' + color = albedo * lambertian.unsqueeze(-1) + + return sigma, color, normal + + + def density(self, x): + # x: [N, 3], in [-bound, bound] + + sigma, albedo = self.common_forward(x) + + return { + 'sigma': sigma, + 'albedo': albedo, + } + + + def background(self, d): + + h = self.encoder_bg(d) # [N, C] + + h = self.bg_net(h) + + # sigmoid activation for rgb + rgbs = torch.sigmoid(h) + + return rgbs + + # optimizer utils + def get_params(self, lr): + + params = [ + {'params': self.encoder.parameters(), 'lr': lr * 10}, + {'params': self.sigma_net.parameters(), 'lr': lr}, + ] + + if self.opt.bg_radius > 0: + params.append({'params': self.bg_net.parameters(), 'lr': lr}) + + if self.opt.dmtet: + params.append({'params': self.sdf, 'lr': lr}) + params.append({'params': self.deform, 'lr': lr}) + + return params \ No newline at end of file diff --git a/nerf/provider.py b/nerf/provider.py new file mode 100644 index 0000000..219b6ec --- /dev/null +++ b/nerf/provider.py @@ -0,0 +1,329 @@ +import random +import numpy as np +from scipy.spatial.transform import Slerp, Rotation + + +import torch +import torch.nn.functional as F +from torch.utils.data import DataLoader + +from .utils import get_rays, safe_normalize + +DIR_COLORS = np.array([ + [255, 0, 0, 255], # front + [0, 255, 0, 255], # side + [0, 0, 255, 255], # back + [255, 255, 0, 255], # side + [255, 0, 255, 255], # overhead + [0, 255, 255, 255], # bottom +], dtype=np.uint8) + +def visualize_poses(poses, dirs, size=0.1): + # poses: [B, 4, 4], dirs: [B] + import trimesh + axes = trimesh.creation.axis(axis_length=4) + sphere = trimesh.creation.icosphere(radius=1) + objects = [axes, sphere] + + for pose, dir in zip(poses, dirs): + # a camera is visualized with 8 line segments. + pos = pose[:3, 3] + a = pos + size * pose[:3, 0] + size * pose[:3, 1] - size * pose[:3, 2] + b = pos - size * pose[:3, 0] + size * pose[:3, 1] - size * pose[:3, 2] + c = pos - size * pose[:3, 0] - size * pose[:3, 1] - size * pose[:3, 2] + d = pos + size * pose[:3, 0] - size * pose[:3, 1] - size * pose[:3, 2] + + segs = np.array([[pos, a], [pos, b], [pos, c], [pos, d], [a, b], [b, c], [c, d], [d, a]]) + segs = trimesh.load_path(segs) + + # different color for different dirs + segs.colors = DIR_COLORS[[dir]].repeat(len(segs.entities), 0) + + objects.append(segs) + + trimesh.Scene(objects).show() + +def get_view_direction(thetas, phis, overhead, front): + # phis [B,]; thetas: [B,] + # front = 0 [0, front) + # side (right) = 1 [front, 180) + # back = 2 [180, 180+front) + # side (left) = 3 [180+front, 360) + # top = 4 [0, overhead] + # bottom = 5 [180-overhead, 180] + res = torch.zeros(thetas.shape[0], dtype=torch.long) + # first determine by phis + phis = phis % (2 * np.pi) + res[(phis < front / 2) | (phis >= 2 * np.pi - front / 2)] = 0 + res[(phis >= front / 2) & (phis < np.pi - front / 2)] = 1 + res[(phis >= np.pi - front / 2) & (phis < np.pi + front / 2)] = 2 + res[(phis >= np.pi + front / 2) & (phis < 2 * np.pi - front / 2)] = 3 + # override by thetas + res[thetas <= overhead] = 4 + res[thetas >= (np.pi - overhead)] = 5 + return res + + +def rand_poses(size, device, opt, radius_range=[1, 1.5], theta_range=[0, 120], phi_range=[0, 360], return_dirs=False, angle_overhead=30, angle_front=60, uniform_sphere_rate=0.5): + ''' generate random poses from an orbit camera + Args: + size: batch size of generated poses. + device: where to allocate the output. + radius: camera radius + theta_range: [min, max], should be in [0, pi] + phi_range: [min, max], should be in [0, 2 * pi] + Return: + poses: [size, 4, 4] + ''' + + theta_range = np.array(theta_range) / 180 * np.pi + phi_range = np.array(phi_range) / 180 * np.pi + angle_overhead = angle_overhead / 180 * np.pi + angle_front = angle_front / 180 * np.pi + + radius = torch.rand(size, device=device) * (radius_range[1] - radius_range[0]) + radius_range[0] + + if random.random() < uniform_sphere_rate: + unit_centers = F.normalize( + torch.stack([ + (torch.rand(size, device=device) - 0.5) * 2.0, + torch.rand(size, device=device), + (torch.rand(size, device=device) - 0.5) * 2.0, + ], dim=-1), p=2, dim=1 + ) + thetas = torch.acos(unit_centers[:,1]) + phis = torch.atan2(unit_centers[:,0], unit_centers[:,2]) + phis[phis < 0] += 2 * np.pi + centers = unit_centers * radius.unsqueeze(-1) + else: + thetas = torch.rand(size, device=device) * (theta_range[1] - theta_range[0]) + theta_range[0] + phis = torch.rand(size, device=device) * (phi_range[1] - phi_range[0]) + phi_range[0] + phis[phis < 0] += 2 * np.pi + + centers = torch.stack([ + radius * torch.sin(thetas) * torch.sin(phis), + radius * torch.cos(thetas), + radius * torch.sin(thetas) * torch.cos(phis), + ], dim=-1) # [B, 3] + + targets = 0 + + # jitters + if opt.jitter_pose: + jit_center = opt.jitter_center # 0.015 # was 0.2 + jit_target = opt.jitter_target + centers += torch.rand_like(centers) * jit_center - jit_center/2.0 + targets += torch.randn_like(centers) * jit_target + + # lookat + forward_vector = safe_normalize(centers - targets) + up_vector = torch.FloatTensor([0, 1, 0]).to(device).unsqueeze(0).repeat(size, 1) + right_vector = safe_normalize(torch.cross(forward_vector, up_vector, dim=-1)) + + if opt.jitter_pose: + up_noise = torch.randn_like(up_vector) * opt.jitter_up + else: + up_noise = 0 + + up_vector = safe_normalize(torch.cross(right_vector, forward_vector, dim=-1) + up_noise) + + poses = torch.eye(4, dtype=torch.float, device=device).unsqueeze(0).repeat(size, 1, 1) + poses[:, :3, :3] = torch.stack((right_vector, up_vector, forward_vector), dim=-1) + poses[:, :3, 3] = centers + + if return_dirs: + dirs = get_view_direction(thetas, phis, angle_overhead, angle_front) + else: + dirs = None + + # back to degree + thetas = thetas / np.pi * 180 + phis = phis / np.pi * 180 + + return poses, dirs, thetas, phis, radius + + +def circle_poses(device, radius=torch.tensor([3.2]), theta=torch.tensor([60]), phi=torch.tensor([0]), return_dirs=False, angle_overhead=30, angle_front=60): + + theta = theta / 180 * np.pi + phi = phi / 180 * np.pi + angle_overhead = angle_overhead / 180 * np.pi + angle_front = angle_front / 180 * np.pi + + centers = torch.stack([ + radius * torch.sin(theta) * torch.sin(phi), + radius * torch.cos(theta), + radius * torch.sin(theta) * torch.cos(phi), + ], dim=-1) # [B, 3] + + # lookat + forward_vector = safe_normalize(centers) + up_vector = torch.FloatTensor([0, 1, 0]).to(device).unsqueeze(0).repeat(len(centers), 1) + right_vector = safe_normalize(torch.cross(forward_vector, up_vector, dim=-1)) + up_vector = safe_normalize(torch.cross(right_vector, forward_vector, dim=-1)) + + poses = torch.eye(4, dtype=torch.float, device=device).unsqueeze(0).repeat(len(centers), 1, 1) + poses[:, :3, :3] = torch.stack((right_vector, up_vector, forward_vector), dim=-1) + poses[:, :3, 3] = centers + + if return_dirs: + dirs = get_view_direction(theta, phi, angle_overhead, angle_front) + else: + dirs = None + + return poses, dirs + + +class NeRFDataset: + def __init__(self, opt, device, type='train', H=256, W=256, size=100): + super().__init__() + + self.opt = opt + self.device = device + self.type = type # train, val, test + + self.H = H + self.W = W + self.size = size + + self.training = self.type in ['train', 'all'] + + self.cx = self.H / 2 + self.cy = self.W / 2 + + self.near = self.opt.min_near + self.far = 1000 # infinite + + # [debug] visualize poses + # poses, dirs, _, _, _ = rand_poses(100, self.device, opt, radius_range=self.opt.radius_range, angle_overhead=self.opt.angle_overhead, angle_front=self.opt.angle_front, jitter=self.opt.jitter_pose, uniform_sphere_rate=1) + # visualize_poses(poses.detach().cpu().numpy(), dirs.detach().cpu().numpy()) + + def get_default_view_data(self): + + H = int(self.opt.known_view_scale * self.H) + W = int(self.opt.known_view_scale * self.W) + cx = H / 2 + cy = W / 2 + + radii = torch.FloatTensor(self.opt.ref_radii).to(self.device) + thetas = torch.FloatTensor(self.opt.ref_polars).to(self.device) + phis = torch.FloatTensor(self.opt.ref_azimuths).to(self.device) + poses, dirs = circle_poses(self.device, radius=radii, theta=thetas, phi=phis, return_dirs=True, angle_overhead=self.opt.angle_overhead, angle_front=self.opt.angle_front) + fov = self.opt.default_fovy + focal = H / (2 * np.tan(np.deg2rad(fov) / 2)) + intrinsics = np.array([focal, focal, cx, cy]) + + projection = torch.tensor([ + [2*focal/W, 0, 0, 0], + [0, -2*focal/H, 0, 0], + [0, 0, -(self.far+self.near)/(self.far-self.near), -(2*self.far*self.near)/(self.far-self.near)], + [0, 0, -1, 0] + ], dtype=torch.float32, device=self.device).unsqueeze(0).repeat(len(radii), 1, 1) + + mvp = projection @ torch.inverse(poses) # [B, 4, 4] + + # sample a low-resolution but full image + rays = get_rays(poses, intrinsics, H, W, -1) + + data = { + 'H': H, + 'W': W, + 'rays_o': rays['rays_o'], + 'rays_d': rays['rays_d'], + 'dir': dirs, + 'mvp': mvp, + 'polar': self.opt.ref_polars, + 'azimuth': self.opt.ref_azimuths, + 'radius': self.opt.ref_radii, + } + + return data + + def collate(self, index): + + B = len(index) + + if self.training: + # random pose on the fly + poses, dirs, thetas, phis, radius = rand_poses(B, self.device, self.opt, radius_range=self.opt.radius_range, theta_range=self.opt.theta_range, phi_range=self.opt.phi_range, return_dirs=True, angle_overhead=self.opt.angle_overhead, angle_front=self.opt.angle_front, uniform_sphere_rate=self.opt.uniform_sphere_rate) + + # random focal + fov = random.random() * (self.opt.fovy_range[1] - self.opt.fovy_range[0]) + self.opt.fovy_range[0] + + elif self.type == 'six_views': + # six views + thetas_six = [90]*4 + [1e-6] + [180] + phis_six = [0, 90, 180, -90, 0, 0] + thetas = torch.FloatTensor([thetas_six[index[0]]]).to(self.device) + phis = torch.FloatTensor([phis_six[index[0]]]).to(self.device) + radius = torch.FloatTensor([self.opt.default_radius]).to(self.device) + poses, dirs = circle_poses(self.device, radius=radius, theta=thetas, phi=phis, return_dirs=True, angle_overhead=self.opt.angle_overhead, angle_front=self.opt.angle_front) + + # fixed focal + fov = self.opt.default_fovy + + else: + # circle pose + thetas = torch.FloatTensor([self.opt.default_polar]).to(self.device) + phis = torch.FloatTensor([(index[0] / self.size) * 360]).to(self.device) + radius = torch.FloatTensor([self.opt.default_radius]).to(self.device) + poses, dirs = circle_poses(self.device, radius=radius, theta=thetas, phi=phis, return_dirs=True, angle_overhead=self.opt.angle_overhead, angle_front=self.opt.angle_front) + + # fixed focal + fov = self.opt.default_fovy + + focal = self.H / (2 * np.tan(np.deg2rad(fov) / 2)) + intrinsics = np.array([focal, focal, self.cx, self.cy]) + + projection = torch.tensor([ + [2*focal/self.W, 0, 0, 0], + [0, -2*focal/self.H, 0, 0], + [0, 0, -(self.far+self.near)/(self.far-self.near), -(2*self.far*self.near)/(self.far-self.near)], + [0, 0, -1, 0] + ], dtype=torch.float32, device=self.device).unsqueeze(0) + + mvp = projection @ torch.inverse(poses) # [1, 4, 4] + + # sample a low-resolution but full image + rays = get_rays(poses, intrinsics, self.H, self.W, -1) + + # delta polar/azimuth/radius to default view + delta_polar = thetas - self.opt.default_polar + delta_azimuth = phis - self.opt.default_azimuth + delta_azimuth[delta_azimuth > 180] -= 360 # range in [-180, 180] + delta_radius = radius - self.opt.default_radius + + data = { + 'H': self.H, + 'W': self.W, + 'rays_o': rays['rays_o'], + 'rays_d': rays['rays_d'], + 'dir': dirs, + 'mvp': mvp, + 'polar': delta_polar, + 'azimuth': delta_azimuth, + 'radius': delta_radius, + } + + return data + + def dataloader(self, batch_size=None): + batch_size = batch_size or self.opt.batch_size + loader = DataLoader(list(range(self.size)), batch_size=batch_size, collate_fn=self.collate, shuffle=self.training, num_workers=0) + loader._data = self + return loader + + +def generate_grid_points(resolution=128, device='cuda'): + # resolution: number of points along each dimension + # Generate the grid points + x = torch.linspace(0, 1, resolution) + y = torch.linspace(0, 1, resolution) + z = torch.linspace(0, 1, resolution) + # Create the meshgrid + grid_x, grid_y, grid_z = torch.meshgrid(x, y, z) + + # Flatten the grid points if needed + grid_points = torch.stack((grid_x.flatten(), grid_y.flatten(), grid_z.flatten()), dim=1).to(device) + return grid_points + diff --git a/nerf/renderer.py b/nerf/renderer.py new file mode 100644 index 0000000..1fb9475 --- /dev/null +++ b/nerf/renderer.py @@ -0,0 +1,1575 @@ +import os +import math +import cv2 +import numpy as np +from tqdm import tqdm + +import torch +import torch.nn as nn +import torch.nn.functional as F + +from encoding import get_encoder +import nvdiffrast.torch as dr + +import mcubes +import raymarching +from .utils import custom_meshgrid, safe_normalize +import logging +from activation import trunc_exp, biased_softplus + + +logger = logging.getLogger(__name__) + + +class MLP(nn.Module): + def __init__(self, dim_in, dim_out, dim_hidden, num_layers, bias=True): + super().__init__() + self.dim_in = dim_in + self.dim_out = dim_out + self.dim_hidden = dim_hidden + self.num_layers = num_layers + + net = [] + for l in range(num_layers): + net.append(nn.Linear(self.dim_in if l == 0 else self.dim_hidden, + self.dim_out if l == num_layers - 1 else self.dim_hidden, bias=bias)) + + self.net = nn.ModuleList(net) + + def forward(self, x): + for l in range(self.num_layers): + x = self.net[l](x) + if l != self.num_layers - 1: + x = F.relu(x, inplace=True) + return x + + def reset_parameters(self): + @torch.no_grad() + def weight_init(m): + if isinstance(m, nn.Linear): + nn.init.xavier_uniform_( + m.weight, gain=nn.init.calculate_gain('relu')) + if m.bias is not None: + nn.init.zeros_(m.bias) + self.apply(weight_init) + + +def sample_pdf(bins, weights, n_samples, det=False): + # This implementation is from NeRF + # bins: [B, T], old_z_vals + # weights: [B, T - 1], bin weights. + # return: [B, n_samples], new_z_vals + + # Get pdf + weights = weights + 1e-5 # prevent nans + pdf = weights / torch.sum(weights, -1, keepdim=True) + cdf = torch.cumsum(pdf, -1) + cdf = torch.cat([torch.zeros_like(cdf[..., :1]), cdf], -1) + # Take uniform samples + if det: + u = torch.linspace(0. + 0.5 / n_samples, 1. - 0.5 / n_samples, steps=n_samples).to(weights.device) + u = u.expand(list(cdf.shape[:-1]) + [n_samples]) + else: + u = torch.rand(list(cdf.shape[:-1]) + [n_samples]).to(weights.device) + + # Invert CDF + u = u.contiguous() + inds = torch.searchsorted(cdf, u, right=True) + below = torch.max(torch.zeros_like(inds - 1), inds - 1) + above = torch.min((cdf.shape[-1] - 1) * torch.ones_like(inds), inds) + inds_g = torch.stack([below, above], -1) # (B, n_samples, 2) + + matched_shape = [inds_g.shape[0], inds_g.shape[1], cdf.shape[-1]] + cdf_g = torch.gather(cdf.unsqueeze(1).expand(matched_shape), 2, inds_g) + bins_g = torch.gather(bins.unsqueeze(1).expand(matched_shape), 2, inds_g) + + denom = (cdf_g[..., 1] - cdf_g[..., 0]) + denom = torch.where(denom < 1e-5, torch.ones_like(denom), denom) + t = (u - cdf_g[..., 0]) / denom + samples = bins_g[..., 0] + t * (bins_g[..., 1] - bins_g[..., 0]) + + return samples + +@torch.cuda.amp.autocast(enabled=False) +def near_far_from_bound(rays_o, rays_d, bound, type='cube', min_near=0.05): + # rays: [B, N, 3], [B, N, 3] + # bound: int, radius for ball or half-edge-length for cube + # return near [B, N, 1], far [B, N, 1] + + radius = rays_o.norm(dim=-1, keepdim=True) + + if type == 'sphere': + near = radius - bound # [B, N, 1] + far = radius + bound + + elif type == 'cube': + tmin = (-bound - rays_o) / (rays_d + 1e-15) # [B, N, 3] + tmax = (bound - rays_o) / (rays_d + 1e-15) + near = torch.where(tmin < tmax, tmin, tmax).max(dim=-1, keepdim=True)[0] + far = torch.where(tmin > tmax, tmin, tmax).min(dim=-1, keepdim=True)[0] + # if far < near, means no intersection, set both near and far to inf (1e9 here) + mask = far < near + near[mask] = 1e9 + far[mask] = 1e9 + # restrict near to a minimal value + near = torch.clamp(near, min=min_near) + + return near, far + + +def plot_pointcloud(pc, color=None): + import trimesh + # pc: [N, 3] + # color: [N, 3/4] + logger.info('[visualize points]', pc.shape, pc.dtype, pc.min(0), pc.max(0)) + pc = trimesh.PointCloud(pc, color) + # axis + axes = trimesh.creation.axis(axis_length=4) + # sphere + sphere = trimesh.creation.icosphere(radius=1) + trimesh.Scene([pc, axes, sphere]).show() + + +class DMTet: + def __init__(self, device='cuda'): + self.device = device + self.triangle_table = torch.tensor([ + [-1, -1, -1, -1, -1, -1], + [1, 0, 2, -1, -1, -1], + [4, 0, 3, -1, -1, -1], + [1, 4, 2, 1, 3, 4], + [3, 1, 5, -1, -1, -1], + [2, 3, 0, 2, 5, 3], + [1, 4, 0, 1, 5, 4], + [4, 2, 5, -1, -1, -1], + [4, 5, 2, -1, -1, -1], + [4, 1, 0, 4, 5, 1], + [3, 2, 0, 3, 5, 2], + [1, 3, 5, -1, -1, -1], + [4, 1, 2, 4, 3, 1], + [3, 0, 4, -1, -1, -1], + [2, 0, 1, -1, -1, -1], + [-1, -1, -1, -1, -1, -1] + ], dtype=torch.long, device=self.device) + + self.num_triangles_table = torch.tensor( + [0, 1, 1, 2, 1, 2, 2, 1, 1, 2, 2, 1, 2, 1, 1, 0], dtype=torch.long, device=self.device) + self.base_tet_edges = torch.tensor( + [0, 1, 0, 2, 0, 3, 1, 2, 1, 3, 2, 3], dtype=torch.long, device=self.device) + + ############################################################################### + # Utility functions + ############################################################################### + + def sort_edges(self, edges_ex2): + with torch.no_grad(): + order = (edges_ex2[:, 0] > edges_ex2[:, 1]).long() + order = order.unsqueeze(dim=1) + + a = torch.gather(input=edges_ex2, index=order, dim=1) + b = torch.gather(input=edges_ex2, index=1-order, dim=1) + + return torch.stack([a, b], -1) + + def map_uv(self, faces, face_gidx, max_idx): + N = int(np.ceil(np.sqrt((max_idx+1)//2))) + tex_y, tex_x = torch.meshgrid( + torch.linspace(0, 1 - (1 / N), N, + dtype=torch.float32, device=self.device), + torch.linspace(0, 1 - (1 / N), N, + dtype=torch.float32, device=self.device), + ) # indexing='ij') + + pad = 0.9 / N + + uvs = torch.stack([ + tex_x, tex_y, + tex_x + pad, tex_y, + tex_x + pad, tex_y + pad, + tex_x, tex_y + pad + ], dim=-1).view(-1, 2) + + def _idx(tet_idx, N): + x = tet_idx % N + y = torch.div(tet_idx, N, rounding_mode='trunc') + return y * N + x + + tet_idx = _idx(torch.div(face_gidx, 2, rounding_mode='trunc'), N) + tri_idx = face_gidx % 2 + + uv_idx = torch.stack(( + tet_idx * 4, tet_idx * 4 + tri_idx + 1, tet_idx * 4 + tri_idx + 2 + ), dim=-1). view(-1, 3) + + return uvs, uv_idx + + ############################################################################### + # Marching tets implementation + ############################################################################### + + def __call__(self, pos_nx3, sdf_n, tet_fx4, return_uv=True): + # pos_nx3: [N, 3] + # sdf_n: [N] + # tet_fx4: [F, 4] + + with torch.no_grad(): + occ_n = sdf_n > 0 + occ_fx4 = occ_n[tet_fx4.reshape(-1)].reshape(-1, 4) + occ_sum = torch.sum(occ_fx4, -1) # [F,] + + # a valid tets not all positive (out space) and not all negative (inner) + valid_tets = (occ_sum > 0) & (occ_sum < 4) + occ_sum = occ_sum[valid_tets] + + # find all vertices + all_edges = tet_fx4[valid_tets][:, + self.base_tet_edges].reshape(-1, 2) + all_edges = self.sort_edges(all_edges) + unique_edges, idx_map = torch.unique( + all_edges, dim=0, return_inverse=True) + + # find out the edges across the surface to interpolate and refine + unique_edges = unique_edges.long() + mask_edges = occ_n[unique_edges.reshape(-1) + ].reshape(-1, 2).sum(-1) == 1 + mapping = torch.ones( + (unique_edges.shape[0]), dtype=torch.long, device=self.device) * -1 + mapping[mask_edges] = torch.arange( + mask_edges.sum(), dtype=torch.long, device=self.device) + idx_map = mapping[idx_map] # map edges to verts + + interp_v = unique_edges[mask_edges] + edges_to_interp = pos_nx3[interp_v.reshape(-1)].reshape(-1, 2, 3) + edges_to_interp_sdf = sdf_n[interp_v.reshape(-1)].reshape(-1, 2, 1) + edges_to_interp_sdf[:, -1] *= -1 + denominator = edges_to_interp_sdf.sum(1, keepdim=True) + edges_to_interp_sdf = torch.flip(edges_to_interp_sdf, [1])/denominator + + # interpolate edges by sdf + verts = (edges_to_interp * edges_to_interp_sdf).sum(1) + + idx_map = idx_map.reshape(-1, 6) + + v_id = torch.pow(2, torch.arange( + 4, dtype=torch.long, device=self.device)) + tetindex = (occ_fx4[valid_tets] * v_id.unsqueeze(0)).sum(-1) + num_triangles = self.num_triangles_table[tetindex] + + # Generate triangle indices + faces = torch.cat(( + torch.gather(input=idx_map[num_triangles == 1], dim=1, + index=self.triangle_table[tetindex[num_triangles == 1]][:, :3]).reshape(-1, 3), + torch.gather(input=idx_map[num_triangles == 2], dim=1, + index=self.triangle_table[tetindex[num_triangles == 2]][:, :6]).reshape(-1, 3), + ), dim=0) + + if return_uv: + # Get global face index (static, does not depend on topology) + num_tets = tet_fx4.shape[0] + tet_gidx = torch.arange(num_tets, dtype=torch.long, device=self.device)[ + valid_tets] + face_gidx = torch.cat(( + tet_gidx[num_triangles == 1]*2, + torch.stack( + (tet_gidx[num_triangles == 2]*2, tet_gidx[num_triangles == 2]*2 + 1), dim=-1).view(-1) + ), dim=0) + + uvs, uv_idx = self.map_uv(faces, face_gidx, num_tets*2) + else: + uvs, uv_idx = None, None + return verts, faces, uvs, uv_idx + +############################################################################### +# Regularizer +############################################################################### + + +def sdf_reg_loss(sdf, all_edges): + sdf_f1x6x2 = sdf[all_edges.reshape(-1)].reshape(-1, 2) + mask = torch.sign(sdf_f1x6x2[..., 0]) != torch.sign(sdf_f1x6x2[..., 1]) + sdf_f1x6x2 = sdf_f1x6x2[mask] + sdf_diff = torch.nn.functional.binary_cross_entropy_with_logits(sdf_f1x6x2[..., 0], (sdf_f1x6x2[..., 1] > 0).float()) + \ + torch.nn.functional.binary_cross_entropy_with_logits( + sdf_f1x6x2[..., 1], (sdf_f1x6x2[..., 0] > 0).float()) + return sdf_diff + +############################################################################### +# Geometry interface +############################################################################### + + +class DMTetGeometry(torch.nn.Module): + def __init__(self, grid_res, tet_mlp, opt, device='cuda'): + super(DMTetGeometry, self).__init__() + + self.opt = opt + self.device = device + self.tet_scale = torch.ones(3, device=device) + self.grid_res = grid_res + self.marching_tets = DMTet() + + tets = np.load('data/tets/{}_tets.npz'.format(self.grid_res)) + # for 64/128, [N=36562/277410, 3], in [-0.5, 0.5]^3 + self.verts = torch.tensor( + tets['vertices'], dtype=torch.float32, device=self.device) * 2 + # for 64/128, [M=192492/1524684, 4], vert indices for each tetrahetron + self.indices = torch.tensor( + tets['indices'], dtype=torch.long, device=self.device) + self.generate_edges() + + self.tet_mlp = tet_mlp + if tet_mlp: + self.encoder, self.in_dim = get_encoder('hashgrid', input_dim=3) + self.encoder = self.encoder.to(device) + self.mlp = MLP(self.in_dim, 4, 32, 3, False).to(device) + self.sdf = None + else: + sdf = torch.nn.Parameter(torch.zeros_like( + self.verts[..., 0]), requires_grad=True) + self.register_parameter('sdf', sdf) + deform = torch.nn.Parameter( + torch.zeros_like(self.verts), requires_grad=True) + self.register_parameter('deform', deform) + + if opt.base_mesh and os.path.exists(opt.base_mesh): + self.init_tet_from_mesh(opt.base_mesh) + + def reset_tet(self, reset_scale=True): + if self.tet_mlp: + self.mlp.reset_parameters() + else: + self.sdf.data = torch.zeros_like(self.verts[..., 0]) + self.deform.data = torch.zeros_like(self.verts) + if reset_scale: + self.reset_tet_scale() + + def get_sdf_from_mesh(self, base_mesh): + logger.info(f'[INFO] init sdf from base mesh: {base_mesh}') + + import cubvh + import trimesh + mesh = trimesh.load(base_mesh, force='mesh') + + scale = 1.5 / np.array(mesh.bounds[1] - mesh.bounds[0]).max() + center = np.array(mesh.bounds[1] + mesh.bounds[0]) / 2 + mesh.vertices = (mesh.vertices - center) * scale + + # build with numpy.ndarray/torch.Tensor + BVH = cubvh.cuBVH(mesh.vertices, mesh.faces) + sdf, face_id, _ = BVH.signed_distance( + self.verts, return_uvw=False, mode='watertight') + sdf *= -1 # INNER is POSITIVE + return sdf + + def init_tet_from_mesh(self, base_mesh): + sdf = self.get_sdf_from_mesh(base_mesh) + self.init_tet_from_sdf(sdf) + # visualize + # sdf_np_gt = sdf.cpu().numpy() + # sdf_np = self.mlp(self.encoder(self.verts)).detach().cpu().numpy()[..., 0] + # verts_np = self.verts.cpu().numpy() + # color = np.zeros_like(verts_np) + # color[sdf_np < 0] = [1, 0, 0] + # color[sdf_np > 0] = [0, 0, 1] + # color = (color * 255).astype(np.uint8) + # pc = trimesh.PointCloud(verts_np, color) + # axes = trimesh.creation.axis(axis_length=4) + # box = trimesh.primitives.Box(extents=(2, 2, 2)).as_outline() + # trimesh.Scene([mesh, pc, axes, box]).show() + + def init_tet_from_sdf(self, sdf, pretrain_iters=5000, lr=1e-3): + if self.tet_mlp: + self.mlp.reset_parameters() + # pretraining + loss_fn = torch.nn.MSELoss() + optimizer = torch.optim.Adam(list(self.parameters()), lr=lr) + + #batch_size = min(10240, self.verts.shape[0]) + batch_size = self.verts.shape[0] + pbar = tqdm(range(pretrain_iters), desc="init dmtet mlp from sdf") + for i in pbar: + rand_idx = torch.randint(0, self.verts.shape[0], (batch_size,)) + p = self.verts[rand_idx] + ref_value = sdf[rand_idx] + output = self.mlp(self.encoder(p)) + loss = loss_fn(output[..., 0], ref_value) + optimizer.zero_grad() + loss.backward() + optimizer.step() + pbar.set_postfix(loss=loss.item()) + else: + self.sdf.data = sdf.squeeze() + + @torch.no_grad() + def reset_tet_scale(self, tet_scale=1.): + if isinstance(tet_scale, float): + tet_scale = torch.ones(3, device=self.device) * tet_scale + self.tet_scale = tet_scale + self.verts = self.verts * tet_scale + + @torch.no_grad() + def generate_edges(self): + # six edges for each tetrahedron. + edges = torch.tensor([0, 1, 0, 2, 0, 3, 1, 2, 1, 3, 2, 3], + dtype=torch.long, device=self.device) + all_edges = self.indices[:, edges].reshape(-1, 2) # [M * 6, 2] + all_edges_sorted = torch.sort(all_edges, dim=1)[0] + self.all_edges = torch.unique(all_edges_sorted, dim=0) + + def get_sdf_deform(self): + if self.tet_mlp: + # predict SDF and per-vertex deformation + pred = self.mlp(self.encoder(self.verts)) + sdf, deform = pred[:, 0], pred[:, 1:] + return sdf, torch.tanh(deform) / (self.grid_res) + else: + return self.sdf, torch.tanh(self.deform) / (self.grid_res) + + def get_verts_face(self): + sdf, deform = self.get_sdf_deform() + verts, faces, _, _ = self.marching_tets( + self.verts + deform, sdf, self.indices, return_uv=False) + return verts, faces + + # def getAABB(self): + # return torch.min(self.verts, dim=0).values, torch.max(self.verts, dim=0).values + + # def getMesh(self, material): + + # pred = self.mlp(self.encoder(self.verts)) # predict SDF and per-vertex deformation + # sdf, deform = pred[:, 0], pred[:, 1:] + + # v_deformed = self.verts + torch.tanh(deform) / (self.grid_res) + + # verts, faces, uvs, uv_idx = self.marching_tets(v_deformed, sdf, self.indices) + + # imesh = mesh.Mesh(verts, faces, v_tex=uvs, t_tex_idx=uv_idx, material=material) + + # # Run mesh operations to generate tangent space + # imesh = mesh.auto_normals(imesh) + # imesh = mesh.compute_tangents(imesh) + + # return imesh, sdf + + # def render(self, glctx, target, lgt, opt_material, bsdf=None): + + # # return rendered buffers, keys: ['shaded', 'kd_grad', 'occlusion']. + # opt_mesh, sdf = self.getMesh(opt_material) + # buffers = render.render_mesh(glctx, opt_mesh, target['mvp'], target['campos'], lgt, target['resolution'], spp=target['spp'], + # msaa=True, background=None, bsdf=bsdf) + # buffers['mesh'] = opt_mesh + # buffers['sdf'] = sdf + + # return buffers + + # def tick(self, glctx, target, lgt, opt_material, loss_fn, guidance_model, text_z, iteration): + + # # ============================================================================================== + # # Render optimizable object with identical conditions + # # ============================================================================================== + # buffers = self.render(glctx, target, lgt, opt_material) + + # mesh = buffers['mesh'] + + # # ============================================================================================== + # # Compute loss + # # ============================================================================================== + # t_iter = iteration / self.opt.iter + + # if iteration < int(self.opt.iter * 0.2): + # # mode = 'normal_latent' + # pred_rgb = buffers['normal'][..., 0:4].permute(0, 3, 1, 2).contiguous() + # as_latent = True + # elif iteration < int(self.opt.iter * 0.6): + # # mode = 'normal' + # pred_rgb = buffers['normal'][..., 0:3].permute(0, 3, 1, 2).contiguous() + # as_latent = False + # else: + # # mode = 'rgb' + # pred_rgb = buffers['shaded'][..., 0:3].permute(0, 3, 1, 2).contiguous() + # pred_ws = buffers['shaded'][..., 3].unsqueeze(1) # [B, 1, H, W] + # pred_rgb = pred_rgb * pred_ws + (1 - pred_ws) * 1 # white bg + # as_latent = False + + # # torch_vis_2d(pred_rgb[0]) + # # torch_vis_2d(pred_normal[0]) + # # torch_vis_2d(pred_ws[0]) + + # if self.opt.directional_text: + # all_pos = [] + # all_neg = [] + # for emb in text_z[target['direction']]: # list of [2, S, -1] + # pos, neg = emb.chunk(2) # [1, S, -1] + # all_pos.append(pos) + # all_neg.append(neg) + # text_embedding = torch.cat(all_pos + all_neg, dim=0) # [2b, S, -1] + # else: + # text_embedding = text_z + + # img_loss = guidance_model.train_step(text_embedding, pred_rgb.half(), as_latent=as_latent) + + # # img_loss = torch.tensor(0.0, device = self.device) + + # # below are lots of regularizations... + # reg_loss = torch.tensor(0.0, device = self.device) + + # if iteration < int(self.opt.iter * 0.6): + # # SDF regularizer + # sdf_weight = self.opt.sdf_regularizer - (self.opt.sdf_regularizer - 0.01) * min(1.0, 4.0 * t_iter) + # sdf_loss = sdf_reg_loss(buffers['sdf'], self.all_edges).mean() * sdf_weight # Dropoff to 0.01 + # reg_loss = reg_loss + sdf_loss + + # # directly regularize mesh smoothness in finetuning... + # if iteration > int(self.opt.iter * 0.2): + # lap_loss = regularizer.laplace_regularizer_const(mesh.v_pos, mesh.t_pos_idx) * self.opt.laplace_scale #* min(1.0, iteration / 500) + # reg_loss = reg_loss + lap_loss + + # # normal_loss = regularizer.normal_consistency(mesh.v_pos, mesh.t_pos_idx) * self.opt.laplace_scale * min(1.0, iteration / 500) + # # reg_loss = reg_loss + normal_loss + + # else: + # # Albedo (k_d) smoothnesss regularizer + # # reg_loss += torch.mean(buffers['kd_grad'][..., :-1] * buffers['kd_grad'][..., -1:]) * 0.03 * min(1.0, (iteration - int(self.opt.iter * 0.6)) / 500) + + # # # Visibility regularizer + # # reg_loss += torch.mean(buffers['occlusion'][..., :-1] * buffers['occlusion'][..., -1:]) * 0.001 * min(1.0, (iteration - int(self.opt.iter * 0.6)) / 500) + + # # # Light white balance regularizer + # reg_loss += lgt.regularizer() * 0.005 + + # return img_loss, reg_loss + + +def compute_edge_to_face_mapping(attr_idx): + with torch.no_grad(): + # Get unique edges + # Create all edges, packed by triangle + all_edges = torch.cat(( + torch.stack((attr_idx[:, 0], attr_idx[:, 1]), dim=-1), + torch.stack((attr_idx[:, 1], attr_idx[:, 2]), dim=-1), + torch.stack((attr_idx[:, 2], attr_idx[:, 0]), dim=-1), + ), dim=-1).view(-1, 2) + + # Swap edge order so min index is always first + order = (all_edges[:, 0] > all_edges[:, 1]).long().unsqueeze(dim=1) + sorted_edges = torch.cat(( + torch.gather(all_edges, 1, order), + torch.gather(all_edges, 1, 1 - order) + ), dim=-1) + + # Elliminate duplicates and return inverse mapping + unique_edges, idx_map = torch.unique( + sorted_edges, dim=0, return_inverse=True) + + tris = torch.arange(attr_idx.shape[0]).repeat_interleave(3).cuda() + + tris_per_edge = torch.zeros( + (unique_edges.shape[0], 2), dtype=torch.int64).cuda() + + # Compute edge to face table + mask0 = order[:, 0] == 0 + mask1 = order[:, 0] == 1 + tris_per_edge[idx_map[mask0], 0] = tris[mask0] + tris_per_edge[idx_map[mask1], 1] = tris[mask1] + + return tris_per_edge + + +@torch.cuda.amp.autocast(enabled=False) +def normal_consistency(face_normals, t_pos_idx): + + tris_per_edge = compute_edge_to_face_mapping(t_pos_idx) + + # Fetch normals for both faces sharind an edge + n0 = face_normals[tris_per_edge[:, 0], :] + n1 = face_normals[tris_per_edge[:, 1], :] + + # Compute error metric based on normal difference + term = torch.clamp(torch.sum(n0 * n1, -1, keepdim=True), min=-1.0, max=1.0) + term = (1.0 - term) + + return torch.mean(torch.abs(term)) + + +def laplacian_uniform(verts, faces): + + V = verts.shape[0] + F = faces.shape[0] + + # Neighbor indices + ii = faces[:, [1, 2, 0]].flatten() + jj = faces[:, [2, 0, 1]].flatten() + adj = torch.stack( + [torch.cat([ii, jj]), torch.cat([jj, ii])], dim=0).unique(dim=1) + adj_values = torch.ones( + adj.shape[1], device=verts.device, dtype=torch.float) + + # Diagonal indices + diag_idx = adj[0] + + # Build the sparse matrix + idx = torch.cat((adj, torch.stack((diag_idx, diag_idx), dim=0)), dim=1) + values = torch.cat((-adj_values, adj_values)) + + # The coalesce operation sums the duplicate indices, resulting in the + # correct diagonal + return torch.sparse_coo_tensor(idx, values, (V, V)).coalesce() + + +@torch.cuda.amp.autocast(enabled=False) +def laplacian_smooth_loss(verts, faces): + with torch.no_grad(): + L = laplacian_uniform(verts, faces.long()) + loss = L.mm(verts) + loss = loss.norm(dim=1) + loss = loss.mean() + return loss + + +class NeRFRenderer(nn.Module): + def __init__(self, opt): + super().__init__() + + self.opt = opt + self.bound = opt.bound + self.cascade = 1 + math.ceil(math.log2(opt.bound)) + self.grid_size = 128 + self.max_level = None + self.dmtet = opt.dmtet + self.cuda_ray = opt.cuda_ray + self.taichi_ray = opt.taichi_ray + self.min_near = opt.min_near + self.density_thresh = opt.density_thresh + + # prepare aabb with a 6D tensor (xmin, ymin, zmin, xmax, ymax, zmax) + # NOTE: aabb (can be rectangular) is only used to generate points, we still rely on bound (always cubic) to calculate density grid and hashing. + aabb_train = torch.FloatTensor( + [-opt.bound, -opt.bound, -opt.bound, opt.bound, opt.bound, opt.bound]) + aabb_infer = aabb_train.clone() + self.register_buffer('aabb_train', aabb_train) + self.register_buffer('aabb_infer', aabb_infer) + + self.glctx = None + + # extra state for cuda raymarching + if self.cuda_ray: + # density grid + density_grid = torch.zeros( + [self.cascade, self.grid_size ** 3]) # [CAS, H * H * H] + density_bitfield = torch.zeros( + self.cascade * self.grid_size ** 3 // 8, dtype=torch.uint8) # [CAS * H * H * H // 8] + self.register_buffer('density_grid', density_grid) + self.register_buffer('density_bitfield', density_bitfield) + self.mean_density = 0 + self.iter_density = 0 + + # load dmtet vertices + if self.opt.dmtet: + self.dmtet = DMTetGeometry(opt.tet_grid_size, opt.tet_mlp, opt).to(opt.device) + if self.opt.h <= 2048 and self.opt.w <= 2048: + self.glctx = dr.RasterizeCudaContext() + else: + self.glctx = dr.RasterizeGLContext() + + if self.taichi_ray: + from einops import rearrange + from taichi_modules import RayMarcherTaichi + from taichi_modules import VolumeRendererTaichi + from taichi_modules import RayAABBIntersector as RayAABBIntersectorTaichi + from taichi_modules import raymarching_test as raymarching_test_taichi + from taichi_modules import composite_test as composite_test_fw + from taichi_modules import packbits as packbits_taichi + self.rearrange = rearrange + self.packbits_taichi = packbits_taichi + self.ray_aabb_intersector = RayAABBIntersectorTaichi + self.raymarching_test_taichi = raymarching_test_taichi + self.composite_test_fw = composite_test_fw + self.ray_marching = RayMarcherTaichi( + batch_size=4096) # TODO: hard encoded batch size + self.volume_render = VolumeRendererTaichi( + batch_size=4096) # TODO: hard encoded batch size + # density grid + density_grid = torch.zeros( + [self.cascade, self.grid_size ** 3]) # [CAS, H * H * H] + density_bitfield = torch.zeros( + self.cascade * self.grid_size ** 3 // 8, dtype=torch.uint8) # [CAS * H * H * H // 8] + self.register_buffer('density_grid', density_grid) + self.register_buffer('density_bitfield', density_bitfield) + self.mean_density = 0 + self.iter_density = 0 + + if self.opt.density_activation == 'exp': + self.density_activation = trunc_exp + elif self.opt.density_activation == 'softplus': + self.density_activation = F.softplus + elif self.opt.density_activation == 'relu': + self.density_activation = F.relu + + # ref: https://github.com/zhaofuq/Instant-NSR/blob/main/nerf/network_sdf.py#L192 + def finite_difference_normal(self, x, epsilon=1e-2): + # x: [N, 3] + dx_pos, _ = self.common_forward((x + torch.tensor([[epsilon, 0.00, 0.00]], device=x.device)).clamp(-self.bound, self.bound)) + dx_neg, _ = self.common_forward((x + torch.tensor([[-epsilon, 0.00, 0.00]], device=x.device)).clamp(-self.bound, self.bound)) + dy_pos, _ = self.common_forward((x + torch.tensor([[0.00, epsilon, 0.00]], device=x.device)).clamp(-self.bound, self.bound)) + dy_neg, _ = self.common_forward((x + torch.tensor([[0.00, -epsilon, 0.00]], device=x.device)).clamp(-self.bound, self.bound)) + dz_pos, _ = self.common_forward((x + torch.tensor([[0.00, 0.00, epsilon]], device=x.device)).clamp(-self.bound, self.bound)) + dz_neg, _ = self.common_forward((x + torch.tensor([[0.00, 0.00, -epsilon]], device=x.device)).clamp(-self.bound, self.bound)) + + normal = torch.stack([ + 0.5 * (dx_pos - dx_neg) / epsilon, + 0.5 * (dy_pos - dy_neg) / epsilon, + 0.5 * (dz_pos - dz_neg) / epsilon + ], dim=-1) + + return -normal + + def normal(self, x): + normal = self.finite_difference_normal(x) + normal = safe_normalize(normal) + normal = torch.nan_to_num(normal) + return normal + + @torch.no_grad() + def density_blob(self, x): + # x: [B, N, 3] + + d = (x ** 2).sum(-1) + + if self.opt.density_activation == 'exp': + g = self.opt.blob_density * \ + torch.exp(- d / (2 * self.opt.blob_radius ** 2)) + else: + g = self.opt.blob_density * \ + (1 - torch.sqrt(d) / self.opt.blob_radius) + + return g + + def forward(self, x, d): + raise NotImplementedError() + + def density(self, x): + raise NotImplementedError() + + def reset_extra_state(self): + if not (self.cuda_ray or self.taichi_ray): + return + # density grid + self.density_grid.zero_() + self.mean_density = 0 + self.iter_density = 0 + + @torch.no_grad() + def export_mesh(self, path, resolution=None, decimate_target=-1, S=128): + from meshutils import decimate_mesh, clean_mesh, poisson_mesh_reconstruction + if self.opt.dmtet: + vertices, triangles = self.dmtet.get_verts_face() + vertices = vertices.detach().cpu().numpy() + triangles = triangles.detach().cpu().numpy() + + else: + + if resolution is None: + resolution = self.grid_size + + if self.cuda_ray: + density_thresh = min(self.mean_density, self.density_thresh) \ + if np.greater(self.mean_density, 0) else self.density_thresh + else: + density_thresh = self.density_thresh + + sigmas = np.zeros( + [resolution, resolution, resolution], dtype=np.float32) + + # query + X = torch.linspace(-1, 1, resolution).split(S) + Y = torch.linspace(-1, 1, resolution).split(S) + Z = torch.linspace(-1, 1, resolution).split(S) + + for xi, xs in enumerate(X): + for yi, ys in enumerate(Y): + for zi, zs in enumerate(Z): + xx, yy, zz = custom_meshgrid(xs, ys, zs) + pts = torch.cat( + [xx.reshape(-1, 1), yy.reshape(-1, 1), zz.reshape(-1, 1)], dim=-1) # [S, 3] + val = self.density(pts.to(self.aabb_train.device)) + sigmas[xi * S: xi * S + len(xs), yi * S: yi * S + len(ys), zi * S: zi * S + len( + zs)] = val['sigma'].reshape(len(xs), len(ys), len(zs)).detach().cpu().numpy() # [S, 1] --> [x, y, z] + + logger.info( + f'[INFO] marching cubes thresh: {density_thresh} ({sigmas.min()} ~ {sigmas.max()})') + + vertices, triangles = mcubes.marching_cubes(sigmas, density_thresh) + vertices = vertices / (resolution - 1.0) * 2 - 1 + + # clean + vertices = vertices.astype(np.float32) + triangles = triangles.astype(np.int32) + vertices, triangles = clean_mesh( + vertices, triangles, remesh=True, remesh_size=0.01) + + # decimation + if decimate_target > 0 and triangles.shape[0] > decimate_target: + vertices, triangles = decimate_mesh( + vertices, triangles, decimate_target) + + v = torch.from_numpy(vertices).contiguous( + ).float().to(self.aabb_train.device) + f = torch.from_numpy(triangles).contiguous().int().to( + self.aabb_train.device) + + # mesh = trimesh.Trimesh(vertices, triangles, process=False) # important, process=True leads to seg fault... + # mesh.export(os.path.join(path, f'mesh.ply')) + + def _export(v, f, h0=2048, w0=2048, ssaa=1, name=''): + # v, f: torch Tensor + device = v.device + v_np = v.cpu().numpy() # [N, 3] + f_np = f.cpu().numpy() # [M, 3] + + logger.info( + f'[INFO] running xatlas to unwrap UVs for mesh: v={v_np.shape} f={f_np.shape}') + + # unwrap uvs + import xatlas + import nvdiffrast.torch as dr + from sklearn.neighbors import NearestNeighbors + from scipy.ndimage import binary_dilation, binary_erosion + + atlas = xatlas.Atlas() + atlas.add_mesh(v_np, f_np) + chart_options = xatlas.ChartOptions() + chart_options.max_iterations = 4 # for faster unwrap... + atlas.generate(chart_options=chart_options) + vmapping, ft_np, vt_np = atlas[0] # [N], [M, 3], [N, 2] + + # vmapping, ft_np, vt_np = xatlas.parametrize(v_np, f_np) # [N], [M, 3], [N, 2] + + vt = torch.from_numpy(vt_np.astype(np.float32)).float().to(device) + ft = torch.from_numpy(ft_np.astype(np.int64)).int().to(device) + + # render uv maps + uv = vt * 2.0 - 1.0 # uvs to range [-1, 1] + uv = torch.cat((uv, torch.zeros_like( + uv[..., :1]), torch.ones_like(uv[..., :1])), dim=-1) # [N, 4] + + if ssaa > 1: + h = int(h0 * ssaa) + w = int(w0 * ssaa) + else: + h, w = h0, w0 + + if self.glctx is None: + if h <= 2048 and w <= 2048: + self.glctx = dr.RasterizeCudaContext() + else: + self.glctx = dr.RasterizeGLContext() + + rast, _ = dr.rasterize(self.glctx, uv.unsqueeze( + 0), ft, (h, w)) # [1, h, w, 4] + xyzs, _ = dr.interpolate(v.unsqueeze(0), rast, f) # [1, h, w, 3] + mask, _ = dr.interpolate(torch.ones_like( + v[:, :1]).unsqueeze(0), rast, f) # [1, h, w, 1] + + # masked query + xyzs = xyzs.view(-1, 3) + mask = (mask > 0).view(-1) + + feats = torch.zeros(h * w, 3, device=device, dtype=torch.float32) + + if mask.any(): + xyzs = xyzs[mask] # [M, 3] + + # batched inference to avoid OOM + all_feats = [] + head = 0 + while head < xyzs.shape[0]: + tail = min(head + 640000, xyzs.shape[0]) + results_ = self.density(xyzs[head:tail]) + all_feats.append(results_['albedo'].float()) + head += 640000 + + feats[mask] = torch.cat(all_feats, dim=0) + + feats = feats.view(h, w, -1) + mask = mask.view(h, w) + + # quantize [0.0, 1.0] to [0, 255] + feats = feats.cpu().numpy() + feats = (feats * 255).astype(np.uint8) + + ### NN search as an antialiasing ... + mask = mask.cpu().numpy() + + inpaint_region = binary_dilation(mask, iterations=3) + inpaint_region[mask] = 0 + + search_region = mask.copy() + not_search_region = binary_erosion(search_region, iterations=2) + search_region[not_search_region] = 0 + + search_coords = np.stack(np.nonzero(search_region), axis=-1) + inpaint_coords = np.stack(np.nonzero(inpaint_region), axis=-1) + + knn = NearestNeighbors(n_neighbors=1, algorithm='kd_tree').fit(search_coords) + _, indices = knn.kneighbors(inpaint_coords) + + feats[tuple(inpaint_coords.T)] = feats[tuple(search_coords[indices[:, 0]].T)] + + feats = cv2.cvtColor(feats, cv2.COLOR_RGB2BGR) + + # do ssaa after the NN search, in numpy + if ssaa > 1: + feats = cv2.resize(feats, (w0, h0), interpolation=cv2.INTER_LINEAR) + + cv2.imwrite(os.path.join(path, f'{name}albedo.png'), feats) + + # save obj (v, vt, f /) + obj_file = os.path.join(path, f'{name}mesh.obj') + mtl_file = os.path.join(path, f'{name}mesh.mtl') + + logger.info(f'[INFO] writing obj mesh to {obj_file}') + with open(obj_file, "w") as fp: + fp.write(f'mtllib {name}mesh.mtl \n') + + logger.info(f'[INFO] writing vertices {v_np.shape}') + for v in v_np: + fp.write(f'v {v[0]} {v[1]} {v[2]} \n') + + logger.info( + f'[INFO] writing vertices texture coords {vt_np.shape}') + for v in vt_np: + fp.write(f'vt {v[0]} {1 - v[1]} \n') + + logger.info(f'[INFO] writing faces {f_np.shape}') + fp.write(f'usemtl mat0 \n') + for i in range(len(f_np)): + fp.write( + f"f {f_np[i, 0] + 1}/{ft_np[i, 0] + 1} {f_np[i, 1] + 1}/{ft_np[i, 1] + 1} {f_np[i, 2] + 1}/{ft_np[i, 2] + 1} \n") + + with open(mtl_file, "w") as fp: + fp.write(f'newmtl mat0 \n') + fp.write(f'Ka 1.000000 1.000000 1.000000 \n') + fp.write(f'Kd 1.000000 1.000000 1.000000 \n') + fp.write(f'Ks 0.000000 0.000000 0.000000 \n') + fp.write(f'Tr 1.000000 \n') + fp.write(f'illum 1 \n') + fp.write(f'Ns 0.000000 \n') + fp.write(f'map_Kd {name}albedo.png \n') + + _export(v, f) + + def run(self, rays_o, rays_d, light_d=None, ambient_ratio=1.0, shading='albedo', bg_color=None, perturb=False, **kwargs): + # rays_o, rays_d: [B, N, 3] + # bg_color: [BN, 3] in range [0, 1] + # return: image: [B, N, 3], depth: [B, N] + + prefix = rays_o.shape[:-1] + rays_o = rays_o.contiguous().view(-1, 3) + rays_d = rays_d.contiguous().view(-1, 3) + + N = rays_o.shape[0] # N = B * N, in fact + device = rays_o.device + + results = {} + + # choose aabb + aabb = self.aabb_train if self.training else self.aabb_infer + + # sample steps + # nears, fars = raymarching.near_far_from_aabb(rays_o, rays_d, aabb, self.min_near) + # nears.unsqueeze_(-1) + # fars.unsqueeze_(-1) + nears, fars = near_far_from_bound(rays_o, rays_d, self.bound, type='sphere', min_near=self.min_near) + + # random sample light_d if not provided + if light_d is None: + # gaussian noise around the ray origin, so the light always face the view dir (avoid dark face) + if self.training: + light_d = safe_normalize(rays_o + torch.randn(3, device=rays_o.device)) # [N, 3] + else: + light_d = safe_normalize(rays_o[0:1] + torch.randn(3, device=rays_o.device)) # [N, 3] + + #print(f'nears = {nears.min().item()} ~ {nears.max().item()}, fars = {fars.min().item()} ~ {fars.max().item()}') + + z_vals = torch.linspace(0.0, 1.0, self.opt.num_steps, device=device).unsqueeze(0) # [1, T] + z_vals = z_vals.expand((N, self.opt.num_steps)) # [N, T] + z_vals = nears + (fars - nears) * z_vals # [N, T], in [nears, fars] + + # perturb z_vals + sample_dist = (fars - nears) / self.opt.num_steps + if perturb: + z_vals = z_vals + (torch.rand(z_vals.shape, device=device) - 0.5) * sample_dist + #z_vals = z_vals.clamp(nears, fars) # avoid out of bounds xyzs. + + # generate xyzs + xyzs = rays_o.unsqueeze(-2) + rays_d.unsqueeze(-2) * z_vals.unsqueeze(-1) # [N, 1, 3] * [N, T, 1] -> [N, T, 3] + xyzs = torch.min(torch.max(xyzs, aabb[:3]), aabb[3:]) # a manual clip. + + #plot_pointcloud(xyzs.reshape(-1, 3).detach().cpu().numpy()) + + # query SDF and RGB + density_outputs = self.density(xyzs.reshape(-1, 3)) + + #sigmas = density_outputs['sigma'].view(N, self.opt.num_steps) # [N, T] + for k, v in density_outputs.items(): + density_outputs[k] = v.view(N, self.opt.num_steps, -1) + + # upsample z_vals (nerf-like) + if self.opt.upsample_steps > 0: + with torch.no_grad(): + + deltas = z_vals[..., 1:] - z_vals[..., :-1] # [N, T-1] + deltas = torch.cat([deltas, sample_dist * torch.ones_like(deltas[..., :1])], dim=-1) + + alphas = 1 - torch.exp(-deltas * density_outputs['sigma'].squeeze(-1)) # [N, T] + alphas_shifted = torch.cat([torch.ones_like(alphas[..., :1]), 1 - alphas + 1e-15], dim=-1) # [N, T+1] + weights = alphas * torch.cumprod(alphas_shifted, dim=-1)[..., :-1] # [N, T] + + # sample new z_vals + z_vals_mid = (z_vals[..., :-1] + 0.5 * deltas[..., :-1]) # [N, T-1] + new_z_vals = sample_pdf(z_vals_mid, weights[:, 1:-1], self.opt.upsample_steps, det=not self.training).detach() # [N, t] + + new_xyzs = rays_o.unsqueeze(-2) + rays_d.unsqueeze(-2) * new_z_vals.unsqueeze(-1) # [N, 1, 3] * [N, t, 1] -> [N, t, 3] + new_xyzs = torch.min(torch.max(new_xyzs, aabb[:3]), aabb[3:]) # a manual clip. + + # only forward new points to save computation + new_density_outputs = self.density(new_xyzs.reshape(-1, 3)) + #new_sigmas = new_density_outputs['sigma'].view(N, self.opt.upsample_steps) # [N, t] + for k, v in new_density_outputs.items(): + new_density_outputs[k] = v.view(N, self.opt.upsample_steps, -1) + + # re-order + z_vals = torch.cat([z_vals, new_z_vals], dim=1) # [N, T+t] + z_vals, z_index = torch.sort(z_vals, dim=1) + + xyzs = torch.cat([xyzs, new_xyzs], dim=1) # [N, T+t, 3] + xyzs = torch.gather(xyzs, dim=1, index=z_index.unsqueeze(-1).expand_as(xyzs)) + + for k in density_outputs: + tmp_output = torch.cat([density_outputs[k], new_density_outputs[k]], dim=1) + density_outputs[k] = torch.gather(tmp_output, dim=1, index=z_index.unsqueeze(-1).expand_as(tmp_output)) + + deltas = z_vals[..., 1:] - z_vals[..., :-1] # [N, T+t-1] + deltas = torch.cat([deltas, sample_dist * torch.ones_like(deltas[..., :1])], dim=-1) + alphas = 1 - torch.exp(-deltas * density_outputs['sigma'].squeeze(-1)) # [N, T+t] + alphas_shifted = torch.cat([torch.ones_like(alphas[..., :1]), 1 - alphas + 1e-15], dim=-1) # [N, T+t+1] + weights = alphas * torch.cumprod(alphas_shifted, dim=-1)[..., :-1] # [N, T+t] + + dirs = rays_d.view(-1, 1, 3).expand_as(xyzs) + light_d = light_d.view(-1, 1, 3).expand_as(xyzs) + for k, v in density_outputs.items(): + density_outputs[k] = v.view(-1, v.shape[-1]) + + dirs = safe_normalize(dirs) + sigmas, rgbs, normals = self(xyzs.reshape(-1, 3), dirs.reshape(-1, 3), light_d, ratio=ambient_ratio, shading=shading) + rgbs = rgbs.view(N, -1, 3) # [N, T+t, 3] + if normals is not None: + normals = normals.view(N, -1, 3) + + # calculate weight_sum (mask) + weights_sum = weights.sum(dim=-1) # [N] + + # calculate depth + depth = torch.sum(weights * z_vals, dim=-1) + + # calculate color + image = torch.sum(weights.unsqueeze(-1) * rgbs, dim=-2) # [N, 3], in [0, 1] + + # mix background color + if bg_color is None: + if self.opt.bg_radius > 0: + # use the bg model to calculate bg_color + bg_color = self.background(rays_d) # [N, 3] + else: + bg_color = 1 + + image = image + (1 - weights_sum).unsqueeze(-1) * bg_color + + image = image.view(*prefix, 3) + depth = depth.view(*prefix) + weights_sum = weights_sum.reshape(*prefix) + + if self.training: + if self.opt.lambda_orient > 0 and normals is not None: + # orientation loss + loss_orient = weights.detach() * (normals * dirs).sum(-1).clamp(min=0) ** 2 + results['loss_orient'] = loss_orient.sum(-1).mean() + + if self.opt.lambda_3d_normal_smooth > 0 and normals is not None: + normals_perturb = self.normal(xyzs + torch.randn_like(xyzs) * 1e-2) + results['loss_normal_perturb'] = (normals - normals_perturb).abs().mean() + + if normals is not None: + normal_image = torch.sum( + weights.unsqueeze(-1) * (normals + 1) / 2, dim=-2) # [N, 3], in [0, 1] + results['normal_image'] = normal_image + + results['image'] = image + results['depth'] = depth + results['weights'] = weights + results['weights_sum'] = weights_sum + + return results + + + def run_cuda(self, rays_o, rays_d, light_d=None, ambient_ratio=1.0, shading='albedo', bg_color=None, perturb=False, T_thresh=1e-4, binarize=False, **kwargs): + # rays_o, rays_d: [B, N, 3] + # return: image: [B, N, 3], depth: [B, N] + + prefix = rays_o.shape[:-1] + rays_o = rays_o.contiguous().view(-1, 3) + rays_d = rays_d.contiguous().view(-1, 3) + + N = rays_o.shape[0] # B * N, in fact + device = rays_o.device + + # pre-calculate near far + nears, fars = raymarching.near_far_from_aabb(rays_o, rays_d, self.aabb_train if self.training else self.aabb_infer) + + # random sample light_d if not provided + if light_d is None: + # gaussian noise around the ray origin, so the light always face the view dir (avoid dark face) + if self.training: + light_d = safe_normalize(rays_o[0:1] + torch.randn(3, device=rays_o.device)) # [N, 3] + else: + light_d = safe_normalize(rays_o[0:1] + torch.randn(3, device=rays_o.device)) # [N, 3] + + results = {} + + if self.training: + xyzs, dirs, ts, rays = raymarching.march_rays_train(rays_o, rays_d, self.bound, self.density_bitfield, self.cascade, self.grid_size, nears, fars, perturb, self.opt.dt_gamma, self.opt.max_steps) + dirs = safe_normalize(dirs) + + if light_d.shape[0] > 1: + flatten_rays = raymarching.flatten_rays(rays, xyzs.shape[0]).long() + light_d = light_d[flatten_rays] + + sigmas, rgbs, normals = self(xyzs, dirs, light_d, ratio=ambient_ratio, shading=shading) + weights, weights_sum, depth, image = raymarching.composite_rays_train(sigmas, rgbs, ts, rays, T_thresh, binarize) + + # normals related regularizations + if self.opt.lambda_orient > 0 and normals is not None: + # orientation loss + loss_orient = weights.detach() * (normals * dirs).sum(-1).clamp(min=0) ** 2 + results['loss_orient'] = loss_orient.mean() + + if self.opt.lambda_3d_normal_smooth > 0 and normals is not None: + normals_perturb = self.normal(xyzs + torch.randn_like(xyzs) * 1e-2) + results['loss_normal_perturb'] = (normals - normals_perturb).abs().mean() + + if normals is not None: + _, _, _, normal_image = raymarching.composite_rays_train(sigmas.detach(), (normals + 1) / 2, ts, rays, T_thresh, binarize) + results['normal_image'] = normal_image + + # weights normalization + results['weights'] = weights + + else: + + # allocate outputs + dtype = torch.float32 + + weights_sum = torch.zeros(N, dtype=dtype, device=device) + depth = torch.zeros(N, dtype=dtype, device=device) + image = torch.zeros(N, 3, dtype=dtype, device=device) + + n_alive = N + rays_alive = torch.arange(n_alive, dtype=torch.int32, device=device) # [N] + rays_t = nears.clone() # [N] + + step = 0 + + while step < self.opt.max_steps: # hard coded max step + + # count alive rays + n_alive = rays_alive.shape[0] + + # exit loop + if n_alive <= 0: + break + + # decide compact_steps + n_step = max(min(N // n_alive, 8), 1) + + xyzs, dirs, ts = raymarching.march_rays(n_alive, n_step, rays_alive, rays_t, rays_o, rays_d, self.bound, self.density_bitfield, self.cascade, self.grid_size, nears, fars, perturb if step == 0 else False, self.opt.dt_gamma, self.opt.max_steps) + dirs = safe_normalize(dirs) + sigmas, rgbs, normals = self(xyzs, dirs, light_d, ratio=ambient_ratio, shading=shading) + raymarching.composite_rays(n_alive, n_step, rays_alive, rays_t, sigmas, rgbs, ts, weights_sum, depth, image, T_thresh, binarize) + + rays_alive = rays_alive[rays_alive >= 0] + #print(f'step = {step}, n_step = {n_step}, n_alive = {n_alive}, xyzs: {xyzs.shape}') + + step += n_step + + # mix background color + if bg_color is None: + if self.opt.bg_radius > 0: + # use the bg model to calculate bg_color + bg_color = self.background(rays_d) # [N, 3] + else: + bg_color = 1 + + image = image + (1 - weights_sum).unsqueeze(-1) * bg_color + image = image.view(*prefix, 3) + + depth = depth.view(*prefix) + + weights_sum = weights_sum.reshape(*prefix) + + results['image'] = image + results['depth'] = depth + results['weights_sum'] = weights_sum + + return results + + def get_sdf_albedo_for_init(self, points=None): + output = self.density(self.dmtet.verts if points is None else points) + sigma, albedo = output['sigma'], output['albedo'] + return sigma - self.density_thresh, albedo + + def run_dmtet(self, rays_o, rays_d, mvp, h, w, light_d=None, ambient_ratio=1.0, shading='albedo', bg_color=None, **kwargs): + # mvp: [B, 4, 4] + + device = mvp.device + campos = rays_o[:, 0, :] # only need one ray per batch + + # random sample light_d if not provided + if light_d is None: + # gaussian noise around the ray origin, so the light always face the view dir (avoid dark face) + light_d = safe_normalize(campos + torch.randn_like(campos)).view(-1, 1, 1, 3) # [B, 1, 1, 3] + + results = {} + + verts, faces = self.dmtet.get_verts_face() + + # get normals + i0, i1, i2 = faces[:, 0], faces[:, 1], faces[:, 2] + v0, v1, v2 = verts[i0, :], verts[i1, :], verts[i2, :] + + faces = faces.int() + + face_normals = torch.cross(v1 - v0, v2 - v0) + face_normals = safe_normalize(face_normals) + + vn = torch.zeros_like(verts) + vn.scatter_add_(0, i0[:, None].repeat(1,3), face_normals) + vn.scatter_add_(0, i1[:, None].repeat(1,3), face_normals) + vn.scatter_add_(0, i2[:, None].repeat(1,3), face_normals) + + vn = torch.where(torch.sum(vn * vn, -1, keepdim=True) > 1e-20, vn, torch.tensor([0.0, 0.0, 1.0], dtype=torch.float32, device=vn.device)) + + # rasterization + verts_clip = torch.bmm(F.pad(verts, pad=(0, 1), mode='constant', value=1.0).unsqueeze(0).repeat(mvp.shape[0], 1, 1), + mvp.permute(0,2,1)).float() # [B, N, 4] + rast, rast_db = dr.rasterize(self.glctx, verts_clip, faces, (h, w)) + + alpha, _ = dr.interpolate(torch.ones_like(verts[:, :1]).unsqueeze(0), rast, faces) # [B, H, W, 1] + xyzs, _ = dr.interpolate(verts.unsqueeze(0), rast, faces) # [B, H, W, 3] + normal, _ = dr.interpolate(vn.unsqueeze(0).contiguous(), rast, faces) + normal = safe_normalize(normal) + + xyzs = xyzs.view(-1, 3) + mask = (alpha > 0).view(-1).detach() + + # do the lighting here since we have normal from mesh now. + albedo = torch.zeros_like(xyzs, dtype=torch.float32) + if mask.any(): + masked_albedo = self.density(xyzs[mask])['albedo'] + albedo[mask] = masked_albedo.float() + albedo = albedo.view(-1, h, w, 3) + + if shading == 'albedo': + color = albedo + elif shading == 'textureless': + lambertian = ambient_ratio + (1 - ambient_ratio) * (normal * light_d).sum(-1).float().clamp(min=0) + color = lambertian.unsqueeze(-1).repeat(1, 1, 1, 3) + elif shading == 'normal': + color = (normal + 1) / 2 + else: # 'lambertian' + lambertian = ambient_ratio + (1 - ambient_ratio) * (normal * light_d).sum(-1).float().clamp(min=0) + color = albedo * lambertian.unsqueeze(-1) + + color = dr.antialias(color, rast, verts_clip, faces).clamp(0, 1) # [B, H, W, 3] + alpha = dr.antialias(alpha, rast, verts_clip, faces).clamp(0, 1) # [B, H, W, 1] + + # mix background color + if bg_color is None: + if self.opt.bg_radius > 0: + # use the bg model to calculate bg_color + bg_color = self.background(rays_d) # [N, 3] + else: + bg_color = 1 + + if torch.is_tensor(bg_color) and len(bg_color.shape) > 1: + bg_color = bg_color.view(-1, h, w, 3) + + depth = rast[:, :, :, [2]] # [B, H, W] + color = color + (1 - alpha) * bg_color + + results['depth'] = depth + results['image'] = color + results['weights_sum'] = alpha.squeeze(-1) + + normal_image = dr.antialias((normal + 1) / 2, rast, verts_clip, faces).clamp(0, 1) # [B, H, W, 3] + results['normal_image'] = normal_image + + # regularizations + if self.training: + if self.opt.lambda_mesh_normal > 0: + results['loss_normal'] = normal_consistency( + face_normals, faces) + if self.opt.lambda_mesh_lap > 0: + results['loss_lap'] = laplacian_smooth_loss(verts, faces) + + return results + + def run_taichi(self, rays_o, rays_d, light_d=None, ambient_ratio=1.0, shading='albedo', bg_color=None, perturb=False, T_thresh=1e-4, **kwargs): + # rays_o, rays_d: [B, N, 3], assumes B == 1 + # return: image: [B, N, 3], depth: [B, N] + + prefix = rays_o.shape[:-1] + rays_o = rays_o.contiguous().view(-1, 3) + rays_d = rays_d.contiguous().view(-1, 3) + + N = rays_o.shape[0] # N = B * N, in fact + device = rays_o.device + + # pre-calculate near far + exp_step_factor = kwargs.get('exp_step_factor', 0.) + MAX_SAMPLES = 1024 + NEAR_DISTANCE = 0.01 + center = torch.zeros(1, 3) + half_size = torch.ones(1, 3) + _, hits_t, _ = self.ray_aabb_intersector.apply(rays_o, rays_d, center, half_size, 1) + hits_t[(hits_t[:, 0, 0] >= 0) & (hits_t[:, 0, 0] < NEAR_DISTANCE), 0, 0] = NEAR_DISTANCE + + # TODO: should sample different light_d for each batch... but taichi end doesn't have a flatten_ray implemented currently... + # random sample light_d if not provided + if light_d is None: + # gaussian noise around the ray origin, so the light always face the view dir (avoid dark face) + light_d = (rays_o[0] + torch.randn(3, device=device, dtype=torch.float)) + light_d = safe_normalize(light_d) + + results = {} + + if self.training: + rays_a, xyzs, dirs, deltas, ts, _ = self.ray_marching(rays_o, rays_d, hits_t[:, 0], self.density_bitfield, self.cascade, self.bound, exp_step_factor, self.grid_size, MAX_SAMPLES) + dirs = safe_normalize(dirs) + # plot_pointcloud(xyzs.reshape(-1, 3).detach().cpu().numpy()) + sigmas, rgbs, normals = self(xyzs, dirs, light_d, ratio=ambient_ratio, shading=shading) + _, weights_sum, depth, image, weights = self.volume_render(sigmas, rgbs, deltas, ts, rays_a, kwargs.get('T_threshold', 1e-4)) + + # normals related regularizations + if self.opt.lambda_orient > 0 and normals is not None: + # orientation loss + loss_orient = weights.detach() * (normals * dirs).sum(-1).clamp(min=0) ** 2 + results['loss_orient'] = loss_orient.mean() + + if self.opt.lambda_3d_normal_smooth > 0 and normals is not None: + normals_perturb = self.normal(xyzs + torch.randn_like(xyzs) * 1e-2) + results['loss_normal_perturb'] = (normals - normals_perturb).abs().mean() + + if normals is not None: + _, _, _, normal_image, _ = self.volume_render(sigmas.detach(), (normals + 1) / 2, deltas, ts, rays_a, kwargs.get('T_threshold', 1e-4)) + results['normal_image'] = normal_image + + # weights normalization + results['weights'] = weights + + else: + + # allocate outputs + dtype = torch.float32 + + weights_sum = torch.zeros(N, dtype=dtype, device=device) + depth = torch.zeros(N, dtype=dtype, device=device) + image = torch.zeros(N, 3, dtype=dtype, device=device) + + n_alive = N + rays_alive = torch.arange(n_alive, dtype=torch.int32, device=device) # [N] + rays_t = hits_t[:, 0, 0] + step = 0 + + min_samples = 1 if exp_step_factor == 0 else 4 + + while step < self.opt.max_steps: # hard coded max step + + # count alive rays + n_alive = rays_alive.shape[0] + + # exit loop + if n_alive <= 0: + break + + # decide compact_steps + # n_step = max(min(N // n_alive, 8), 1) + n_step = max(min(N // n_alive, 64), min_samples) + + xyzs, dirs, deltas, ts, N_eff_samples = \ + self.raymarching_test_taichi(rays_o, rays_d, hits_t[:, 0], rays_alive, + self.density_bitfield, self.cascade, + self.bound, exp_step_factor, + self.grid_size, MAX_SAMPLES, n_step) + + xyzs = self.rearrange(xyzs, 'n1 n2 c -> (n1 n2) c') + dirs = self.rearrange(dirs, 'n1 n2 c -> (n1 n2) c') + dirs = safe_normalize(dirs) + valid_mask = ~torch.all(dirs == 0, dim=1) + if valid_mask.sum() == 0: + break + + sigmas = torch.zeros(len(xyzs), device=device) + rgbs = torch.zeros(len(xyzs), 3, device=device) + normals = torch.zeros(len(xyzs), 3, device=device) + + sigmas[valid_mask], _rgbs, normals = self(xyzs[valid_mask], dirs[valid_mask], light_d, ratio=ambient_ratio, shading=shading) + rgbs[valid_mask] = _rgbs.float() + sigmas = self.rearrange(sigmas, '(n1 n2) -> n1 n2', n2=n_step) + rgbs = self.rearrange(rgbs, '(n1 n2) c -> n1 n2 c', n2=n_step) + if normals is not None: + normals = self.rearrange(normals, '(n1 n2) c -> n1 n2 c', n2=n_step) + + self.composite_test_fw(sigmas, rgbs, deltas, ts, hits_t[:,0], rays_alive, + kwargs.get('T_threshold', 1e-4), N_eff_samples, + weights_sum, depth, image) + + rays_alive = rays_alive[rays_alive >= 0] + + step += n_step + + # mix background color + if bg_color is None: + if self.opt.bg_radius > 0: + # use the bg model to calculate bg_color + bg_color = self.background(rays_d) # [N, 3] + else: + bg_color = 1 + + image = image + self.rearrange(1 - weights_sum, 'n -> n 1') * bg_color + image = image.view(*prefix, 3) + + depth = depth.view(*prefix) + + weights_sum = weights_sum.reshape(*prefix) + + results['image'] = image + results['depth'] = depth + results['weights_sum'] = weights_sum + + return results + + + @torch.no_grad() + def update_extra_state(self, decay=0.95, S=128): + # call before each epoch to update extra states. + + if not (self.cuda_ray or self.taichi_ray): + return + + ### update density grid + tmp_grid = - torch.ones_like(self.density_grid) + + X = torch.arange(self.grid_size, dtype=torch.int32, device=self.aabb_train.device).split(S) + Y = torch.arange(self.grid_size, dtype=torch.int32, device=self.aabb_train.device).split(S) + Z = torch.arange(self.grid_size, dtype=torch.int32, device=self.aabb_train.device).split(S) + + for xs in X: + for ys in Y: + for zs in Z: + + # construct points + xx, yy, zz = custom_meshgrid(xs, ys, zs) + coords = torch.cat([xx.reshape(-1, 1), yy.reshape(-1, 1), zz.reshape(-1, 1)], dim=-1) # [N, 3], in [0, 128) + indices = raymarching.morton3D(coords).long() # [N] + xyzs = 2 * coords.float() / (self.grid_size - 1) - 1 # [N, 3] in [-1, 1] + + # cascading + for cas in range(self.cascade): + bound = min(2 ** cas, self.bound) + half_grid_size = bound / self.grid_size + # scale to current cascade's resolution + cas_xyzs = xyzs * (bound - half_grid_size) + # add noise in [-hgs, hgs] + cas_xyzs += (torch.rand_like(cas_xyzs) * 2 - 1) * half_grid_size + # query density + sigmas = self.density(cas_xyzs)['sigma'].reshape(-1).detach() + # assign + tmp_grid[cas, indices] = sigmas + # ema update + valid_mask = self.density_grid >= 0 + self.density_grid[valid_mask] = torch.maximum(self.density_grid[valid_mask] * decay, tmp_grid[valid_mask]) + self.mean_density = torch.mean(self.density_grid[valid_mask]).item() + self.iter_density += 1 + + # convert to bitfield + density_thresh = min(self.mean_density, self.density_thresh) + if self.cuda_ray: + self.density_bitfield = raymarching.packbits(self.density_grid, density_thresh, self.density_bitfield) + elif self.taichi_ray: + self.packbits_taichi(self.density_grid.reshape(-1).contiguous(), density_thresh, self.density_bitfield) + + # print(f'[density grid] min={self.density_grid.min().item():.4f}, max={self.density_grid.max().item():.4f}, mean={self.mean_density:.4f}, occ_rate={(self.density_grid > density_thresh).sum() / (128**3 * self.cascade):.3f}') + + + def render(self, rays_o, rays_d, mvp, h, w, staged=False, max_ray_batch=4096, **kwargs): + # rays_o, rays_d: [B, N, 3] + # return: pred_rgb: [B, N, 3] + B, N = rays_o.shape[:2] + device = rays_o.device + + if self.dmtet: + results = self.run_dmtet(rays_o, rays_d, mvp, h, w, **kwargs) + elif self.cuda_ray: + results = self.run_cuda(rays_o, rays_d, **kwargs) + elif self.taichi_ray: + results = self.run_taichi(rays_o, rays_d, **kwargs) + else: + if staged: + depth = torch.empty((B, N), device=device) + image = torch.empty((B, N, 3), device=device) + weights_sum = torch.empty((B, N), device=device) + + for b in range(B): + head = 0 + while head < N: + tail = min(head + max_ray_batch, N) + results_ = self.run(rays_o[b:b+1, head:tail], rays_d[b:b+1, head:tail], **kwargs) + depth[b:b+1, head:tail] = results_['depth'] + weights_sum[b:b+1, head:tail] = results_['weights_sum'] + image[b:b+1, head:tail] = results_['image'] + head += max_ray_batch + + results = {} + results['depth'] = depth + results['image'] = image + results['weights_sum'] = weights_sum + + else: + results = self.run(rays_o, rays_d, **kwargs) + + return results + + def init_tet_from_nerf(self, reset_scale=True): + sdf = self.get_sdf_from_nerf(reset_scale=reset_scale) + self.dmtet.init_tet_from_sdf(sdf) + logger.info(f'init dmtet from NeRF Done ...') + + + @torch.no_grad() + def get_sdf_from_nerf(self, reset_scale=True): + if self.cuda_ray: + density_thresh = min(self.mean_density, self.density_thresh) + else: + density_thresh = self.density_thresh + + if reset_scale: + # init scale + sigma = self.density(self.dmtet.verts)[ + 'sigma'] # verts covers [-1, 1] now + mask = sigma > density_thresh + valid_verts = self.dmtet.verts[mask] + tet_scale = valid_verts.abs().amax(dim=0) + 1e-1 + self.dmtet.reset_tet_scale(tet_scale) + sdf = (self.density(self.dmtet.verts)[ + 'sigma'] - density_thresh).clamp(-1, 1) + return sdf diff --git a/nerf/utils.py b/nerf/utils.py new file mode 100644 index 0000000..b2f100d --- /dev/null +++ b/nerf/utils.py @@ -0,0 +1,1599 @@ +import os +import glob +import tqdm +import random +import logging +import gc + +import numpy as np +import imageio, imageio_ffmpeg +import time + +import cv2 + +import torch +import torch.nn as nn +import torch.optim as optim +import torch.nn.functional as F +import torch.distributed as dist +from torch import Tensor +from torch.utils.tensorboard import SummaryWriter +import torchvision.transforms.functional as TF +from torchvision.utils import make_grid +from torchmetrics.functional import pearson_corrcoef + +from rich.console import Console +from torch_ema import ExponentialMovingAverage + +from packaging import version as pver + +from nerf.clip import CLIP +from easydict import EasyDict as edict +logger = logging.getLogger(__name__) + + +class AverageMeters(object): + """Computes and stores the average and current value""" + def __init__(self, keys=['loss']): + self.meters = edict() + self.keys= keys + self.reset() + + def reset(self): + for key in self.keys: + self.meters[key] = {} + self.meters[key].val = 0 + self.meters[key].avg = 0 + self.meters[key].sum = 0 + self.meters[key].count = 0 + + def reset_by_key(self, key): + self.meters[key] = {} + self.meters[key].val = 0 + self.meters[key].avg = 0 + self.meters[key].sum = 0 + self.meters[key].count = 0 + + def update(self, in_dict, n=1): + for key, val in in_dict.items(): + if key not in self.keys: + self.keys.append(key) + self.reset_by_key(key) + self.meters[key].val = val + self.meters[key].sum += val * n + self.meters[key].count += n + self.meters[key].avg = self.meters[key].sum / self.meters[key].count + + +def setup_workspace(opt): + if opt.workspace is None or opt.workspace == '': + opt.workspace = 'out/' + if opt.text: + opt.workspace += '_'.join(opt.text.split(' ')) + if opt.image: + opt.workspace += '_'.join('_'.join(opt.image.split('/') + [-2:]).split('.')[:-1]) + opt.workspace += '+' + time.strftime('%Y%m%d-%H%M%S') + opt.runname = os.path.basename(opt.workspace) + os.makedirs(opt.workspace, exist_ok=True) + opt.log_path = os.path.join(opt.workspace, f"log_{opt.runname}.txt") + opt.ckpt_path = os.path.join(opt.workspace, 'checkpoints') + opt.best_path = f"{opt.ckpt_path}/{opt.runname}.pth" + os.makedirs(opt.ckpt_path, exist_ok=True) + + +def custom_meshgrid(*args): + # ref: https://pytorch.org/docs/stable/generated/torch.meshgrid.html?highlight=meshgrid#torch.meshgrid + if pver.parse(torch.__version__) < pver.parse('1.10'): + return torch.meshgrid(*args) + else: + return torch.meshgrid(*args, indexing='ij') + +def safe_normalize(x, eps=1e-20): + return x / torch.sqrt(torch.clamp(torch.sum(x * x, -1, keepdim=True), min=eps)) + +@torch.cuda.amp.autocast(enabled=False) +def get_rays(poses, intrinsics, H, W, N=-1, error_map=None): + ''' get rays + Args: + poses: [B, 4, 4], cam2world + intrinsics: [4] + H, W, N: int + error_map: [B, 128 * 128], sample probability based on training error + Returns: + rays_o, rays_d: [B, N, 3] + inds: [B, N] + ''' + + device = poses.device + B = poses.shape[0] + fx, fy, cx, cy = intrinsics + + i, j = custom_meshgrid(torch.linspace(0, W-1, W, device=device), torch.linspace(0, H-1, H, device=device)) + i = i.t().reshape([1, H*W]).expand([B, H*W]) + 0.5 + j = j.t().reshape([1, H*W]).expand([B, H*W]) + 0.5 + + results = {} + + if N > 0: + N = min(N, H*W) + + if error_map is None: + inds = torch.randint(0, H*W, size=[N], device=device) # may duplicate + inds = inds.expand([B, N]) + else: + + # weighted sample on a low-reso grid + inds_coarse = torch.multinomial(error_map.to(device), N, replacement=False) # [B, N], but in [0, 128*128) + + # map to the original resolution with random perturb. + inds_x, inds_y = inds_coarse // 128, inds_coarse % 128 # `//` will throw a warning in torch 1.10... anyway. + sx, sy = H / 128, W / 128 + inds_x = (inds_x * sx + torch.rand(B, N, device=device) * sx).long().clamp(max=H - 1) + inds_y = (inds_y * sy + torch.rand(B, N, device=device) * sy).long().clamp(max=W - 1) + inds = inds_x * W + inds_y + + results['inds_coarse'] = inds_coarse # need this when updating error_map + + i = torch.gather(i, -1, inds) + j = torch.gather(j, -1, inds) + + results['inds'] = inds + + else: + inds = torch.arange(H*W, device=device).expand([B, H*W]) + + zs = - torch.ones_like(i) + xs = - (i - cx) / fx * zs + ys = (j - cy) / fy * zs + directions = torch.stack((xs, ys, zs), dim=-1) + # directions = safe_normalize(directions) + rays_d = directions @ poses[:, :3, :3].transpose(-1, -2) # (B, N, 3) + + rays_o = poses[..., :3, 3] # [B, 3] + rays_o = rays_o[..., None, :].expand_as(rays_d) # [B, N, 3] + + results['rays_o'] = rays_o + results['rays_d'] = rays_d + + return results + + +def seed_everything(seed): + random.seed(seed) + os.environ['PYTHONHASHSEED'] = str(seed) + np.random.seed(seed) + torch.manual_seed(seed) + torch.cuda.manual_seed(seed) + #torch.backends.cudnn.deterministic = True + #torch.backends.cudnn.benchmark = True + + +def save_tensor2image(x: torch.Tensor, path, channel_last=False, quality=75, **kwargs): + # assume the input x is channel last + if x.ndim == 4 and channel_last: + x = x.permute(0, 3, 1, 2) + TF.to_pil_image(make_grid(x, value_range=(0, 1), **kwargs)).save(path, quality=quality) + +@torch.jit.script +def linear_to_srgb(x): + return torch.where(x < 0.0031308, 12.92 * x, 1.055 * x ** 0.41666 - 0.055) + + +@torch.jit.script +def srgb_to_linear(x): + return torch.where(x < 0.04045, x / 12.92, ((x + 0.055) / 1.055) ** 2.4) + + +def nonzero_normalize_depth(depth, mask=None): + if mask is not None: + if (depth[mask]>0).sum() > 0: + nonzero_depth_min = depth[mask][depth[mask]>0].min() + else: + nonzero_depth_min = 0 + else: + if (depth>0).sum() > 0: + nonzero_depth_min = depth[depth>0].min() + else: + nonzero_depth_min = 0 + if nonzero_depth_min == 0: + return depth + else: + depth = (depth - nonzero_depth_min) / depth.max() + return depth.clamp(0, 1) + + +class Trainer(object): + def __init__(self, + argv, # command line args + name, # name of this experiment + opt, # extra conf + model, # network + guidance, # guidance network + criterion=None, # loss function, if None, assume inline implementation in train_step + optimizer=None, # optimizer + ema_decay=None, # if use EMA, set the decay + lr_scheduler=None, # scheduler + metrics=[], # metrics for evaluation, if None, use val_loss to measure performance, else use the first metric. + local_rank=0, # which GPU am I + world_size=1, # total num of GPUs + device=None, # device to use, usually setting to None is OK. (auto choose device) + mute=False, # whether to mute all print + fp16=False, # amp optimize level + max_keep_ckpt=1, # max num of saved ckpts in disk + workspace='workspace', # workspace to save logs & ckpts + best_mode='min', # the smaller/larger result, the better + use_loss_as_metric=True, # use loss as the first metric + report_metric_at_train=False, # also report metrics at training + use_checkpoint="latest", # which ckpt to use at init time + use_tensorboard=True, # whether to use tensorboard for logging + scheduler_update_every_step=False, # whether to call scheduler.step() after every train step + ): + + self.argv = argv + self.name = name + self.opt = opt + self.mute = mute + self.metrics = metrics + self.local_rank = local_rank + self.world_size = world_size + self.workspace = workspace + self.ema_decay = ema_decay + self.fp16 = fp16 + self.best_mode = best_mode + self.use_loss_as_metric = use_loss_as_metric + self.report_metric_at_train = report_metric_at_train + self.max_keep_ckpt = max_keep_ckpt + self.use_checkpoint = use_checkpoint + self.use_tensorboard = use_tensorboard + self.time_stamp = time.strftime("%Y-%m-%d_%H-%M-%S") + self.scheduler_update_every_step = scheduler_update_every_step + self.device = device if device is not None else torch.device(f'cuda:{local_rank}' if torch.cuda.is_available() else 'cpu') + self.console = Console() + + model.to(self.device) + if self.world_size > 1: + model = torch.nn.SyncBatchNorm.convert_sync_batchnorm(model) + model = torch.nn.parallel.DistributedDataParallel(model, device_ids=[local_rank]) + self.model = model + + # guide model + self.guidance = guidance + self.embeddings = {} + + # text prompt / images + if self.guidance is not None: + for key in self.guidance: + for p in self.guidance[key].parameters(): + p.requires_grad = False + self.embeddings[key] = {} + self.prepare_embeddings() + + if isinstance(criterion, nn.Module): + criterion.to(self.device) + self.criterion = criterion + + if optimizer is None: + self.optimizer = optim.Adam(self.model.parameters(), lr=0.001, weight_decay=5e-4) # naive adam + else: + self.optimizer = optimizer(self.model) + + if lr_scheduler is None: + self.lr_scheduler = optim.lr_scheduler.LambdaLR(self.optimizer, lr_lambda=lambda epoch: 1) # fake scheduler + else: + self.lr_scheduler = lr_scheduler(self.optimizer) + + if ema_decay: + self.ema = ExponentialMovingAverage( + self.model.parameters(), decay=ema_decay) + else: + self.ema = None + + self.scaler = torch.cuda.amp.GradScaler(enabled=self.fp16) + + # variable init + self.total_train_t = 0 + self.epoch = 0 + self.global_step = 0 + self.local_step = 0 + self.novel_view_step = 0 + self.stats = { + "loss": [], + "valid_loss": [], + "results": [], # metrics[0], or valid_loss + "checkpoints": [], # record path of saved ckpt, to automatically remove old ckpt + "best_result": None, + } + self.loss_meter = AverageMeters() + # auto fix + if len(metrics) == 0 or self.use_loss_as_metric: + self.best_mode = 'min' + + logger.info(f'[INFO] cmdline: {self.argv}') + logger.info(f'args:\n{self.opt}') + logger.info( + f'[INFO] Trainer: {self.name} | {self.time_stamp} | {self.device} | {"fp16" if self.fp16 else "fp32"} | {self.workspace}') + logger.info( + f'[INFO] #parameters: {sum([p.numel() for p in model.parameters() if p.requires_grad])}') + logger.info(f'[INFO] #Optimizer: \n{self.optimizer}') + logger.info(f'[INFO] #Scheduler: \n{self.lr_scheduler}') + + if self.workspace is not None: + if self.use_checkpoint == "scratch": + logger.info("[INFO] Training from scratch ...") + elif self.use_checkpoint == "latest": + logger.info("[INFO] Loading latest checkpoint ...") + self.load_checkpoint() + elif self.use_checkpoint == "latest_model": + logger.info("[INFO] Loading latest checkpoint (model only)...") + self.load_checkpoint(model_only=True) + elif self.use_checkpoint == "best": + if os.path.exists(self.opt.best_path): + logger.info("[INFO] Loading best checkpoint ...") + self.load_checkpoint(self.opt.best_path) + else: + logger.info( + f"[INFO] {self.opt.best_path} not found, loading latest ...") + self.load_checkpoint() + else: # path to ckpt + logger.info(f"[INFO] Loading {self.use_checkpoint} ...") + self.load_checkpoint(self.use_checkpoint) + + # calculate the text embs. + @torch.no_grad() + def prepare_embeddings(self): + + # text embeddings (stable-diffusion) + if self.opt.text is not None: + + dir_texts = ['front', 'side', 'back'] + if 'SD' in self.guidance: + self.embeddings['SD']['default'] = self.guidance['SD'].get_all_text_embeds([self.opt.text]) + neg_embedding = self.guidance['SD'].get_all_text_embeds([self.opt.negative]) + + for idx, d in enumerate(dir_texts): + text = f"{self.opt.text}, {d} view" + self.embeddings['SD'][d] = self.guidance['SD'].get_all_text_embeds([text]) + if self.opt.dir_texts_neg: + text_neg = self.opt.negative + ', '.join([text+' view' for i, text in enumerate(dir_texts) if i != idx]) + logger.info(f'dir_texts of {d}\n postive text: {text},\n negative text: {text_neg}') + neg_embedding= self.guidance['SD'].get_all_text_embeds([text_neg]) + self.embeddings['SD'][d] = torch.cat((neg_embedding, self.embeddings['SD'][d]), dim=0) + + if 'IF' in self.guidance: + self.embeddings['IF']['default'] = self.guidance['IF'].get_text_embeds([self.opt.text]) + neg_embedding = self.guidance['IF'].get_text_embeds([self.opt.negative]) + + for idx, d in enumerate(dir_texts): + text = f"{self.opt.text}, {d} view" + self.embeddings['IF'][d] = self.guidance['IF'].get_text_embeds([text]) + if self.opt.dir_texts_neg: + text_neg = self.opt.negative + ', '.join([text+' view' for i, text in enumerate(dir_texts) if i != idx]) + logger.info(f'dir_texts of {d}\n postive text: {text},\n negative text: {text_neg}') + neg_embedding= self.guidance['IF'].get_all_text_embeds([text_neg]) + self.embeddings['IF'][d] = torch.cat((neg_embedding, self.embeddings['IF'][d]), dim=0) + + # if 'clip' in self.guidance: + # self.embeddings['clip']['text'] = self.guidance['clip'].get_text_embeds(self.opt.text) + + if self.opt.images is not None: + + h = int(self.opt.known_view_scale * self.opt.h) + w = int(self.opt.known_view_scale * self.opt.w) + + # load processed image and remove edges + rgbas = [] + rgbas_hw = [] + mask_no_edges = [] + for image in self.opt.images: + rgba = cv2.cvtColor(cv2.imread(image, cv2.IMREAD_UNCHANGED), cv2.COLOR_BGRA2RGBA) + rgbas.append(rgba) + rgba_hw = cv2.resize(rgba, (w, h), interpolation=cv2.INTER_AREA).astype(np.float32) / 255 + rgbas_hw.append(rgba_hw) + if self.opt.rm_edge: + alpha = np.uint8(rgba_hw[..., 3] * 255.) + dilate = cv2.dilate(alpha, np.ones((self.opt.edge_width, self.opt.edge_width), np.uint8)) + edge = cv2.absdiff(alpha, dilate).astype(np.float32) / 255 + mask_no_edge = rgba_hw[..., 3] > 0.5 + mask_no_edge[edge>self.opt.edge_threshold] = False + mask_no_edges.append(mask_no_edge) + rgba_hw = np.stack(rgbas_hw) + mask = rgba_hw[..., 3] > 0.5 + if len(mask_no_edges) > 0: + mask_no_edge = np.stack(mask_no_edges) + else: + mask_no_edge = mask + + # breakpoint() + # rgb + rgb_hw = rgba_hw[..., :3] * rgba_hw[..., 3:] + (1 - rgba_hw[..., 3:]) + self.rgb = torch.from_numpy(rgb_hw).permute(0,3,1,2).contiguous().to(self.device) + self.mask = torch.from_numpy(mask).to(self.device) + self.opacity = torch.from_numpy(mask_no_edge).to(self.device).to(torch.float32).unsqueeze(0) + print(f'[INFO] dataset: load image prompt {self.opt.images} {self.rgb.shape}') + + # load depth + depth_paths = [image.replace('rgba', 'depth') for image in self.opt.images] + if os.path.exists(depth_paths[0]): + depths = [cv2.imread(depth_path, cv2.IMREAD_UNCHANGED) for depth_path in depth_paths] + depth = np.stack([cv2.resize(depth, (w, h), interpolation=cv2.INTER_AREA) for depth in depths]) + self.depth = 1 - torch.from_numpy(depth.astype(np.float32) / 255).to(self.device) + if len(self.depth.shape) == 4 and self.depth.shape[-1] > 1: + self.depth = self.depth[..., 0] + logger.info(f'[WARN] dataset: {depth_paths[0]} has more than one channel, only use the first channel') + if self.opt.normalize_depth: + self.depth = nonzero_normalize_depth(self.depth, self.mask) + save_tensor2image(self.depth, os.path.join(self.workspace, 'depth_resized.jpg')) + self.depth = self.depth[self.mask] + print(f'[INFO] dataset: load depth prompt {depth_paths} {self.depth.shape}') + else: + self.depth = None + logger.info(f'[WARN] dataset: {depth_paths[0]} is not found') + + # load normal + normal_paths = [image.replace('rgba', 'normal') for image in self.opt.images] + if os.path.exists(normal_paths[0]): + normals = [] + for normal_path in normal_paths: + normal = cv2.imread(normal_path, cv2.IMREAD_UNCHANGED) + if normal.shape[-1] == 4: + normal = cv2.cvtColor(normal, cv2.COLOR_BGRA2RGB) + normals.append(normal) + normal = np.stack([cv2.resize(normal, (w, h), interpolation=cv2.INTER_AREA) for normal in normals]) + self.normal = torch.from_numpy(normal.astype(np.float32) / 255).to(self.device) + save_tensor2image(self.normal, os.path.join(self.workspace, 'normal_resized.jpg'), channel_last=True) + print(f'[INFO] dataset: load normal prompt {normal_paths} {self.normal.shape}') + self.normal = self.normal[self.mask] + else: + self.normal = None + logger.info(f'[WARN] dataset: {normal_paths[0]} is not found') + + # save for debug + save_tensor2image(self.rgb, os.path.join(self.workspace, 'rgb_resized.png'), channel_last=False) + save_tensor2image(self.opacity, os.path.join(self.workspace, 'opacity_resized.png'), channel_last=False) + + # encode embeddings for zero123 + if 'zero123' in self.guidance: + rgba_256 = np.stack([cv2.resize(rgba, (256, 256), interpolation=cv2.INTER_AREA).astype(np.float32) / 255 for rgba in rgbas]) + rgbs_256 = rgba_256[..., :3] * rgba_256[..., 3:] + (1 - rgba_256[..., 3:]) + rgb_256 = torch.from_numpy(rgbs_256).permute(0,3,1,2).contiguous().to(self.device) + guidance_embeds = self.guidance['zero123'].get_img_embeds(rgb_256) + self.embeddings['zero123']['default'] = { + 'zero123_ws' : self.opt.zero123_ws, + 'c_crossattn' : guidance_embeds[0], + 'c_concat' : guidance_embeds[1], + 'ref_polars' : self.opt.ref_polars, + 'ref_azimuths' : self.opt.ref_azimuths, + 'ref_radii' : self.opt.ref_radii, + } + + # if 'clip' in self.guidance: + # self.embeddings['clip']['image'] = self.guidance['clip'].get_img_embeds(self.rgb) + # encoder image for clip + if self.opt.use_clip: + self.rgb_clip_embed = self.guidance.get_clip_img_embeds(self.rgb) + # debug. + scaler = torch.cuda.amp.GradScaler() + image = torch.randn((1,3,512,512), device=self.device, requires_grad=True) + with torch.autocast(device_type='cuda', dtype=torch.float16): + loss = self.guidance.clip_loss(self.rgb_clip_embed, image) + scaler.scale(loss).backward() + else: + self.rgb_clip_embed = None + + + # ------------------------------ + @torch.no_grad() + def match_known(self, **kwargs): + self.model.eval() + data = self.default_view_data + rays_o = data['rays_o'] # [B, N, 3] + rays_d = data['rays_d'] # [B, N, 3] + mvp = data['mvp'] # [B, 4, 4] + + B, N = rays_o.shape[:2] + H, W = data['H'], data['W'] + + ambient_ratio = 1.0 + shading = self.opt.known_shading + binarize = False + bg_color = self.get_bg_color( + self.opt.bg_color_known, B*N, rays_o.device) + + # add camera noise to avoid grid-like artifect + # * (1 - self.global_step / self.opt.iters) + noise_scale = self.opt.known_view_noise_scale + rays_o = rays_o + torch.randn(3, device=self.device) * noise_scale + rays_d = rays_d + torch.randn(3, device=self.device) * noise_scale + + outputs = self.model.render(rays_o, rays_d, mvp, H, W, staged=False, perturb=True, + bg_color=bg_color, ambient_ratio=ambient_ratio, shading=shading, binarize=binarize) + pred_rgb = outputs['image'].reshape(B, H, W, 3).permute( + 0, 3, 1, 2).contiguous() # [1, 3, H, W] + pred_mask = outputs['weights_sum'].reshape(B, 1, H, W) + + rgb_loss = self.opt.lambda_rgb * \ + F.mse_loss(pred_rgb*self.opacity, + self.rgb*self.opacity) + mask_loss = self.opt.lambda_mask * \ + F.mse_loss(pred_mask, self.mask.to(torch.float32).unsqueeze(0)) + return pred_rgb, pred_mask, rgb_loss, mask_loss + + def get_bg_color(self, bg_type, N, device): + if bg_type is None: + return None + elif isinstance(bg_type, str): + if bg_type == 'pixelnoise': + bg_color = torch.rand((N, 3), device=device) + elif bg_type == 'noise': + bg_color = torch.rand((1, 3), device=device).repeat(N, 1) + elif bg_type == 'white': + bg_color = torch.ones((N, 3), device=device) + return bg_color + elif isinstance(bg_type, Tensor): + bg_color = bg_color.to(device) + return bg_color + else: + raise NotImplementedError(f"{bg_type} is not implemented") + + # def margin_rank_loss(self, depth): + # # high res, only calc on fg + # output = depth.squeeze().view(-1) + # output = output[self.fg_idx] + # num = output.shape[0] # [n, 1] + # # print(num) + # output = output.reshape(1, -1) + # o1 = output.expand(num, -1).reshape(-1) + # o2 = output.T.expand(-1, num).reshape(-1) + # return F.margin_ranking_loss(o1, o2, self.rank_loss_target) + + def train_step(self, data): + # perform RGBD loss instead of SDS if is image-conditioned + do_rgbd_loss = self.opt.images is not None and \ + (self.global_step < self.opt.known_iters) or (self.global_step % self.opt.known_view_interval == 0) + + # override random camera with fixed known camera + if do_rgbd_loss: + data = self.default_view_data + + # progressively relaxing view range + if self.opt.progressive_view: + r = min(1.0, 0.2 + self.global_step / (0.5 * self.opt.iters)) + self.opt.phi_range = [self.opt.default_azimuth * (1 - r) + self.opt.full_phi_range[0] * r, + self.opt.default_azimuth * (1 - r) + self.opt.full_phi_range[1] * r] + self.opt.theta_range = [self.opt.default_polar * (1 - r) + self.opt.full_theta_range[0] * r, + self.opt.default_polar * (1 - r) + self.opt.full_theta_range[1] * r] + self.opt.radius_range = [self.opt.default_radius * (1 - r) + self.opt.full_radius_range[0] * r, + self.opt.default_radius * (1 - r) + self.opt.full_radius_range[1] * r] + self.opt.fovy_range = [self.opt.default_fovy * (1 - r) + self.opt.full_fovy_range[0] * r, + self.opt.default_fovy * (1 - r) + self.opt.full_fovy_range[1] * r] + + # progressively increase max_level + if self.opt.progressive_level: + self.model.max_level = min(1.0, 0.25 + self.global_step / (0.5 * self.opt.iters)) + + rays_o = data['rays_o'] # [B, N, 3] + rays_d = data['rays_d'] # [B, N, 3] + mvp = data['mvp'] # [B, 4, 4] + + B, N = rays_o.shape[:2] + H, W = data['H'], data['W'] + + # When ref_data has B images > opt.batch_size + if B > self.opt.batch_size: + # choose batch_size images out of those B images + choice = torch.randperm(B)[:self.opt.batch_size] + B = self.opt.batch_size + rays_o = rays_o[choice] + rays_d = rays_d[choice] + mvp = mvp[choice] + + if do_rgbd_loss: + ambient_ratio = 1.0 + shading = 'lambertian' # use lambertian instead of albedo to get normal + as_latent = False + binarize = False + bg_color = self.get_bg_color( + self.opt.bg_color_known, B*N, rays_o.device) + + # add camera noise to avoid grid-like artifact + if self.opt.known_view_noise_scale > 0: + noise_scale = self.opt.known_view_noise_scale #* (1 - self.global_step / self.opt.iters) + rays_o = rays_o + torch.randn(3, device=self.device) * noise_scale + rays_d = rays_d + torch.randn(3, device=self.device) * noise_scale + + elif self.global_step < (self.opt.latent_iter_ratio * self.opt.iters): + ambient_ratio = 1.0 + shading = 'normal' + as_latent = True + binarize = False + bg_color = None + + else: + if self.global_step < (self.opt.normal_iter_ratio * self.opt.iters): + ambient_ratio = 1.0 + shading = 'normal' + elif self.global_step < (self.opt.textureless_iter_ratio * self.opt.iters): + ambient_ratio = 0.1 + 0.9 * random.random() + shading = 'textureless' + elif self.global_step < (self.opt.albedo_iter_ratio * self.opt.iters): + ambient_ratio = 1.0 + shading = 'albedo' + else: + # random shading + ambient_ratio = 0.1 + 0.9 * random.random() + rand = random.random() + if rand > 0.8: + shading = 'textureless' + else: + shading = 'lambertian' + + as_latent = False + + # random weights binarization (like mobile-nerf) [NOT WORKING NOW] + # binarize_thresh = min(0.5, -0.5 + self.global_step / self.opt.iters) + # binarize = random.random() < binarize_thresh + binarize = False + + # random background + rand = random.random() + if self.opt.bg_radius > 0 and rand > 0.5: + bg_color = None # use bg_net + else: + bg_color = torch.rand(3).to(self.device) # single color random bg + + outputs = self.model.render(rays_o, rays_d, mvp, H, W, staged=False, perturb=True, bg_color=bg_color, ambient_ratio=ambient_ratio, shading=shading, binarize=binarize) + pred_depth = outputs['depth'].reshape(B, 1, H, W) + if self.opt.normalize_depth: + pred_depth = nonzero_normalize_depth(pred_depth) + pred_mask = outputs['weights_sum'].reshape(B, 1, H, W) + if 'normal_image' in outputs: + pred_normal = outputs['normal_image'].reshape(B, H, W, 3) + else: + pred_normal = None + + if as_latent: + # abuse normal & mask as latent code for faster geometry initialization (ref: fantasia3D) + pred_rgb = torch.cat([outputs['image'], outputs['weights_sum'].unsqueeze(-1)], dim=-1).reshape(B, H, W, 4).permute(0, 3, 1, 2).contiguous() # [B, 4, H, W] + else: + pred_rgb = outputs['image'].reshape(B, H, W, 3).permute(0, 3, 1, 2).contiguous() # [B, 3, H, W] + out_dict = { + 'rgb': pred_rgb, + 'depth': pred_depth, + 'mask': pred_mask, + 'normal': pred_normal, + } + + # Loss + # known view loss + loss_rgb, loss_mask, loss_normal, loss_depth, loss_sds, loss_if, loss_zero123, loss_clip, loss_entropy, loss_opacity, loss_orient, loss_smooth, loss_smooth2d, loss_smooth3d, loss_mesh_normal, loss_mesh_lap = torch.zeros(16, device=self.device) + # known view loss + if do_rgbd_loss: + gt_mask = self.mask # [B, H, W] + gt_rgb = self.rgb # [B, 3, H, W] + gt_opacity = self.opacity # [B, 1, H, W] + gt_normal = self.normal # [B, H, W, 3] + gt_depth = self.depth # [B, H, W] + + if len(gt_rgb) > self.opt.batch_size: + gt_mask = gt_mask[choice] + gt_rgb = gt_rgb[choice] + gt_opacity = gt_opacity[choice] + gt_normal = gt_normal[choice] + gt_depth = gt_depth[choice] + + # color loss + loss_rgb = self.opt.lambda_rgb * \ + F.mse_loss(pred_rgb*gt_opacity, gt_rgb*gt_opacity) + + # mask loss + loss_mask = self.opt.lambda_mask * F.mse_loss(pred_mask, gt_mask.to(torch.float32).unsqueeze(0)) + + # normal loss + if self.opt.lambda_normal > 0 and 'normal_image' in outputs and self.normal is not None: + pred_normal = pred_normal[self.mask] + lambda_normal = self.opt.lambda_normal * \ + min(1, self.global_step / self.opt.iters) + loss_normal = lambda_normal * \ + (1 - F.cosine_similarity(pred_normal, self.normal).mean())/2 + + # relative depth loss + if self.opt.lambda_depth > 0 and self.depth is not None: + valid_pred_depth = pred_depth[:, 0][self.mask] + loss_depth = self.opt.lambda_depth * (1 - pearson_corrcoef(valid_pred_depth, self.depth))/2 + + loss = loss_rgb + loss_mask + loss_normal + loss_depth + # novel view loss + else: + save_guidance_path = os.path.join(self.opt.workspace, 'guidance', f'train_step{self.global_step}_guidance.jpg') if self.opt.save_guidance_every > 0 and self.novel_view_step % self.opt.save_guidance_every ==0 else None + if 'SD' in self.guidance: + # interpolate text_z + azimuth = data['azimuth'] # [-180, 180] + + # ENHANCE: remove loop to handle batch size > 1 + text_z = [] + for b in range(azimuth.shape[0]): + if azimuth[b] >= -90 and azimuth[b] < 90: + if azimuth[b] >= 0: + r = 1 - azimuth[b] / 90 + else: + r = 1 + azimuth[b] / 90 + start_z = self.embeddings['SD']['front'] + end_z = self.embeddings['SD']['side'] + else: + if azimuth[b] >= 0: + r = 1 - (azimuth[b] - 90) / 90 + else: + r = 1 + (azimuth[b] + 90) / 90 + start_z = self.embeddings['SD']['side'] + end_z = self.embeddings['SD']['back'] + text_z.append(r * start_z + (1 - r) * end_z) + text_z = torch.stack(text_z, dim=0).transpose(0, 1).flatten(0, 1) + text_z_sds = text_z[:, :-1] + loss_sds, _ = self.guidance['SD'].train_step(text_z_sds, pred_rgb, as_latent=as_latent, guidance_scale=self.opt.guidance_scale['SD'], grad_scale=self.opt.lambda_guidance['SD'], + density=pred_mask if self.opt.gudiance_spatial_weighting else None, + save_guidance_path=save_guidance_path + ) + # if self.opt.lambda_clip > 0: + # lambda_clip = 10 * (1 - abs(azimuth) / 180) * self.opt.lambda_clip + # if self.opt.clip_image_loss: + # loss_clip = lambda_clip * self.guidance.clip_loss(self.rgb_clip_embed, pred_rgb) + # else: + # loss_clip = lambda_clip * self.guidance.clip_loss(text_z_clip, pred_rgb) + + if 'IF' in self.guidance: + # interpolate text_z + azimuth = data['azimuth'] # [-180, 180] + + # ENHANCE: remove loop to handle batch size > 1 + # ENHANCE: remove loop to handle batch size > 1 + text_z = [] + for b in range(azimuth.shape[0]): + if azimuth[b] >= -90 and azimuth[b] < 90: + if azimuth[b] >= 0: + r = 1 - azimuth[b] / 90 + else: + r = 1 + azimuth[b] / 90 + start_z = self.embeddings['IF']['front'] + end_z = self.embeddings['IF']['side'] + else: + if azimuth[b] >= 0: + r = 1 - (azimuth[b] - 90) / 90 + else: + r = 1 + (azimuth[b] + 90) / 90 + start_z = self.embeddings['IF']['side'] + end_z = self.embeddings['IF']['back'] + text_z.append(r * start_z + (1 - r) * end_z) + text_z = torch.stack(text_z, dim=0).transpose(0, 1).flatten(0, 1) + text_z = torch.cat(text_z, dim=1).reshape(B, 2, start_z.shape[-2]-1, start_z.shape[-1]).transpose(0, 1).flatten(0, 1) + loss_if = self.guidance['IF'].train_step(text_z, pred_rgb, guidance_scale=self.opt.guidance_scale['IF'], grad_scale=self.opt.lambda_guidance['IF']) + + if 'zero123' in self.guidance: + + polar = data['polar'] + azimuth = data['azimuth'] + radius = data['radius'] + + loss_zero123 = self.guidance['zero123'].train_step(self.embeddings['zero123']['default'], pred_rgb, polar, azimuth, radius, guidance_scale=self.opt.guidance_scale['zero123'], + as_latent=as_latent, grad_scale=self.opt.lambda_guidance['zero123'], save_guidance_path=save_guidance_path) + + if 'clip' in self.guidance: + + # empirical, far view should apply smaller CLIP loss + lambda_guidance = 10 * (1 - abs(azimuth) / 180) * self.opt.lambda_guidance['clip'] + loss_clip = self.guidance['clip'].train_step(self.embeddings['clip'], pred_rgb, grad_scale=lambda_guidance) + loss = loss_sds + loss_if + loss_zero123 + loss_clip + + # regularizations + if not self.opt.dmtet: + + if self.opt.lambda_opacity > 0: + loss_opacity = self.opt.lambda_opacity * (outputs['weights_sum'] ** 2).mean() + + if self.opt.lambda_entropy > 0: + lambda_entropy = self.opt.lambda_entropy * \ + min(1, 2 * self.global_step / self.opt.iters) + alphas = outputs['weights'].clamp(1e-5, 1 - 1e-5) + # alphas = alphas ** 2 # skewed entropy, favors 0 over 1 + loss_entropy = lambda_entropy * (- alphas * torch.log2(alphas) - + (1 - alphas) * torch.log2(1 - alphas)).mean() + + if self.opt.lambda_normal_smooth > 0 and 'normal_image' in outputs: + pred_vals = outputs['normal_image'].reshape(B, H, W, 3) + # total-variation + loss_smooth = (pred_vals[:, 1:, :, :] - pred_vals[:, :-1, :, :]).square().mean() + \ + (pred_vals[:, :, 1:, :] - + pred_vals[:, :, :-1, :]).square().mean() + loss_smooth = self.opt.lambda_normal_smooth * loss_smooth + + if self.opt.lambda_normal_smooth2d > 0 and 'normal_image' in outputs: + pred_vals = outputs['normal_image'].reshape( + B, H, W, 3).permute(0, 3, 1, 2).contiguous() + smoothed_vals = TF.gaussian_blur(pred_vals, kernel_size=9) + loss_smooth2d = self.opt.lambda_normal_smooth2d * F.mse_loss(pred_vals, smoothed_vals) + + if self.opt.lambda_orient > 0 and 'loss_orient' in outputs: + loss_orient = self.opt.lambda_orient * outputs['loss_orient'] + + if self.opt.lambda_3d_normal_smooth > 0 and 'loss_normal_perturb' in outputs: + loss_smooth3d = self.opt.lambda_3d_normal_smooth * outputs['loss_normal_perturb'] + + loss += loss_opacity + loss_entropy + loss_smooth + loss_smooth2d + loss_orient + loss_smooth3d + + else: + if self.opt.lambda_mesh_normal > 0: + loss_mesh_normal = self.opt.lambda_mesh_normal * \ + outputs['loss_normal'] + + if self.opt.lambda_mesh_lap > 0: + loss_mesh_lap = self.opt.lambda_mesh_lap * outputs['loss_lap'] + loss += loss_mesh_normal + loss_mesh_lap + + losses_dict = { + 'loss': loss.item(), + 'loss_sds': loss_sds.item(), + 'loss_if': loss_if.item(), + 'loss_zero123': loss_zero123.item(), + 'loss_clip': loss_clip.item(), + 'loss_rgb': loss_rgb.item(), + 'loss_mask': loss_mask.item(), + 'loss_normal': loss_normal.item(), + 'loss_depth': loss_depth.item(), + 'loss_opacity': loss_opacity.item(), + 'loss_entropy': loss_entropy.item(), + 'loss_smooth': loss_smooth.item(), + 'loss_smooth2d': loss_smooth2d.item(), + 'loss_smooth3d': loss_smooth3d.item(), + 'loss_orient': loss_orient.item(), + 'loss_mesh_normal': loss_mesh_normal.item(), + 'loss_mesh_lap': loss_mesh_lap.item(), + } + # if loss_guidance_dict: + # for key, val in loss_guidance_dict.items(): + # losses_dict[key] = val.item() if isinstance(val, torch.Tensor) else val + + if 'normal' in out_dict: + out_dict['normal'] = out_dict['normal'].permute(0, 3, 1, 2).contiguous() + + # save for debug purpose + if self.opt.save_train_every > 0 and self.global_step % self.opt.save_train_every == 0: + image_save_path = os.path.join(self.workspace, 'train_debug',) + os.makedirs(image_save_path, exist_ok=True) + for key, value in out_dict.items(): + if value is not None: + value = ((value - value.min()) / (value.max() - value.min() + 1e-6)).detach().mul(255).to(torch.uint8) + try: + save_tensor2image(value, os.path.join(image_save_path, f'train_{self.global_step:06d}_{key}.jpg'), channel_last=False) + except: + pass + return loss, losses_dict, out_dict + + def post_train_step(self): + + # unscale grad before modifying it! + # ref: https://pytorch.org/docs/stable/notes/amp_examples.html#gradient-clipping + self.scaler.unscale_(self.optimizer) + + # clip grad + if self.opt.grad_clip >= 0: + torch.nn.utils.clip_grad_value_(self.model.parameters(), self.opt.grad_clip) + + if not self.opt.dmtet and self.opt.backbone == 'grid': + + if self.opt.lambda_tv > 0: + lambda_tv = min(1.0, self.global_step / (0.5 * self.opt.iters)) * self.opt.lambda_tv + self.model.encoder.grad_total_variation(lambda_tv, None, self.model.bound) + if self.opt.lambda_wd > 0: + self.model.encoder.grad_weight_decay(self.opt.lambda_wd) + + def eval_step(self, data): + + rays_o = data['rays_o'] # [B, N, 3] + rays_d = data['rays_d'] # [B, N, 3] + mvp = data['mvp'] + + B, N = rays_o.shape[:2] + H, W = data['H'], data['W'] + + shading = data['shading'] if 'shading' in data else 'lambertian' + ambient_ratio = data['ambient_ratio'] if 'ambient_ratio' in data else 1.0 + light_d = data['light_d'] if 'light_d' in data else None + + outputs = self.model.render(rays_o, rays_d, mvp, H, W, staged=True, perturb=False, bg_color=None, light_d=light_d, ambient_ratio=ambient_ratio, shading=shading) + pred_rgb = outputs['image'].reshape(B, H, W, 3) + pred_depth = outputs['depth'].reshape(B, H, W, 1) + if self.opt.normalize_depth: + pred_depth = nonzero_normalize_depth(pred_depth) + if 'normal_image' in outputs: + pred_normal = outputs['normal_image'].reshape(B, H, W, 3) + else: + pred_normal = None + out_dict = { + shading: pred_rgb, + 'depth': pred_depth, + 'normal_image': pred_normal, + } + # dummy + loss = torch.zeros([1], device=pred_rgb.device, dtype=pred_rgb.dtype) + return out_dict, loss + + def test_step(self, data, bg_color=None, perturb=False, shading='lambertian'): + rays_o = data['rays_o'] # [B, N, 3] + rays_d = data['rays_d'] # [B, N, 3] + mvp = data['mvp'] + + B, N = rays_o.shape[:2] + H, W = data['H'], data['W'] + + bg_color = self.get_bg_color(bg_color, B*N, rays_o.device) + + shading = data['shading'] if 'shading' in data else shading + ambient_ratio = data['ambient_ratio'] if 'ambient_ratio' in data else 1.0 + light_d = data['light_d'] if 'light_d' in data else None + + outputs = self.model.render(rays_o, rays_d, mvp, H, W, staged=True, perturb=perturb, light_d=light_d, ambient_ratio=ambient_ratio, shading=shading, bg_color=bg_color) + + pred_rgb = outputs['image'].reshape(B, H, W, 3) + pred_depth = outputs['depth'].reshape(B, H, W, 1) + pred_mask = outputs['weights_sum'].reshape(B, H, W, 1) + # if self.opt.normalize_depth: + pred_depth = nonzero_normalize_depth(pred_depth) + if 'normal_image' in outputs: + pred_normal = outputs['normal_image'].reshape(B, H, W, 3) + pred_normal = pred_normal * pred_mask + (1.0 - pred_mask) + else: + pred_normal = None + out_dict = { + shading: pred_rgb, + 'depth': pred_depth, + 'normal_image': pred_normal, + 'mask': pred_mask, + } + return out_dict + + def save_mesh(self, loader=None, save_path=None): + + if save_path is None: + save_path = os.path.join(self.workspace, 'mesh') + + logger.info(f"==> Saving mesh to {save_path}") + + os.makedirs(save_path, exist_ok=True) + + self.model.export_mesh(save_path, resolution=self.opt.mcubes_resolution, decimate_target=self.opt.decimate_target) + + logger.info(f"==> Finished saving mesh.") + + ### ------------------------------ + + def train(self, train_loader, valid_loader, test_loader, max_epochs): + + if self.use_tensorboard and self.local_rank == 0: + self.writer = SummaryWriter( + os.path.join(self.workspace, "run", self.name)) + + # init from nerf should be performed after Shap-E, since Shap-E will rescale dmtet + if self.opt.dmtet and (self.opt.init_ckpt and os.path.exists(self.opt.init_ckpt)): + reset_scale = False if self.opt.use_shape else True + old_sdf = self.model.get_sdf_from_nerf(reset_scale) + if not self.opt.tet_mlp: + self.model.dmtet.init_tet_from_sdf(old_sdf) + self.test(valid_loader, name=f'init_ckpt', write_video=False, save_each_frame=False, subfolder='check_init') + else: + old_sdf = None + + if self.opt.use_shape and self.opt.dmtet: + os.makedirs(os.path.join(self.opt.workspace, 'shape'), exist_ok=True) + best_loss = torch.inf + best_idx = 0 + for idx, (sdf, color) in enumerate(zip(self.opt.rpsts, self.opt.colors)): + self.model.init_tet_from_sdf_color(sdf) + pred_rgb, pred_mask, rgb_loss, mask_loss = self.match_known() + best_loss = min(best_loss, mask_loss) + if best_loss == mask_loss: + best_idx = idx + logger.info(f"==> Current best match shape known sdf idx: {best_idx}") + save_tensor2image(pred_mask, os.path.join(self.opt.workspace, 'shape', f"match_shape_known_{idx}_rgb.jpg"), channel_last=False) + self.test(valid_loader, name=f'idx_{idx}', write_video=False, save_each_frame=False, subfolder='check_init') + + sdf = self.opt.rpsts[best_idx] + self.model.init_tet_from_sdf_color(sdf, self.opt.colors[best_idx]) + self.test(valid_loader, name=f'shape_only', write_video=False, save_each_frame=False, subfolder='check_init') + + # Enable mixture model + if self.opt.base_mesh: + logger.info(f"==> Enable mixture model with base mesh {self.opt.base_mesh}") + mesh_sdf = self.model.dmtet.get_sdf_from_mesh(self.opt.base_mesh) + sdf = (mesh_sdf.clamp(0, 1) + sdf.clamp(0,1) ).clamp(0, 1) + + if old_sdf is not None: + sdf = (sdf.clamp(0, 1) + old_sdf.clamp(0, 1)).clamp(0, 1) + + self.model.init_tet_from_sdf_color(sdf, self.opt.colors[best_idx]) + self.test(valid_loader, name=f'shape_merge', write_video=False, save_each_frame=False, subfolder='check_init') + + del best_loss, best_idx, pred_rgb, pred_mask, rgb_loss, mask_loss + self.opt.rpsts = None + gc.collect() + torch.cuda.empty_cache() + + # init shape for NeRF. NOTE: Does not work yet.. in progress. + # if self.opt.use_shape and not self.opt.dmtet: + # os.makedirs(os.path.join(self.opt.workspace, 'shape'), exist_ok=True) + # best_loss = torch.inf + # best_idx = 0 + # for idx, (density, color) in enumerate(zip(self.opt.rpsts, self.opt.colors)): + # self.model.init_nerf_from_sdf_color(density, color, self.opt.points, lr=0.001) + # pred_rgb, pred_mask, rgb_loss, mask_loss = self.match_known() + # best_loss = min(best_loss, mask_loss) + # if best_loss == mask_loss: + # best_idx = idx + # logger.info(f"==> Current best match shape known sdf idx: {best_idx}") + # save_tensor2image(pred_mask, os.path.join(self.opt.workspace, 'shape', f"match_shape_known_{idx}_rgb.jpg"), channel_last=False) + # self.evaluate_one_epoch(valid_loader, f'idx_{idx}') + # self.model.init_nerf_from_sdf_color(self.opt.rpsts[best_idx], self.opt.colors[best_idx]) + # self.evaluate_one_epoch(valid_loader, f'init_from_shape_{idx}') + + # del best_loss, best_idx, pred_rgb, pred_mask, rgb_loss, mask_loss + # self.opt.rpsts = None + # self.opt.colors = None + # self.opt.points = None + # gc.collect() + # torch.cuda.empty_cache() + + start_t = time.time() + + for epoch in range(self.epoch + 1, max_epochs + 1): + self.epoch = epoch + + self.train_one_epoch(train_loader, max_epochs) + + if self.workspace is not None and self.local_rank == 0: + self.save_checkpoint(full=True, best=False) + + if self.epoch % self.opt.eval_interval == 0: + self.evaluate_one_epoch(valid_loader) + self.save_checkpoint(full=False, best=True) + + if self.epoch % self.opt.test_interval == 0 or self.epoch == max_epochs: + self.test(test_loader, img_folder='images' if self.epoch == max_epochs else f'images_ep{self.epoch:04d}') + + end_t = time.time() + + self.total_train_t = end_t - start_t + self.total_train_t + + logger.info(f"[INFO] training takes {(self.total_train_t)/ 60:.4f} minutes.") + + if self.use_tensorboard and self.local_rank == 0: + self.writer.close() + + def evaluate(self, loader, name=None): + self.use_tensorboard, use_tensorboard = False, self.use_tensorboard + self.evaluate_one_epoch(loader, name) + self.use_tensorboard = use_tensorboard + + def test(self, loader, save_path=None, name=None, + write_video=True, save_each_frame=True, shading='lambertian', + subfolder='results', img_folder='images' + ): + + if save_path is None: + save_path = os.path.join(self.workspace, subfolder) + image_save_path = os.path.join(self.workspace, subfolder, img_folder) + + if name is None: + name = f'{self.name}_ep{self.epoch:04d}' + + os.makedirs(save_path, exist_ok=True) + os.makedirs(image_save_path, exist_ok=True) + + logger.info(f"==> Start Test, saving {shading} results to {save_path}") + + pbar = tqdm.tqdm(total=len(loader) * loader.batch_size, bar_format='{percentage:3.0f}% {n_fmt}/{total_fmt} [{elapsed}<{remaining}, {rate_fmt}]') + self.model.eval() + + all_outputs = {} + with torch.no_grad(): + for i, data in enumerate(loader): + with torch.cuda.amp.autocast(enabled=self.fp16): + outputs = self.test_step(data, bg_color=self.opt.bg_color_test, shading=shading) + for key, value in outputs.items(): + if value is not None: + value = ((value - value.min()) / (value.max() - value.min() + 1e-6)).detach().mul(255).to(torch.uint8) + if save_each_frame: + save_tensor2image(value, os.path.join(image_save_path, f'{name}_{i:04d}_{key}.jpg'), channel_last=True) + if key not in all_outputs.keys(): + all_outputs[key] = [] + all_outputs[key].append(value) + pbar.update(loader.batch_size) + + for key, value in all_outputs.items(): + all_outputs[key] = torch.cat(value, dim=0) + + if write_video: + for key, value in all_outputs.items(): + # current version torchvision does not support writing a single-channel video + # torchvision.io.write_video(os.path.join(save_path, f'{name}_{key}.mp4'), all_outputs[key].detach().cpu(), fps=25) + imageio.mimwrite(os.path.join(save_path, f'{name}_{key}.mp4'), all_outputs[key].detach().cpu().numpy(), fps=25, quality=8, macro_block_size=1) + for key, value in all_outputs.items(): + save_tensor2image(value, os.path.join(save_path, f'{name}_{key}.jpg'), channel_last=True) + logger.info(f"==> Finished Test.") + + # [GUI] train text step. + def train_gui(self, train_loader, step=16): + + self.model.train() + + total_loss = torch.tensor([0], dtype=torch.float32, device=self.device) + + loader = iter(train_loader) + + for _ in range(step): + + # mimic an infinite loop dataloader (in case the total dataset is smaller than step) + try: + data = next(loader) + except StopIteration: + loader = iter(train_loader) + data = next(loader) + + # update grid every 16 steps + if self.model.cuda_ray and self.global_step % self.opt.update_extra_interval == 0: + with torch.cuda.amp.autocast(enabled=self.fp16): + self.model.update_extra_state() + + self.global_step += 1 + + self.optimizer.zero_grad() + + with torch.cuda.amp.autocast(enabled=self.fp16): + loss, loss_dicts, outputs = self.train_step(data) + + self.scaler.scale(loss).backward() + self.post_train_step() + self.scaler.step(self.optimizer) + self.scaler.update() + + if self.scheduler_update_every_step: + self.lr_scheduler.step() + + self.loss_meter.update(loss_dicts) + + if self.ema is not None: + self.ema.update() + + average_loss = self.loss_meter.meters['loss'].avg + + if not self.scheduler_update_every_step: + if isinstance(self.lr_scheduler, torch.optim.lr_scheduler.ReduceLROnPlateau): + self.lr_scheduler.step(average_loss) + else: + self.lr_scheduler.step() + + outputs = { + 'loss': average_loss, + 'lr': self.optimizer.param_groups[0]['lr'], + } + + return outputs + + + # [GUI] test on a single image + def test_gui(self, pose, intrinsics, mvp, W, H, bg_color=None, spp=1, downscale=1, light_d=None, ambient_ratio=1.0, shading='albedo'): + + # render resolution (may need downscale to for better frame rate) + rH = int(H * downscale) + rW = int(W * downscale) + intrinsics = intrinsics * downscale + + pose = torch.from_numpy(pose).unsqueeze(0).to(self.device) + mvp = torch.from_numpy(mvp).unsqueeze(0).to(self.device) + + rays = get_rays(pose, intrinsics, rH, rW, -1) + + # from degree theta/phi to 3D normalized vec + light_d = np.deg2rad(light_d) + light_d = np.array([ + np.sin(light_d[0]) * np.sin(light_d[1]), + np.cos(light_d[0]), + np.sin(light_d[0]) * np.cos(light_d[1]), + ], dtype=np.float32) + light_d = torch.from_numpy(light_d).to(self.device) + + data = { + 'rays_o': rays['rays_o'], + 'rays_d': rays['rays_d'], + 'mvp': mvp, + 'H': rH, + 'W': rW, + 'light_d': light_d, + 'ambient_ratio': ambient_ratio, + 'shading': shading, + } + + self.model.eval() + + if self.ema is not None: + self.ema.store() + self.ema.copy_to() + + with torch.no_grad(): + with torch.cuda.amp.autocast(enabled=self.fp16): + # here spp is used as perturb random seed! + outputs = self.test_step( + data, bg_color=bg_color, perturb=False if spp == 1 else spp) + + if self.ema is not None: + self.ema.restore() + + # interpolation to the original resolution + if downscale != 1: + # have to permute twice with torch... + outputs[shading] = F.interpolate(outputs[shading].permute(0, 3, 1, 2), size=( + H, W), mode='nearest').permute(0, 2, 3, 1).contiguous() + outputs['depth'] = F.interpolate(outputs['depth'].unsqueeze( + 1), size=(H, W), mode='nearest').squeeze(1) + + if outputs['normal_imagea'] is not None: + outputs['normal_image'] = F.interpolate(outputs['normal_image'].unsqueeze(1), size=(H, W), mode='nearest').squeeze(1) + + return outputs + + def train_one_epoch(self, loader, max_epochs): + logger.info(f"==> [{time.strftime('%Y-%m-%d_%H-%M-%S')}] Start Training {self.workspace} Epoch {self.epoch}/{max_epochs}, lr={self.optimizer.param_groups[0]['lr']:.6f} ...") + + if self.local_rank == 0 and self.report_metric_at_train: + for metric in self.metrics: + metric.clear() + + self.model.train() + + # distributedSampler: must call set_epoch() to shuffle indices across multiple epochs + # ref: https://pytorch.org/docs/stable/data.html + if self.world_size > 1: + loader.sampler.set_epoch(self.epoch) + + self.local_step = 0 + + for data in loader: + + # update grid every 16 steps + if (self.model.cuda_ray or self.model.taichi_ray) and self.global_step % self.opt.update_extra_interval == 0: + with torch.cuda.amp.autocast(enabled=self.fp16): + self.model.update_extra_state() + + # Update grid + if self.opt.grid_levels_mask > 0: + if self.global_step > self.opt.grid_levels_mask_iters: + self.model.grid_levels_mask = 0 + else: + self.model.grid_levels_mask = self.opt.grid_levels_mask + + self.local_step += 1 + self.global_step += 1 + + self.optimizer.zero_grad() + + with torch.cuda.amp.autocast(enabled=self.fp16): + loss, losses_dict, outputs = self.train_step(data) + + # hooked grad clipping for RGB space + if self.opt.grad_clip_rgb >= 0: + def _hook(grad): + if self.opt.fp16: + # correctly handle the scale + grad_scale = self.scaler._get_scale_async() + return grad.clamp(grad_scale * -self.opt.grad_clip_rgb, grad_scale * self.opt.grad_clip_rgb) + else: + return grad.clamp(-self.opt.grad_clip_rgb, self.opt.grad_clip_rgb) + outputs['rgb'].register_hook(_hook) + # if (self.global_step <= self.opt.known_iters or self.global_step % self.opt.known_view_interval == 0) and self.opt.image is not None and self.opt.joint_known_unknown and known_rgbs is not None: + # known_rgbs.register_hook(_hook) + # pred_rgbs.retain_grad() + + self.scaler.scale(loss).backward() + + self.post_train_step() + self.scaler.step(self.optimizer) + self.scaler.update() + + if self.scheduler_update_every_step: + self.lr_scheduler.step() + + self.loss_meter.update(losses_dict) + if self.local_rank == 0: + # if self.report_metric_at_train: + # for metric in self.metrics: + # metric.update(preds, truths) + + if self.use_tensorboard: + + for key, val in losses_dict.items(): + self.writer.add_scalar( + f"train/{key}", val, self.global_step) + + self.writer.add_scalar( + "train/lr", self.optimizer.param_groups[0]['lr'], self.global_step) + + if self.global_step % self.opt.log_every == 0: + strings = f"==> Train [Step] {self.global_step}/{self.opt.iters}" + for key, value in losses_dict.items(): + strings += f", {key}={value:.4f}" + logger.info(strings) + strings = f"==> Train [Avg] {self.global_step}/{self.opt.iters}" + for key in self.loss_meter.meters.keys(): + strings += f", {key}={self.loss_meter.meters[key].avg:.4f}" + logger.info(strings) + + if self.ema is not None: + self.ema.update() + + average_loss = self.loss_meter.meters['loss'].avg + self.stats["loss"].append(average_loss) + + if self.local_rank == 0: + # pbar.close() + if self.report_metric_at_train: + for metric in self.metrics: + logger.info(metric.report(), style="red") + if self.use_tensorboard: + metric.write(self.writer, self.epoch, prefix="train") + metric.clear() + + if not self.scheduler_update_every_step: + if isinstance(self.lr_scheduler, torch.optim.lr_scheduler.ReduceLROnPlateau): + self.lr_scheduler.step(average_loss) + else: + self.lr_scheduler.step() + + # Visualize Training + if self.local_rank == 0: + # save image + save_path = os.path.join( + self.workspace, 'training') + os.makedirs(save_path, exist_ok=True) + name = f'train_{self.name}_ep{self.epoch:04d}' + for key, value in outputs.items(): + save_tensor2image(value, os.path.join(save_path, f'{name}_{key}.jpg'), channel_last=False) + gpu_mem = get_GPU_mem()[0] + logger.info(f"==> [Finished Epoch {self.epoch}/{max_epochs}. GPU={gpu_mem:.1f}GB.") + + def evaluate_one_epoch(self, loader, name=None): + logger.info(f"++> Evaluate {self.workspace} at epoch {self.epoch} ...") + + if name is None: + name = f'{self.name}_ep{self.epoch:04d}' + + total_loss = 0 + if self.local_rank == 0: + for metric in self.metrics: + metric.clear() + + self.model.eval() + + if self.ema is not None: + self.ema.store() + self.ema.copy_to() + + if self.local_rank == 0: + pbar = tqdm.tqdm(total=len(loader) * loader.batch_size, bar_format='{desc}: {percentage:3.0f}% {n_fmt}/{total_fmt} [{elapsed}<{remaining}, {rate_fmt}]') + + with torch.no_grad(): + self.local_step = 0 + + all_outputs = {} + for data in loader: + self.local_step += 1 + + with torch.cuda.amp.autocast(enabled=self.fp16): + outputs, loss = self.eval_step(data) + + # all_gather/reduce the statistics (NCCL only support all_*) + if self.world_size > 1: + dist.all_reduce(loss, op=dist.ReduceOp.SUM) + loss = loss / self.world_size + + for key, value in outputs.items(): + if value is not None: + dist.all_gather(outputs[key]) + outputs[key] = torch.cat(outputs[key], dim=0) + + loss_val = loss.item() + total_loss += loss_val + + # only rank = 0 will perform evaluation. + if self.local_rank == 0: + + # save image + save_path = os.path.join( + self.workspace, 'validation') + + # logger.info(f"==> Saving validation image to {save_path}") + os.makedirs(save_path, exist_ok=True) + + for key, value in outputs.items(): + if value is not None: + value = ((value - value.min()) / (value.max() - value.min() + 1e-6)).detach().mul(255).to(torch.uint8) + # save_tensor2image(value, os.path.join(save_path, f'{name}_{self.local_step:04d}_{key}.jpg')) + if key not in all_outputs.keys(): + all_outputs[key] = [] + all_outputs[key].append(value) + + pbar.set_description( + f"loss={loss_val:.4f} ({total_loss/self.local_step:.4f})") + pbar.update(loader.batch_size) + + + average_loss = total_loss / self.local_step + self.stats["valid_loss"].append(average_loss) + + if self.local_rank == 0: + pbar.close() + if not self.use_loss_as_metric and len(self.metrics) > 0: + result = self.metrics[0].measure() + self.stats["results"].append(result if self.best_mode == 'min' else - result) # if max mode, use -result + else: + self.stats["results"].append(average_loss) # if no metric, choose best by min loss + + for metric in self.metrics: + logger.info(metric.report(), style="blue") + if self.use_tensorboard: + metric.write(self.writer, self.epoch, prefix="evaluate") + metric.clear() + + for key, value in all_outputs.items(): + all_outputs[key] = torch.cat(value, dim=0) + save_tensor2image(all_outputs[key], os.path.join(save_path, f'{name}_{key}.jpg'), channel_last=True) + if self.ema is not None: + self.ema.restore() + + logger.info(f"++> Evaluate epoch {self.epoch} Finished.") + + def save_checkpoint(self, name=None, full=False, best=False): + + if name is None: + name = f'{self.name}_ep{self.epoch:04d}' + + state = { + 'epoch': self.epoch, + 'global_step': self.global_step, + 'stats': self.stats, + } + + if self.model.cuda_ray: + state['mean_density'] = self.model.mean_density + + if self.opt.dmtet: + state['tet_scale'] = self.model.dmtet.tet_scale.cpu().numpy() + + if full: + state['optimizer'] = self.optimizer.state_dict() + state['lr_scheduler'] = self.lr_scheduler.state_dict() + state['scaler'] = self.scaler.state_dict() + if self.ema is not None: + state['ema'] = self.ema.state_dict() + + if not best: + + state['model'] = self.model.state_dict() + + file_path = f"{name}.pth" + + self.stats["checkpoints"].append(file_path) + + if len(self.stats["checkpoints"]) > self.max_keep_ckpt: + old_ckpt = os.path.join( + self.opt.ckpt_path, self.stats["checkpoints"].pop(0)) + if os.path.exists(old_ckpt): + os.remove(old_ckpt) + + torch.save(state, os.path.join(self.opt.ckpt_path, file_path)) + + else: + if len(self.stats["results"]) > 0: + # always save best since loss cannot reflect performance. + if True: + # logger.info(f"[INFO] New best result: {self.stats['best_result']} --> {self.stats['results'][-1]}") + # self.stats["best_result"] = self.stats["results"][-1] + + # save ema results + if self.ema is not None: + self.ema.store() + self.ema.copy_to() + + state['model'] = self.model.state_dict() + + if self.ema is not None: + self.ema.restore() + + torch.save(state, self.opt.best_path) + else: + logger.info( + f"[WARN] no evaluated results found, skip saving best checkpoint.") + + def load_checkpoint(self, checkpoint=None, model_only=False): + if checkpoint is None: + checkpoint_list = sorted(glob.glob(f'{self.opt.ckpt_path}/*.pth')) + if checkpoint_list: + checkpoint = checkpoint_list[-1] + logger.info(f"[INFO] Latest checkpoint is {checkpoint}") + else: + logger.info( + "[WARN] No checkpoint found, model randomly initialized.") + return + + checkpoint_dict = torch.load(checkpoint, map_location=self.device) + + if 'model' not in checkpoint_dict: + self.model.load_state_dict(checkpoint_dict) + logger.info("[INFO] loaded model.") + return + + missing_keys, unexpected_keys = self.model.load_state_dict(checkpoint_dict['model'], strict=False) + logger.info("[INFO] loaded model.") + if len(missing_keys) > 0: + logger.info(f"[WARN] missing keys: {missing_keys}") + if len(unexpected_keys) > 0: + logger.info(f"[WARN] unexpected keys: {unexpected_keys}") + + if self.ema is not None and 'ema' in checkpoint_dict: + try: + self.ema.load_state_dict(checkpoint_dict['ema']) + logger.info("[INFO] loaded EMA.") + except: + logger.info("[WARN] failed to loaded EMA.") + + if self.model.cuda_ray: + if 'mean_density' in checkpoint_dict: + self.model.mean_density = checkpoint_dict['mean_density'] + + if self.opt.dmtet: + if 'tet_scale' in checkpoint_dict: + new_scale = torch.from_numpy( + checkpoint_dict['tet_scale']).to(self.device) + self.model.dmtet.verts *= new_scale / self.model.dmtet.tet_scale + self.model.dmtet.tet_scale = new_scale + # self.model.init_tet() + if model_only: + return + + self.stats = checkpoint_dict['stats'] + self.epoch = checkpoint_dict['epoch'] + self.global_step = checkpoint_dict['global_step'] + logger.info( + f"[INFO] load at epoch {self.epoch}, global step {self.global_step}") + + if self.optimizer and 'optimizer' in checkpoint_dict: + try: + self.optimizer.load_state_dict(checkpoint_dict['optimizer']) + logger.info("[INFO] loaded optimizer.") + except: + logger.info("[WARN] Failed to load optimizer.") + + if self.lr_scheduler and 'lr_scheduler' in checkpoint_dict: + try: + self.lr_scheduler.load_state_dict(checkpoint_dict['lr_scheduler']) + logger.info("[INFO] loaded scheduler.") + except: + logger.info("[WARN] Failed to load scheduler.") + + if self.scaler and 'scaler' in checkpoint_dict: + try: + self.scaler.load_state_dict(checkpoint_dict['scaler']) + logger.info("[INFO] loaded scaler.") + except: + logger.info("[WARN] Failed to load scaler.") + + +def get_CPU_mem(): + return psutil.Process(os.getpid()).memory_info().rss /1024**3 + + +def get_GPU_mem(): + num = torch.cuda.device_count() + mem, mems = 0, [] + for i in range(num): + mem_free, mem_total = torch.cuda.mem_get_info(i) + mems.append(int(((mem_total - mem_free)/1024**3)*1000)/1000) + mem += mems[-1] + return mem, mems diff --git a/optimizer.py b/optimizer.py new file mode 100644 index 0000000..f5bb64f --- /dev/null +++ b/optimizer.py @@ -0,0 +1,325 @@ +# Copyright 2022 Garena Online Private Limited +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import math +from typing import List + +import torch +from torch import Tensor +from torch.optim.optimizer import Optimizer + + +class Adan(Optimizer): + """ + Implements a pytorch variant of Adan + Adan was proposed in + Adan: Adaptive Nesterov Momentum Algorithm for + Faster Optimizing Deep Models[J].arXiv preprint arXiv:2208.06677, 2022. + https://arxiv.org/abs/2208.06677 + Arguments: + params (iterable): iterable of parameters to optimize or + dicts defining parameter groups. + lr (float, optional): learning rate. (default: 1e-3) + betas (Tuple[float, float, flot], optional): coefficients used for + first- and second-order moments. (default: (0.98, 0.92, 0.99)) + eps (float, optional): term added to the denominator to improve + numerical stability. (default: 1e-8) + weight_decay (float, optional): decoupled weight decay + (L2 penalty) (default: 0) + max_grad_norm (float, optional): value used to clip + global grad norm (default: 0.0 no clip) + no_prox (bool): how to perform the decoupled weight decay + (default: False) + foreach (bool): if True would use torch._foreach implementation. + It's faster but uses slightly more memory. (default: True) + """ + def __init__(self, + params, + lr=1e-3, + betas=(0.98, 0.92, 0.99), + eps=1e-8, + weight_decay=0.0, + max_grad_norm=0.0, + no_prox=False, + foreach: bool = True): + if not 0.0 <= max_grad_norm: + raise ValueError('Invalid Max grad norm: {}'.format(max_grad_norm)) + if not 0.0 <= lr: + raise ValueError('Invalid learning rate: {}'.format(lr)) + if not 0.0 <= eps: + raise ValueError('Invalid epsilon value: {}'.format(eps)) + if not 0.0 <= betas[0] < 1.0: + raise ValueError('Invalid beta parameter at index 0: {}'.format( + betas[0])) + if not 0.0 <= betas[1] < 1.0: + raise ValueError('Invalid beta parameter at index 1: {}'.format( + betas[1])) + if not 0.0 <= betas[2] < 1.0: + raise ValueError('Invalid beta parameter at index 2: {}'.format( + betas[2])) + defaults = dict(lr=lr, + betas=betas, + eps=eps, + weight_decay=weight_decay, + max_grad_norm=max_grad_norm, + no_prox=no_prox, + foreach=foreach) + super().__init__(params, defaults) + + def __setstate__(self, state): + super(Adan, self).__setstate__(state) + for group in self.param_groups: + group.setdefault('no_prox', False) + + @torch.no_grad() + def restart_opt(self): + for group in self.param_groups: + group['step'] = 0 + for p in group['params']: + if p.requires_grad: + state = self.state[p] + # State initialization + + # Exponential moving average of gradient values + state['exp_avg'] = torch.zeros_like(p) + # Exponential moving average of squared gradient values + state['exp_avg_sq'] = torch.zeros_like(p) + # Exponential moving average of gradient difference + state['exp_avg_diff'] = torch.zeros_like(p) + + @torch.no_grad() + def step(self, closure=None): + """Performs a single optimization step.""" + + loss = None + if closure is not None: + with torch.enable_grad(): + loss = closure() + + if self.defaults['max_grad_norm'] > 0: + device = self.param_groups[0]['params'][0].device + global_grad_norm = torch.zeros(1, device=device) + + max_grad_norm = torch.tensor(self.defaults['max_grad_norm'], + device=device) + for group in self.param_groups: + + for p in group['params']: + if p.grad is not None: + grad = p.grad + global_grad_norm.add_(grad.pow(2).sum()) + + global_grad_norm = torch.sqrt(global_grad_norm) + + clip_global_grad_norm = torch.clamp( + max_grad_norm / (global_grad_norm + group['eps']), + max=1.0).item() + else: + clip_global_grad_norm = 1.0 + + for group in self.param_groups: + params_with_grad = [] + grads = [] + exp_avgs = [] + exp_avg_sqs = [] + exp_avg_diffs = [] + neg_pre_grads = [] + + beta1, beta2, beta3 = group['betas'] + # assume same step across group now to simplify things + # per parameter step can be easily support + # by making it tensor, or pass list into kernel + if 'step' in group: + group['step'] += 1 + else: + group['step'] = 1 + + bias_correction1 = 1.0 - beta1**group['step'] + bias_correction2 = 1.0 - beta2**group['step'] + bias_correction3 = 1.0 - beta3**group['step'] + + for p in group['params']: + if p.grad is None: + continue + params_with_grad.append(p) + grads.append(p.grad) + + state = self.state[p] + if len(state) == 0: + state['exp_avg'] = torch.zeros_like(p) + state['exp_avg_sq'] = torch.zeros_like(p) + state['exp_avg_diff'] = torch.zeros_like(p) + + if 'neg_pre_grad' not in state or group['step'] == 1: + state['neg_pre_grad'] = p.grad.clone().mul_( + -clip_global_grad_norm) + + exp_avgs.append(state['exp_avg']) + exp_avg_sqs.append(state['exp_avg_sq']) + exp_avg_diffs.append(state['exp_avg_diff']) + neg_pre_grads.append(state['neg_pre_grad']) + + kwargs = dict( + params=params_with_grad, + grads=grads, + exp_avgs=exp_avgs, + exp_avg_sqs=exp_avg_sqs, + exp_avg_diffs=exp_avg_diffs, + neg_pre_grads=neg_pre_grads, + beta1=beta1, + beta2=beta2, + beta3=beta3, + bias_correction1=bias_correction1, + bias_correction2=bias_correction2, + bias_correction3_sqrt=math.sqrt(bias_correction3), + lr=group['lr'], + weight_decay=group['weight_decay'], + eps=group['eps'], + no_prox=group['no_prox'], + clip_global_grad_norm=clip_global_grad_norm, + ) + + if group['foreach']: + _multi_tensor_adan(**kwargs) + else: + _single_tensor_adan(**kwargs) + + return loss + + +def _single_tensor_adan( + params: List[Tensor], + grads: List[Tensor], + exp_avgs: List[Tensor], + exp_avg_sqs: List[Tensor], + exp_avg_diffs: List[Tensor], + neg_pre_grads: List[Tensor], + *, + beta1: float, + beta2: float, + beta3: float, + bias_correction1: float, + bias_correction2: float, + bias_correction3_sqrt: float, + lr: float, + weight_decay: float, + eps: float, + no_prox: bool, + clip_global_grad_norm: Tensor, +): + for i, param in enumerate(params): + grad = grads[i] + exp_avg = exp_avgs[i] + exp_avg_sq = exp_avg_sqs[i] + exp_avg_diff = exp_avg_diffs[i] + neg_grad_or_diff = neg_pre_grads[i] + + grad.mul_(clip_global_grad_norm) + + # for memory saving, we use `neg_grad_or_diff` + # to get some temp variable in a inplace way + neg_grad_or_diff.add_(grad) + + exp_avg.mul_(beta1).add_(grad, alpha=1 - beta1) # m_t + exp_avg_diff.mul_(beta2).add_(neg_grad_or_diff, + alpha=1 - beta2) # diff_t + + neg_grad_or_diff.mul_(beta2).add_(grad) + exp_avg_sq.mul_(beta3).addcmul_(neg_grad_or_diff, + neg_grad_or_diff, + value=1 - beta3) # n_t + + denom = ((exp_avg_sq).sqrt() / bias_correction3_sqrt).add_(eps) + step_size_diff = lr * beta2 / bias_correction2 + step_size = lr / bias_correction1 + + if no_prox: + param.mul_(1 - lr * weight_decay) + param.addcdiv_(exp_avg, denom, value=-step_size) + param.addcdiv_(exp_avg_diff, denom, value=-step_size_diff) + else: + param.addcdiv_(exp_avg, denom, value=-step_size) + param.addcdiv_(exp_avg_diff, denom, value=-step_size_diff) + param.div_(1 + lr * weight_decay) + + neg_grad_or_diff.zero_().add_(grad, alpha=-1.0) + + +def _multi_tensor_adan( + params: List[Tensor], + grads: List[Tensor], + exp_avgs: List[Tensor], + exp_avg_sqs: List[Tensor], + exp_avg_diffs: List[Tensor], + neg_pre_grads: List[Tensor], + *, + beta1: float, + beta2: float, + beta3: float, + bias_correction1: float, + bias_correction2: float, + bias_correction3_sqrt: float, + lr: float, + weight_decay: float, + eps: float, + no_prox: bool, + clip_global_grad_norm: Tensor, +): + if len(params) == 0: + return + + torch._foreach_mul_(grads, clip_global_grad_norm) + + # for memory saving, we use `neg_pre_grads` + # to get some temp variable in a inplace way + torch._foreach_add_(neg_pre_grads, grads) + + torch._foreach_mul_(exp_avgs, beta1) + torch._foreach_add_(exp_avgs, grads, alpha=1 - beta1) # m_t + + torch._foreach_mul_(exp_avg_diffs, beta2) + torch._foreach_add_(exp_avg_diffs, neg_pre_grads, + alpha=1 - beta2) # diff_t + + torch._foreach_mul_(neg_pre_grads, beta2) + torch._foreach_add_(neg_pre_grads, grads) + torch._foreach_mul_(exp_avg_sqs, beta3) + torch._foreach_addcmul_(exp_avg_sqs, + neg_pre_grads, + neg_pre_grads, + value=1 - beta3) # n_t + + denom = torch._foreach_sqrt(exp_avg_sqs) + torch._foreach_div_(denom, bias_correction3_sqrt) + torch._foreach_add_(denom, eps) + + step_size_diff = lr * beta2 / bias_correction2 + step_size = lr / bias_correction1 + + if no_prox: + torch._foreach_mul_(params, 1 - lr * weight_decay) + torch._foreach_addcdiv_(params, exp_avgs, denom, value=-step_size) + torch._foreach_addcdiv_(params, + exp_avg_diffs, + denom, + value=-step_size_diff) + else: + torch._foreach_addcdiv_(params, exp_avgs, denom, value=-step_size) + torch._foreach_addcdiv_(params, + exp_avg_diffs, + denom, + value=-step_size_diff) + torch._foreach_div_(params, 1 + lr * weight_decay) + torch._foreach_zero_(neg_pre_grads) + torch._foreach_add_(neg_pre_grads, grads, alpha=-1.0) \ No newline at end of file diff --git a/preprocess_image.py b/preprocess_image.py new file mode 100644 index 0000000..13b1813 --- /dev/null +++ b/preprocess_image.py @@ -0,0 +1,251 @@ +import os +import sys +import cv2 +import argparse +import numpy as np +import matplotlib.pyplot as plt + +import torch +import torch.nn as nn +import torch.nn.functional as F +from torchvision import transforms +from PIL import Image + +from easydict import EasyDict as edict + +class BackgroundRemoval(): + def __init__(self, device='cuda'): + + from carvekit.api.high import HiInterface + self.interface = HiInterface( + object_type="object", # Can be "object" or "hairs-like". + batch_size_seg=5, + batch_size_matting=1, + device=device, + seg_mask_size=640, # Use 640 for Tracer B7 and 320 for U2Net + matting_mask_size=2048, + trimap_prob_threshold=231, + trimap_dilation=30, + trimap_erosion_iters=5, + fp16=True, + ) + + @torch.no_grad() + def __call__(self, image): + # image: [H, W, 3] array in [0, 255]. + image = Image.fromarray(image) + image = self.interface([image])[0] + image = np.array(image) + return image + + +def get_rgba(image, alpha_matting=False): + try: + from rembg import remove + except ImportError: + print('Please install rembg with "pip install rembg"') + sys.exit() + return remove(image, alpha_matting=alpha_matting) + + +class BLIP2(): + def __init__(self, device='cuda'): + self.device = device + from transformers import AutoProcessor, Blip2ForConditionalGeneration + self.processor = AutoProcessor.from_pretrained( + "Salesforce/blip2-opt-2.7b") + self.model = Blip2ForConditionalGeneration.from_pretrained( + "Salesforce/blip2-opt-2.7b", torch_dtype=torch.float16).to(device) + + @torch.no_grad() + def __call__(self, image): + image = Image.fromarray(image) + inputs = self.processor(image, return_tensors="pt").to( + self.device, torch.float16) + + generated_ids = self.model.generate(**inputs, max_new_tokens=20) + generated_text = self.processor.batch_decode( + generated_ids, skip_special_tokens=True)[0].strip() + + return generated_text + + +class DPT(): + def __init__(self, task='depth', device='cuda'): + + self.task = task + self.device = device + + from dpt import DPTDepthModel + + if task == 'depth': + path = 'pretrained/omnidata/omnidata_dpt_depth_v2.ckpt' + self.model = DPTDepthModel(backbone='vitb_rn50_384') + self.aug = transforms.Compose([ + transforms.Resize((384, 384)), + transforms.ToTensor(), + transforms.Normalize(mean=0.5, std=0.5) + ]) + + else: # normal + path = 'pretrained/omnidata/omnidata_dpt_normal_v2.ckpt' + self.model = DPTDepthModel(backbone='vitb_rn50_384', num_channels=3) + self.aug = transforms.Compose([ + transforms.Resize((384, 384)), + transforms.ToTensor() + ]) + + # load model + checkpoint = torch.load(path, map_location='cpu') + if 'state_dict' in checkpoint: + state_dict = {} + for k, v in checkpoint['state_dict'].items(): + state_dict[k[6:]] = v + else: + state_dict = checkpoint + self.model.load_state_dict(state_dict) + self.model.eval().to(device) + + + @torch.no_grad() + def __call__(self, image): + # image: np.ndarray, uint8, [H, W, 3] + H, W = image.shape[:2] + image = Image.fromarray(image) + + image = self.aug(image).unsqueeze(0).to(self.device) + + if self.task == 'depth': + depth = self.model(image).clamp(0, 1) + depth = F.interpolate(depth.unsqueeze(1), size=(H, W), mode='bicubic', align_corners=False) + depth = depth.squeeze(1).cpu().numpy() + return depth + else: + normal = self.model(image).clamp(0, 1) + normal = F.interpolate(normal, size=(H, W), mode='bicubic', align_corners=False) + normal = normal.cpu().numpy() + return normal + + +# from munch import DefaultMunch +from midas.model_loader import default_models, load_model + +depth_config={ + "input_path": None, + "output_path": None, + "model_weights": "pretrained/midas/dpt_beit_large_512.pt", + "model_type": "dpt_beit_large_512", + "side": False, + "optimize": False, + "height": None, + "square": False, + "device":0, + "grayscale": False +} + + +class DepthEstimator: + def __init__(self,**kwargs): + # update coming args + for key, value in kwargs.items(): + depth_config[key]=value + + # self.config=DefaultMunch.fromDict(depth_config) + self.config = edict(depth_config) + + # select device + self.device = torch.device(self.config.device) + model, transform, net_w, net_h = load_model(f"cuda:{self.config.device}", self.config.model_weights, self.config.model_type, + self.config.optimize, self.config.height, self.config.square) + self.model, self.transform, self.net_w, self.net_h=model, transform, net_w, net_h + self.first_execution = True + + @torch.no_grad() + def process(self,image,target_size): + sample = torch.from_numpy(image).to(self.device).unsqueeze(0) + + + if self.first_execution: + height, width = sample.shape[2:] + print(f" Input resized to {width}x{height} before entering the encoder") + self.first_execution = False + + prediction = self.model.forward(sample) + prediction = ( + torch.nn.functional.interpolate( + prediction.unsqueeze(1), + size=target_size[::-1], + mode="bicubic", + align_corners=False, + ) + .squeeze() + .cpu() + .numpy() + ) + return prediction + + @torch.no_grad() + def get_monocular_depth(self,rgb, output_path=None): + original_image_rgb=rgb + image = self.transform({"image": original_image_rgb})["image"] + + prediction = self.process(image, original_image_rgb.shape[1::-1]) + return prediction + + + +def process_single_image(image_path, depth_estimator, normal_estimator=None): + out_dir = os.path.dirname(image_path) + rgba_path = os.path.join(out_dir, 'rgba.png') + depth_path = os.path.join(out_dir, 'depth.png') + # out_normal = os.path.join(out_dir, 'normal.png') + + if os.path.exists(rgba_path): + print(f'[INFO] loading rgba image {rgba_path}...') + rgba = cv2.cvtColor(cv2.imread(rgba_path, cv2.IMREAD_UNCHANGED), cv2.COLOR_BGRA2RGBA) + image = cv2.cvtColor(rgba, cv2.COLOR_RGBA2RGB) + else: + print(f'[INFO] loading image {image_path}...') + image = cv2.imread(image_path, cv2.IMREAD_UNCHANGED) + if image.shape[-1] == 4: + image = cv2.cvtColor(image, cv2.COLOR_BGRA2RGB) + else: + image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) + print(f'[INFO] background removal...') + rgba = BackgroundRemoval()(image) # [H, W, 4] + cv2.imwrite(rgba_path, cv2.cvtColor(rgba, cv2.COLOR_RGBA2BGRA)) + # rgba = get_rgba(image) # [H, W, 4] + # cv2.imwrite(rgba_path.replace('rgba', 'rgba2'), cv2.cvtColor(rgba, cv2.COLOR_RGBA2BGRA)) + + # Predict depth using Midas + mask = rgba[..., -1] > 0 + depth = depth_estimator.get_monocular_depth(image/255) + depth[mask] = (depth[mask] - depth[mask].min()) / (depth[mask].max() - depth[mask].min() + 1e-9) + depth[~mask] = 0 + depth = (depth * 255).astype(np.uint8) + + # print(f'[INFO] normal estimation...') + # normal = normal_estimator(image)[0] + # normal = (normal.clip(0, 1) * 255).astype(np.uint8).transpose(1, 2, 0) + # normal[~mask] = 0 + + cv2.imwrite(depth_path, depth) + # cv2.imwrite(out_normal, cv2.cvtColor(normal, cv2.COLOR_RGB2BGR)) + if not os.path.exists(rgba_path): + cv2.imwrite(rgba_path, cv2.cvtColor(rgba, cv2.COLOR_RGBA2BGRA)) + +if __name__ == '__main__': + import glob + parser = argparse.ArgumentParser() + parser.add_argument('--path', default=None, type=str, nargs='*', help="path to image (png, jpeg, etc.)") + parser.add_argument('--folder', default=None, type=str, help="path to image (png, jpeg, etc.)") + opt = parser.parse_args() + + depth_estimator = DepthEstimator() + # normal_estimator = DPT(task='normal') + + paths = opt.path if opt.path is not None else glob.glob(os.path.join(opt.folder, '*/rgba.png')) + for path in paths: + process_single_image(path, depth_estimator, + # normal_estimator + ) \ No newline at end of file diff --git a/pretrained/zero123/sd-objaverse-finetune-c_concat-256.yaml b/pretrained/zero123/sd-objaverse-finetune-c_concat-256.yaml new file mode 100755 index 0000000..2448cd4 --- /dev/null +++ b/pretrained/zero123/sd-objaverse-finetune-c_concat-256.yaml @@ -0,0 +1,117 @@ +model: + base_learning_rate: 1.0e-04 + target: ldm.models.diffusion.ddpm.LatentDiffusion + params: + linear_start: 0.00085 + linear_end: 0.0120 + num_timesteps_cond: 1 + log_every_t: 200 + timesteps: 1000 + first_stage_key: "image_target" + cond_stage_key: "image_cond" + image_size: 32 + channels: 4 + cond_stage_trainable: false # Note: different from the one we trained before + conditioning_key: hybrid + monitor: val/loss_simple_ema + scale_factor: 0.18215 + + scheduler_config: # 10000 warmup steps + target: ldm.lr_scheduler.LambdaLinearScheduler + params: + warm_up_steps: [ 100 ] + cycle_lengths: [ 10000000000000 ] # incredibly large number to prevent corner cases + f_start: [ 1.e-6 ] + f_max: [ 1. ] + f_min: [ 1. ] + + unet_config: + target: ldm.modules.diffusionmodules.openaimodel.UNetModel + params: + image_size: 32 # unused + in_channels: 8 + out_channels: 4 + model_channels: 320 + attention_resolutions: [ 4, 2, 1 ] + num_res_blocks: 2 + channel_mult: [ 1, 2, 4, 4 ] + num_heads: 8 + use_spatial_transformer: True + transformer_depth: 1 + context_dim: 768 + use_checkpoint: True + legacy: False + + first_stage_config: + target: ldm.models.autoencoder.AutoencoderKL + params: + embed_dim: 4 + monitor: val/rec_loss + ddconfig: + double_z: true + z_channels: 4 + resolution: 256 + in_channels: 3 + out_ch: 3 + ch: 128 + ch_mult: + - 1 + - 2 + - 4 + - 4 + num_res_blocks: 2 + attn_resolutions: [] + dropout: 0.0 + lossconfig: + target: torch.nn.Identity + + cond_stage_config: + target: ldm.modules.encoders.modules.FrozenCLIPImageEmbedder + + +# data: +# target: ldm.data.simple.ObjaverseDataModuleFromConfig +# params: +# root_dir: 'views_whole_sphere' +# batch_size: 192 +# num_workers: 16 +# total_view: 4 +# train: +# validation: False +# image_transforms: +# size: 256 + +# validation: +# validation: True +# image_transforms: +# size: 256 + + +# lightning: +# find_unused_parameters: false +# metrics_over_trainsteps_checkpoint: True +# modelcheckpoint: +# params: +# every_n_train_steps: 5000 +# callbacks: +# image_logger: +# target: main.ImageLogger +# params: +# batch_frequency: 500 +# max_images: 32 +# increase_log_steps: False +# log_first_step: True +# log_images_kwargs: +# use_ema_scope: False +# inpaint: False +# plot_progressive_rows: False +# plot_diffusion_rows: False +# N: 32 +# unconditional_scale: 3.0 +# unconditional_label: [""] + +# trainer: +# benchmark: True +# val_check_interval: 5000000 # really sorry +# num_sanity_val_steps: 0 +# accumulate_grad_batches: 1 diff --git a/raymarching/__init__.py b/raymarching/__init__.py new file mode 100644 index 0000000..26d3cc6 --- /dev/null +++ b/raymarching/__init__.py @@ -0,0 +1 @@ +from .raymarching import * \ No newline at end of file diff --git a/raymarching/backend.py b/raymarching/backend.py new file mode 100644 index 0000000..7cc0d76 --- /dev/null +++ b/raymarching/backend.py @@ -0,0 +1,41 @@ +import os +from torch.utils.cpp_extension import load + +_src_path = os.path.dirname(os.path.abspath(__file__)) + +nvcc_flags = [ + '-O3', '-std=c++14', + '-U__CUDA_NO_HALF_OPERATORS__', '-U__CUDA_NO_HALF_CONVERSIONS__', '-U__CUDA_NO_HALF2_OPERATORS__', +] + +if os.name == "posix": + c_flags = ['-O3', '-std=c++14'] +elif os.name == "nt": + c_flags = ['/O2', '/std:c++17'] + + # find cl.exe + def find_cl_path(): + import glob + for program_files in [r"C:\\Program Files (x86)", r"C:\\Program Files"]: + for edition in ["Enterprise", "Professional", "BuildTools", "Community"]: + paths = sorted(glob.glob(r"%s\\Microsoft Visual Studio\\*\\%s\\VC\\Tools\\MSVC\\*\\bin\\Hostx64\\x64" % (program_files, edition)), reverse=True) + if paths: + return paths[0] + + # If cl.exe is not on path, try to find it. + if os.system("where cl.exe >nul 2>nul") != 0: + cl_path = find_cl_path() + if cl_path is None: + raise RuntimeError("Could not locate a supported Microsoft Visual C++ installation") + os.environ["PATH"] += ";" + cl_path + +_backend = load(name='_raymarching', + extra_cflags=c_flags, + extra_cuda_cflags=nvcc_flags, + sources=[os.path.join(_src_path, 'src', f) for f in [ + 'raymarching.cu', + 'bindings.cpp', + ]], + ) + +__all__ = ['_backend'] \ No newline at end of file diff --git a/raymarching/raymarching.py b/raymarching/raymarching.py new file mode 100644 index 0000000..760d730 --- /dev/null +++ b/raymarching/raymarching.py @@ -0,0 +1,398 @@ +import numpy as np +import time + +import torch +import torch.nn as nn +from torch.autograd import Function +from torch.cuda.amp import custom_bwd, custom_fwd + +# lazy building: +# `import raymarching` will not immediately build the extension, only if you actually call any functions. + +BACKEND = None + +def get_backend(): + global BACKEND + + if BACKEND is None: + try: + import _raymarching as _backend + except ImportError: + from .backend import _backend + + BACKEND = _backend + + return BACKEND + +# ---------------------------------------- +# utils +# ---------------------------------------- + +class _near_far_from_aabb(Function): + @staticmethod + @custom_fwd(cast_inputs=torch.float32) + def forward(ctx, rays_o, rays_d, aabb, min_near=0.2): + ''' near_far_from_aabb, CUDA implementation + Calculate rays' intersection time (near and far) with aabb + Args: + rays_o: float, [N, 3] + rays_d: float, [N, 3] + aabb: float, [6], (xmin, ymin, zmin, xmax, ymax, zmax) + min_near: float, scalar + Returns: + nears: float, [N] + fars: float, [N] + ''' + if not rays_o.is_cuda: rays_o = rays_o.cuda() + if not rays_d.is_cuda: rays_d = rays_d.cuda() + + rays_o = rays_o.contiguous().view(-1, 3) + rays_d = rays_d.contiguous().view(-1, 3) + + N = rays_o.shape[0] # num rays + + nears = torch.empty(N, dtype=rays_o.dtype, device=rays_o.device) + fars = torch.empty(N, dtype=rays_o.dtype, device=rays_o.device) + + get_backend().near_far_from_aabb(rays_o, rays_d, aabb, N, min_near, nears, fars) + + return nears, fars + +near_far_from_aabb = _near_far_from_aabb.apply + + +class _sph_from_ray(Function): + @staticmethod + @custom_fwd(cast_inputs=torch.float32) + def forward(ctx, rays_o, rays_d, radius): + ''' sph_from_ray, CUDA implementation + get spherical coordinate on the background sphere from rays. + Assume rays_o are inside the Sphere(radius). + Args: + rays_o: [N, 3] + rays_d: [N, 3] + radius: scalar, float + Return: + coords: [N, 2], in [-1, 1], theta and phi on a sphere. (further-surface) + ''' + if not rays_o.is_cuda: rays_o = rays_o.cuda() + if not rays_d.is_cuda: rays_d = rays_d.cuda() + + rays_o = rays_o.contiguous().view(-1, 3) + rays_d = rays_d.contiguous().view(-1, 3) + + N = rays_o.shape[0] # num rays + + coords = torch.empty(N, 2, dtype=rays_o.dtype, device=rays_o.device) + + get_backend().sph_from_ray(rays_o, rays_d, radius, N, coords) + + return coords + +sph_from_ray = _sph_from_ray.apply + + +class _morton3D(Function): + @staticmethod + def forward(ctx, coords): + ''' morton3D, CUDA implementation + Args: + coords: [N, 3], int32, in [0, 128) (for some reason there is no uint32 tensor in torch...) + TODO: check if the coord range is valid! (current 128 is safe) + Returns: + indices: [N], int32, in [0, 128^3) + + ''' + if not coords.is_cuda: coords = coords.cuda() + + N = coords.shape[0] + + indices = torch.empty(N, dtype=torch.int32, device=coords.device) + + get_backend().morton3D(coords.int(), N, indices) + + return indices + +morton3D = _morton3D.apply + +class _morton3D_invert(Function): + @staticmethod + def forward(ctx, indices): + ''' morton3D_invert, CUDA implementation + Args: + indices: [N], int32, in [0, 128^3) + Returns: + coords: [N, 3], int32, in [0, 128) + + ''' + if not indices.is_cuda: indices = indices.cuda() + + N = indices.shape[0] + + coords = torch.empty(N, 3, dtype=torch.int32, device=indices.device) + + get_backend().morton3D_invert(indices.int(), N, coords) + + return coords + +morton3D_invert = _morton3D_invert.apply + + +class _packbits(Function): + @staticmethod + @custom_fwd(cast_inputs=torch.float32) + def forward(ctx, grid, thresh, bitfield=None): + ''' packbits, CUDA implementation + Pack up the density grid into a bit field to accelerate ray marching. + Args: + grid: float, [C, H * H * H], assume H % 2 == 0 + thresh: float, threshold + Returns: + bitfield: uint8, [C, H * H * H / 8] + ''' + if not grid.is_cuda: grid = grid.cuda() + grid = grid.contiguous() + + C = grid.shape[0] + H3 = grid.shape[1] + N = C * H3 // 8 + + if bitfield is None: + bitfield = torch.empty(N, dtype=torch.uint8, device=grid.device) + + get_backend().packbits(grid, N, thresh, bitfield) + + return bitfield + +packbits = _packbits.apply + + +class _flatten_rays(Function): + @staticmethod + def forward(ctx, rays, M): + ''' flatten rays + Args: + rays: [N, 2], all rays' (point_offset, point_count), + M: scalar, int, count of points (we cannot get this info from rays unfortunately...) + Returns: + res: [M], flattened ray index. + ''' + if not rays.is_cuda: rays = rays.cuda() + rays = rays.contiguous() + + N = rays.shape[0] + + res = torch.zeros(M, dtype=torch.int, device=rays.device) + + get_backend().flatten_rays(rays, N, M, res) + + return res + +flatten_rays = _flatten_rays.apply + +# ---------------------------------------- +# train functions +# ---------------------------------------- + +class _march_rays_train(Function): + @staticmethod + @custom_fwd(cast_inputs=torch.float32) + def forward(ctx, rays_o, rays_d, bound, density_bitfield, C, H, nears, fars, perturb=False, dt_gamma=0, max_steps=1024, contract=False): + ''' march rays to generate points (forward only) + Args: + rays_o/d: float, [N, 3] + bound: float, scalar + density_bitfield: uint8: [CHHH // 8] + C: int + H: int + nears/fars: float, [N] + step_counter: int32, (2), used to count the actual number of generated points. + mean_count: int32, estimated mean steps to accelerate training. (but will randomly drop rays if the actual point count exceeded this threshold.) + perturb: bool + align: int, pad output so its size is dividable by align, set to -1 to disable. + force_all_rays: bool, ignore step_counter and mean_count, always calculate all rays. Useful if rendering the whole image, instead of some rays. + dt_gamma: float, called cone_angle in instant-ngp, exponentially accelerate ray marching if > 0. (very significant effect, but generally lead to worse performance) + max_steps: int, max number of sampled points along each ray, also affect min_stepsize. + Returns: + xyzs: float, [M, 3], all generated points' coords. (all rays concated, need to use `rays` to extract points belonging to each ray) + dirs: float, [M, 3], all generated points' view dirs. + ts: float, [M, 2], all generated points' ts. + rays: int32, [N, 2], all rays' (point_offset, point_count), e.g., xyzs[rays[i, 0]:(rays[i, 0] + rays[i, 1])] --> points belonging to rays[i, 0] + ''' + + if not rays_o.is_cuda: rays_o = rays_o.cuda() + if not rays_d.is_cuda: rays_d = rays_d.cuda() + if not density_bitfield.is_cuda: density_bitfield = density_bitfield.cuda() + + rays_o = rays_o.float().contiguous().view(-1, 3) + rays_d = rays_d.float().contiguous().view(-1, 3) + density_bitfield = density_bitfield.contiguous() + + N = rays_o.shape[0] # num rays + + step_counter = torch.zeros(1, dtype=torch.int32, device=rays_o.device) # point counter, ray counter + + if perturb: + noises = torch.rand(N, dtype=rays_o.dtype, device=rays_o.device) + else: + noises = torch.zeros(N, dtype=rays_o.dtype, device=rays_o.device) + + # first pass: write rays, get total number of points M to render + rays = torch.empty(N, 2, dtype=torch.int32, device=rays_o.device) # id, offset, num_steps + get_backend().march_rays_train(rays_o, rays_d, density_bitfield, bound, contract, dt_gamma, max_steps, N, C, H, nears, fars, None, None, None, rays, step_counter, noises) + + # allocate based on M + M = step_counter.item() + # print(M, N) + # print(rays[:, 0].max()) + + xyzs = torch.zeros(M, 3, dtype=rays_o.dtype, device=rays_o.device) + dirs = torch.zeros(M, 3, dtype=rays_o.dtype, device=rays_o.device) + ts = torch.zeros(M, 2, dtype=rays_o.dtype, device=rays_o.device) + + # second pass: write outputs + get_backend().march_rays_train(rays_o, rays_d, density_bitfield, bound, contract, dt_gamma, max_steps, N, C, H, nears, fars, xyzs, dirs, ts, rays, step_counter, noises) + + return xyzs, dirs, ts, rays + +march_rays_train = _march_rays_train.apply + + +class _composite_rays_train(Function): + @staticmethod + @custom_fwd(cast_inputs=torch.float32) + def forward(ctx, sigmas, rgbs, ts, rays, T_thresh=1e-4, binarize=False): + ''' composite rays' rgbs, according to the ray marching formula. + Args: + rgbs: float, [M, 3] + sigmas: float, [M,] + ts: float, [M, 2] + rays: int32, [N, 3] + Returns: + weights: float, [M] + weights_sum: float, [N,], the alpha channel + depth: float, [N, ], the Depth + image: float, [N, 3], the RGB channel (after multiplying alpha!) + ''' + + sigmas = sigmas.float().contiguous() + rgbs = rgbs.float().contiguous() + + M = sigmas.shape[0] + N = rays.shape[0] + + weights = torch.zeros(M, dtype=sigmas.dtype, device=sigmas.device) # may leave unmodified, so init with 0 + weights_sum = torch.empty(N, dtype=sigmas.dtype, device=sigmas.device) + + depth = torch.empty(N, dtype=sigmas.dtype, device=sigmas.device) + image = torch.empty(N, 3, dtype=sigmas.dtype, device=sigmas.device) + + get_backend().composite_rays_train_forward(sigmas, rgbs, ts, rays, M, N, T_thresh, binarize, weights, weights_sum, depth, image) + + ctx.save_for_backward(sigmas, rgbs, ts, rays, weights_sum, depth, image) + ctx.dims = [M, N, T_thresh, binarize] + + return weights, weights_sum, depth, image + + @staticmethod + @custom_bwd + def backward(ctx, grad_weights, grad_weights_sum, grad_depth, grad_image): + + grad_weights = grad_weights.contiguous() + grad_weights_sum = grad_weights_sum.contiguous() + grad_depth = grad_depth.contiguous() + grad_image = grad_image.contiguous() + + sigmas, rgbs, ts, rays, weights_sum, depth, image = ctx.saved_tensors + M, N, T_thresh, binarize = ctx.dims + + grad_sigmas = torch.zeros_like(sigmas) + grad_rgbs = torch.zeros_like(rgbs) + + get_backend().composite_rays_train_backward(grad_weights, grad_weights_sum, grad_depth, grad_image, sigmas, rgbs, ts, rays, weights_sum, depth, image, M, N, T_thresh, binarize, grad_sigmas, grad_rgbs) + + return grad_sigmas, grad_rgbs, None, None, None, None + + +composite_rays_train = _composite_rays_train.apply + +# ---------------------------------------- +# infer functions +# ---------------------------------------- + +class _march_rays(Function): + @staticmethod + @custom_fwd(cast_inputs=torch.float32) + def forward(ctx, n_alive, n_step, rays_alive, rays_t, rays_o, rays_d, bound, density_bitfield, C, H, near, far, perturb=False, dt_gamma=0, max_steps=1024, contract=False): + ''' march rays to generate points (forward only, for inference) + Args: + n_alive: int, number of alive rays + n_step: int, how many steps we march + rays_alive: int, [N], the alive rays' IDs in N (N >= n_alive, but we only use first n_alive) + rays_t: float, [N], the alive rays' time, we only use the first n_alive. + rays_o/d: float, [N, 3] + bound: float, scalar + density_bitfield: uint8: [CHHH // 8] + C: int + H: int + nears/fars: float, [N] + align: int, pad output so its size is dividable by align, set to -1 to disable. + perturb: bool/int, int > 0 is used as the random seed. + dt_gamma: float, called cone_angle in instant-ngp, exponentially accelerate ray marching if > 0. (very significant effect, but generally lead to worse performance) + max_steps: int, max number of sampled points along each ray, also affect min_stepsize. + Returns: + xyzs: float, [n_alive * n_step, 3], all generated points' coords + dirs: float, [n_alive * n_step, 3], all generated points' view dirs. + ts: float, [n_alive * n_step, 2], all generated points' ts + ''' + + if not rays_o.is_cuda: rays_o = rays_o.cuda() + if not rays_d.is_cuda: rays_d = rays_d.cuda() + + rays_o = rays_o.float().contiguous().view(-1, 3) + rays_d = rays_d.float().contiguous().view(-1, 3) + + M = n_alive * n_step + + xyzs = torch.zeros(M, 3, dtype=rays_o.dtype, device=rays_o.device) + dirs = torch.zeros(M, 3, dtype=rays_o.dtype, device=rays_o.device) + ts = torch.zeros(M, 2, dtype=rays_o.dtype, device=rays_o.device) # 2 vals, one for rgb, one for depth + + if perturb: + # torch.manual_seed(perturb) # test_gui uses spp index as seed + noises = torch.rand(n_alive, dtype=rays_o.dtype, device=rays_o.device) + else: + noises = torch.zeros(n_alive, dtype=rays_o.dtype, device=rays_o.device) + + get_backend().march_rays(n_alive, n_step, rays_alive, rays_t, rays_o, rays_d, bound, contract, dt_gamma, max_steps, C, H, density_bitfield, near, far, xyzs, dirs, ts, noises) + + return xyzs, dirs, ts + +march_rays = _march_rays.apply + + +class _composite_rays(Function): + @staticmethod + @custom_fwd(cast_inputs=torch.float32) # need to cast sigmas & rgbs to float + def forward(ctx, n_alive, n_step, rays_alive, rays_t, sigmas, rgbs, ts, weights_sum, depth, image, T_thresh=1e-2, binarize=False): + ''' composite rays' rgbs, according to the ray marching formula. (for inference) + Args: + n_alive: int, number of alive rays + n_step: int, how many steps we march + rays_alive: int, [n_alive], the alive rays' IDs in N (N >= n_alive) + rays_t: float, [N], the alive rays' time + sigmas: float, [n_alive * n_step,] + rgbs: float, [n_alive * n_step, 3] + ts: float, [n_alive * n_step, 2] + In-place Outputs: + weights_sum: float, [N,], the alpha channel + depth: float, [N,], the depth value + image: float, [N, 3], the RGB channel (after multiplying alpha!) + ''' + sigmas = sigmas.float().contiguous() + rgbs = rgbs.float().contiguous() + get_backend().composite_rays(n_alive, n_step, T_thresh, binarize, rays_alive, rays_t, sigmas, rgbs, ts, weights_sum, depth, image) + return tuple() + + +composite_rays = _composite_rays.apply \ No newline at end of file diff --git a/raymarching/setup.py b/raymarching/setup.py new file mode 100644 index 0000000..4d32fa7 --- /dev/null +++ b/raymarching/setup.py @@ -0,0 +1,63 @@ +import os +from setuptools import setup +from torch.utils.cpp_extension import BuildExtension, CUDAExtension + +_src_path = os.path.dirname(os.path.abspath(__file__)) + +nvcc_flags = [ + '-O3', '-std=c++14', + '-U__CUDA_NO_HALF_OPERATORS__', '-U__CUDA_NO_HALF_CONVERSIONS__', '-U__CUDA_NO_HALF2_OPERATORS__', +] + +if os.name == "posix": + c_flags = ['-O3', '-std=c++14'] +elif os.name == "nt": + c_flags = ['/O2', '/std:c++17'] + + # find cl.exe + def find_cl_path(): + import glob + for program_files in [r"C:\\Program Files (x86)", r"C:\\Program Files"]: + for edition in ["Enterprise", "Professional", "BuildTools", "Community"]: + paths = sorted(glob.glob(r"%s\\Microsoft Visual Studio\\*\\%s\\VC\\Tools\\MSVC\\*\\bin\\Hostx64\\x64" % (program_files, edition)), reverse=True) + if paths: + return paths[0] + + # If cl.exe is not on path, try to find it. + if os.system("where cl.exe >nul 2>nul") != 0: + cl_path = find_cl_path() + if cl_path is None: + raise RuntimeError("Could not locate a supported Microsoft Visual C++ installation") + os.environ["PATH"] += ";" + cl_path + +''' +Usage: + +python setup.py build_ext --inplace # build extensions locally, do not install (only can be used from the parent directory) + +python setup.py install # build extensions and install (copy) to PATH. +pip install . # ditto but better (e.g., dependency & metadata handling) + +python setup.py develop # build extensions and install (symbolic) to PATH. +pip install -e . # ditto but better (e.g., dependency & metadata handling) + +''' +setup( + name='raymarching', # package name, import this to use python API + ext_modules=[ + CUDAExtension( + name='_raymarching', # extension name, import this to use CUDA API + sources=[os.path.join(_src_path, 'src', f) for f in [ + 'raymarching.cu', + 'bindings.cpp', + ]], + extra_compile_args={ + 'cxx': c_flags, + 'nvcc': nvcc_flags, + } + ), + ], + cmdclass={ + 'build_ext': BuildExtension, + } +) \ No newline at end of file diff --git a/raymarching/src/bindings.cpp b/raymarching/src/bindings.cpp new file mode 100644 index 0000000..eb8f122 --- /dev/null +++ b/raymarching/src/bindings.cpp @@ -0,0 +1,20 @@ +#include + +#include "raymarching.h" + +PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) { + // utils + m.def("flatten_rays", &flatten_rays, "flatten_rays (CUDA)"); + m.def("packbits", &packbits, "packbits (CUDA)"); + m.def("near_far_from_aabb", &near_far_from_aabb, "near_far_from_aabb (CUDA)"); + m.def("sph_from_ray", &sph_from_ray, "sph_from_ray (CUDA)"); + m.def("morton3D", &morton3D, "morton3D (CUDA)"); + m.def("morton3D_invert", &morton3D_invert, "morton3D_invert (CUDA)"); + // train + m.def("march_rays_train", &march_rays_train, "march_rays_train (CUDA)"); + m.def("composite_rays_train_forward", &composite_rays_train_forward, "composite_rays_train_forward (CUDA)"); + m.def("composite_rays_train_backward", &composite_rays_train_backward, "composite_rays_train_backward (CUDA)"); + // infer + m.def("march_rays", &march_rays, "march rays (CUDA)"); + m.def("composite_rays", &composite_rays, "composite rays (CUDA)"); +} \ No newline at end of file diff --git a/raymarching/src/raymarching.cu b/raymarching/src/raymarching.cu new file mode 100644 index 0000000..0292f1c --- /dev/null +++ b/raymarching/src/raymarching.cu @@ -0,0 +1,934 @@ +#include +#include +#include + +#include +#include + +#include +#include +#include +#include + +#define CHECK_CUDA(x) TORCH_CHECK(x.device().is_cuda(), #x " must be a CUDA tensor") +#define CHECK_CONTIGUOUS(x) TORCH_CHECK(x.is_contiguous(), #x " must be a contiguous tensor") +#define CHECK_IS_INT(x) TORCH_CHECK(x.scalar_type() == at::ScalarType::Int, #x " must be an int tensor") +#define CHECK_IS_FLOATING(x) TORCH_CHECK(x.scalar_type() == at::ScalarType::Float || x.scalar_type() == at::ScalarType::Half || x.scalar_type() == at::ScalarType::Double, #x " must be a floating tensor") + + +inline constexpr __device__ float SQRT3() { return 1.7320508075688772f; } +inline constexpr __device__ float RSQRT3() { return 0.5773502691896258f; } +inline constexpr __device__ float PI() { return 3.141592653589793f; } +inline constexpr __device__ float RPI() { return 0.3183098861837907f; } + + +template +inline __host__ __device__ T div_round_up(T val, T divisor) { + return (val + divisor - 1) / divisor; +} + +inline __host__ __device__ float signf(const float x) { + return copysignf(1.0, x); +} + +inline __host__ __device__ float clamp(const float x, const float min, const float max) { + return fminf(max, fmaxf(min, x)); +} + +inline __host__ __device__ void swapf(float& a, float& b) { + float c = a; a = b; b = c; +} + +inline __device__ int mip_from_pos(const float x, const float y, const float z, const float max_cascade) { + const float mx = fmaxf(fabsf(x), fmaxf(fabsf(y), fabsf(z))); + int exponent; + frexpf(mx, &exponent); // [0, 0.5) --> -1, [0.5, 1) --> 0, [1, 2) --> 1, [2, 4) --> 2, ... + return fminf(max_cascade - 1, fmaxf(0, exponent)); +} + +inline __device__ int mip_from_dt(const float dt, const float H, const float max_cascade) { + const float mx = dt * H * 0.5; + int exponent; + frexpf(mx, &exponent); + return fminf(max_cascade - 1, fmaxf(0, exponent)); +} + +inline __host__ __device__ uint32_t __expand_bits(uint32_t v) +{ + v = (v * 0x00010001u) & 0xFF0000FFu; + v = (v * 0x00000101u) & 0x0F00F00Fu; + v = (v * 0x00000011u) & 0xC30C30C3u; + v = (v * 0x00000005u) & 0x49249249u; + return v; +} + +inline __host__ __device__ uint32_t __morton3D(uint32_t x, uint32_t y, uint32_t z) +{ + uint32_t xx = __expand_bits(x); + uint32_t yy = __expand_bits(y); + uint32_t zz = __expand_bits(z); + return xx | (yy << 1) | (zz << 2); +} + +inline __host__ __device__ uint32_t __morton3D_invert(uint32_t x) +{ + x = x & 0x49249249; + x = (x | (x >> 2)) & 0xc30c30c3; + x = (x | (x >> 4)) & 0x0f00f00f; + x = (x | (x >> 8)) & 0xff0000ff; + x = (x | (x >> 16)) & 0x0000ffff; + return x; +} + + +//////////////////////////////////////////////////// +///////////// utils ///////////// +//////////////////////////////////////////////////// + +// rays_o/d: [N, 3] +// nears/fars: [N] +// scalar_t should always be float in use. +template +__global__ void kernel_near_far_from_aabb( + const scalar_t * __restrict__ rays_o, + const scalar_t * __restrict__ rays_d, + const scalar_t * __restrict__ aabb, + const uint32_t N, + const float min_near, + scalar_t * nears, scalar_t * fars +) { + // parallel per ray + const uint32_t n = threadIdx.x + blockIdx.x * blockDim.x; + if (n >= N) return; + + // locate + rays_o += n * 3; + rays_d += n * 3; + + const float ox = rays_o[0], oy = rays_o[1], oz = rays_o[2]; + const float dx = rays_d[0], dy = rays_d[1], dz = rays_d[2]; + const float rdx = 1 / dx, rdy = 1 / dy, rdz = 1 / dz; + + // get near far (assume cube scene) + float near = (aabb[0] - ox) * rdx; + float far = (aabb[3] - ox) * rdx; + if (near > far) swapf(near, far); + + float near_y = (aabb[1] - oy) * rdy; + float far_y = (aabb[4] - oy) * rdy; + if (near_y > far_y) swapf(near_y, far_y); + + if (near > far_y || near_y > far) { + nears[n] = fars[n] = std::numeric_limits::max(); + return; + } + + if (near_y > near) near = near_y; + if (far_y < far) far = far_y; + + float near_z = (aabb[2] - oz) * rdz; + float far_z = (aabb[5] - oz) * rdz; + if (near_z > far_z) swapf(near_z, far_z); + + if (near > far_z || near_z > far) { + nears[n] = fars[n] = std::numeric_limits::max(); + return; + } + + if (near_z > near) near = near_z; + if (far_z < far) far = far_z; + + if (near < min_near) near = min_near; + + nears[n] = near; + fars[n] = far; +} + + +void near_far_from_aabb(const at::Tensor rays_o, const at::Tensor rays_d, const at::Tensor aabb, const uint32_t N, const float min_near, at::Tensor nears, at::Tensor fars) { + + static constexpr uint32_t N_THREAD = 128; + + AT_DISPATCH_FLOATING_TYPES_AND_HALF( + rays_o.scalar_type(), "near_far_from_aabb", ([&] { + kernel_near_far_from_aabb<<>>(rays_o.data_ptr(), rays_d.data_ptr(), aabb.data_ptr(), N, min_near, nears.data_ptr(), fars.data_ptr()); + })); +} + + +// rays_o/d: [N, 3] +// radius: float +// coords: [N, 2] +template +__global__ void kernel_sph_from_ray( + const scalar_t * __restrict__ rays_o, + const scalar_t * __restrict__ rays_d, + const float radius, + const uint32_t N, + scalar_t * coords +) { + // parallel per ray + const uint32_t n = threadIdx.x + blockIdx.x * blockDim.x; + if (n >= N) return; + + // locate + rays_o += n * 3; + rays_d += n * 3; + coords += n * 2; + + const float ox = rays_o[0], oy = rays_o[1], oz = rays_o[2]; + const float dx = rays_d[0], dy = rays_d[1], dz = rays_d[2]; + // const float rdx = 1 / dx, rdy = 1 / dy, rdz = 1 / dz; + + // solve t from || o + td || = radius + const float A = dx * dx + dy * dy + dz * dz; + const float B = ox * dx + oy * dy + oz * dz; // in fact B / 2 + const float C = ox * ox + oy * oy + oz * oz - radius * radius; + + const float t = (- B + sqrtf(B * B - A * C)) / A; // always use the larger solution (positive) + + // solve theta, phi (assume y is the up axis) + const float x = ox + t * dx, y = oy + t * dy, z = oz + t * dz; + const float theta = atan2(sqrtf(x * x + z * z), y); // [0, PI) + const float phi = atan2(z, x); // [-PI, PI) + + // normalize to [-1, 1] + coords[0] = 2 * theta * RPI() - 1; + coords[1] = phi * RPI(); +} + + +void sph_from_ray(const at::Tensor rays_o, const at::Tensor rays_d, const float radius, const uint32_t N, at::Tensor coords) { + + static constexpr uint32_t N_THREAD = 128; + + AT_DISPATCH_FLOATING_TYPES_AND_HALF( + rays_o.scalar_type(), "sph_from_ray", ([&] { + kernel_sph_from_ray<<>>(rays_o.data_ptr(), rays_d.data_ptr(), radius, N, coords.data_ptr()); + })); +} + + +// coords: int32, [N, 3] +// indices: int32, [N] +__global__ void kernel_morton3D( + const int * __restrict__ coords, + const uint32_t N, + int * indices +) { + // parallel + const uint32_t n = threadIdx.x + blockIdx.x * blockDim.x; + if (n >= N) return; + + // locate + coords += n * 3; + indices[n] = __morton3D(coords[0], coords[1], coords[2]); +} + + +void morton3D(const at::Tensor coords, const uint32_t N, at::Tensor indices) { + static constexpr uint32_t N_THREAD = 128; + kernel_morton3D<<>>(coords.data_ptr(), N, indices.data_ptr()); +} + + +// indices: int32, [N] +// coords: int32, [N, 3] +__global__ void kernel_morton3D_invert( + const int * __restrict__ indices, + const uint32_t N, + int * coords +) { + // parallel + const uint32_t n = threadIdx.x + blockIdx.x * blockDim.x; + if (n >= N) return; + + // locate + coords += n * 3; + + const int ind = indices[n]; + + coords[0] = __morton3D_invert(ind >> 0); + coords[1] = __morton3D_invert(ind >> 1); + coords[2] = __morton3D_invert(ind >> 2); +} + + +void morton3D_invert(const at::Tensor indices, const uint32_t N, at::Tensor coords) { + static constexpr uint32_t N_THREAD = 128; + kernel_morton3D_invert<<>>(indices.data_ptr(), N, coords.data_ptr()); +} + + +// grid: float, [C, H, H, H] +// N: int, C * H * H * H / 8 +// density_thresh: float +// bitfield: uint8, [N] +template +__global__ void kernel_packbits( + const scalar_t * __restrict__ grid, + const uint32_t N, + const float density_thresh, + uint8_t * bitfield +) { + // parallel per byte + const uint32_t n = threadIdx.x + blockIdx.x * blockDim.x; + if (n >= N) return; + + // locate + grid += n * 8; + + uint8_t bits = 0; + + #pragma unroll + for (uint8_t i = 0; i < 8; i++) { + bits |= (grid[i] > density_thresh) ? ((uint8_t)1 << i) : 0; + } + + bitfield[n] = bits; +} + + +void packbits(const at::Tensor grid, const uint32_t N, const float density_thresh, at::Tensor bitfield) { + + static constexpr uint32_t N_THREAD = 128; + + AT_DISPATCH_FLOATING_TYPES_AND_HALF( + grid.scalar_type(), "packbits", ([&] { + kernel_packbits<<>>(grid.data_ptr(), N, density_thresh, bitfield.data_ptr()); + })); +} + + +__global__ void kernel_flatten_rays( + const int * __restrict__ rays, + const uint32_t N, const uint32_t M, + int * res +) { + // parallel per ray + const uint32_t n = threadIdx.x + blockIdx.x * blockDim.x; + if (n >= N) return; + + // locate + uint32_t offset = rays[n * 2]; + uint32_t num_steps = rays[n * 2 + 1]; + + // write to res + res += offset; + for (int i = 0; i < num_steps; i++) res[i] = n; +} + +void flatten_rays(const at::Tensor rays, const uint32_t N, const uint32_t M, at::Tensor res) { + + static constexpr uint32_t N_THREAD = 128; + + kernel_flatten_rays<<>>(rays.data_ptr(), N, M, res.data_ptr()); +} + +//////////////////////////////////////////////////// +///////////// training ///////////// +//////////////////////////////////////////////////// + +// rays_o/d: [N, 3] +// grid: [CHHH / 8] +// xyzs, dirs, ts: [M, 3], [M, 3], [M, 2] +// dirs: [M, 3] +// rays: [N, 3], idx, offset, num_steps +template +__global__ void kernel_march_rays_train( + const scalar_t * __restrict__ rays_o, + const scalar_t * __restrict__ rays_d, + const uint8_t * __restrict__ grid, + const float bound, const bool contract, + const float dt_gamma, const uint32_t max_steps, + const uint32_t N, const uint32_t C, const uint32_t H, + const scalar_t* __restrict__ nears, + const scalar_t* __restrict__ fars, + scalar_t * xyzs, scalar_t * dirs, scalar_t * ts, + int * rays, + int * counter, + const scalar_t* __restrict__ noises +) { + // parallel per ray + const uint32_t n = threadIdx.x + blockIdx.x * blockDim.x; + if (n >= N) return; + + // is first pass running. + const bool first_pass = (xyzs == nullptr); + + // locate + rays_o += n * 3; + rays_d += n * 3; + rays += n * 2; + + uint32_t num_steps = max_steps; + + if (!first_pass) { + uint32_t point_index = rays[0]; + num_steps = rays[1]; + xyzs += point_index * 3; + dirs += point_index * 3; + ts += point_index * 2; + } + + // ray marching + const float ox = rays_o[0], oy = rays_o[1], oz = rays_o[2]; + const float dx = rays_d[0], dy = rays_d[1], dz = rays_d[2]; + const float rdx = 1 / dx, rdy = 1 / dy, rdz = 1 / dz; + const float rH = 1 / (float)H; + const float H3 = H * H * H; + + const float near = nears[n]; + const float far = fars[n]; + const float noise = noises[n]; + + const float dt_min = 2 * SQRT3() / max_steps; + const float dt_max = 2 * SQRT3() * bound / H; + // const float dt_max = 1e10f; + + float t0 = near; + t0 += clamp(t0 * dt_gamma, dt_min, dt_max) * noise; + float t = t0; + uint32_t step = 0; + + //if (t < far) printf("valid ray %d t=%f near=%f far=%f \n", n, t, near, far); + + while (t < far && step < num_steps) { + // current point + const float x = clamp(ox + t * dx, -bound, bound); + const float y = clamp(oy + t * dy, -bound, bound); + const float z = clamp(oz + t * dz, -bound, bound); + + float dt = clamp(t * dt_gamma, dt_min, dt_max); + + // get mip level + const int level = max(mip_from_pos(x, y, z, C), mip_from_dt(dt, H, C)); // range in [0, C - 1] + + const float mip_bound = fminf(scalbnf(1.0f, level), bound); + const float mip_rbound = 1 / mip_bound; + + // contraction + float cx = x, cy = y, cz = z; + const float mag = fmaxf(fabsf(x), fmaxf(fabsf(y), fabsf(z))); + if (contract && mag > 1) { + // L-INF norm + const float Linf_scale = (2 - 1 / mag) / mag; + cx *= Linf_scale; + cy *= Linf_scale; + cz *= Linf_scale; + } + + // convert to nearest grid position + const int nx = clamp(0.5 * (cx * mip_rbound + 1) * H, 0.0f, (float)(H - 1)); + const int ny = clamp(0.5 * (cy * mip_rbound + 1) * H, 0.0f, (float)(H - 1)); + const int nz = clamp(0.5 * (cz * mip_rbound + 1) * H, 0.0f, (float)(H - 1)); + + const uint32_t index = level * H3 + __morton3D(nx, ny, nz); + const bool occ = grid[index / 8] & (1 << (index % 8)); + + // if occpuied, advance a small step, and write to output + //if (n == 0) printf("t=%f density=%f vs thresh=%f step=%d\n", t, density, density_thresh, step); + + if (occ) { + step++; + t += dt; + if (!first_pass) { + xyzs[0] = cx; // write contracted coordinates! + xyzs[1] = cy; + xyzs[2] = cz; + dirs[0] = dx; + dirs[1] = dy; + dirs[2] = dz; + ts[0] = t; + ts[1] = dt; + xyzs += 3; + dirs += 3; + ts += 2; + } + // contraction case: cannot apply voxel skipping. + } else if (contract && mag > 1) { + t += dt; + // else, skip a large step (basically skip a voxel grid) + } else { + // calc distance to next voxel + const float tx = (((nx + 0.5f + 0.5f * signf(dx)) * rH * 2 - 1) * mip_bound - cx) * rdx; + const float ty = (((ny + 0.5f + 0.5f * signf(dy)) * rH * 2 - 1) * mip_bound - cy) * rdy; + const float tz = (((nz + 0.5f + 0.5f * signf(dz)) * rH * 2 - 1) * mip_bound - cz) * rdz; + + const float tt = t + fmaxf(0.0f, fminf(tx, fminf(ty, tz))); + // step until next voxel + do { + dt = clamp(t * dt_gamma, dt_min, dt_max); + t += dt; + } while (t < tt); + } + } + + //printf("[n=%d] step=%d, near=%f, far=%f, dt=%f, num_steps=%f\n", n, step, near, far, dt_min, (far - near) / dt_min); + + // write rays + if (first_pass) { + uint32_t point_index = atomicAdd(counter, step); + rays[0] = point_index; + rays[1] = step; + } +} + +void march_rays_train(const at::Tensor rays_o, const at::Tensor rays_d, const at::Tensor grid, const float bound, const bool contract, const float dt_gamma, const uint32_t max_steps, const uint32_t N, const uint32_t C, const uint32_t H, const at::Tensor nears, const at::Tensor fars, at::optional xyzs, at::optional dirs, at::optional ts, at::Tensor rays, at::Tensor counter, at::Tensor noises) { + + static constexpr uint32_t N_THREAD = 128; + + AT_DISPATCH_FLOATING_TYPES_AND_HALF( + rays_o.scalar_type(), "march_rays_train", ([&] { + kernel_march_rays_train<<>>(rays_o.data_ptr(), rays_d.data_ptr(), grid.data_ptr(), bound, contract, dt_gamma, max_steps, N, C, H, nears.data_ptr(), fars.data_ptr(), + xyzs.has_value() ? xyzs.value().data_ptr() : nullptr, + dirs.has_value() ? dirs.value().data_ptr() : nullptr, + ts.has_value() ? ts.value().data_ptr() : nullptr, + rays.data_ptr(), counter.data_ptr(), noises.data_ptr()); + })); +} + + +// sigmas: [M] +// rgbs: [M, 3] +// ts: [M, 2] +// rays: [N, 2], offset, num_steps +// weights: [M] +// weights_sum: [N], final pixel alpha +// depth: [N,] +// image: [N, 3] +template +__global__ void kernel_composite_rays_train_forward( + const scalar_t * __restrict__ sigmas, + const scalar_t * __restrict__ rgbs, + const scalar_t * __restrict__ ts, + const int * __restrict__ rays, + const uint32_t M, const uint32_t N, const float T_thresh, const bool binarize, + scalar_t * weights, + scalar_t * weights_sum, + scalar_t * depth, + scalar_t * image +) { + // parallel per ray + const uint32_t n = threadIdx.x + blockIdx.x * blockDim.x; + if (n >= N) return; + + // locate + uint32_t offset = rays[n * 2]; + uint32_t num_steps = rays[n * 2 + 1]; + + // empty ray, or ray that exceed max step count. + if (num_steps == 0 || offset + num_steps > M) { + weights_sum[n] = 0; + depth[n] = 0; + image[n * 3] = 0; + image[n * 3 + 1] = 0; + image[n * 3 + 2] = 0; + return; + } + + ts += offset * 2; + weights += offset; + sigmas += offset; + rgbs += offset * 3; + + // accumulate + uint32_t step = 0; + + float T = 1.0f; + float r = 0, g = 0, b = 0, ws = 0, d = 0; + + while (step < num_steps) { + + const float real_alpha = 1.0f - __expf(- sigmas[0] * ts[1]); + const float alpha = binarize ? (real_alpha > 0.5 ? 1.0 : 0.0) : real_alpha; + const float weight = alpha * T; + + weights[0] = weight; + + r += weight * rgbs[0]; + g += weight * rgbs[1]; + b += weight * rgbs[2]; + ws += weight; + d += weight * ts[0]; + + T *= 1.0f - alpha; + + // minimal remained transmittence + if (T < T_thresh) break; + + //printf("[n=%d] num_steps=%d, alpha=%f, w=%f, T=%f, sum_dt=%f, d=%f\n", n, step, alpha, weight, T, sum_delta, d); + + // locate + weights++; + sigmas++; + rgbs += 3; + ts += 2; + + step++; + } + + //printf("[n=%d] rgb=(%f, %f, %f), d=%f\n", n, r, g, b, d); + + // write + weights_sum[n] = ws; // weights_sum + depth[n] = d; + image[n * 3] = r; + image[n * 3 + 1] = g; + image[n * 3 + 2] = b; +} + + +void composite_rays_train_forward(const at::Tensor sigmas, const at::Tensor rgbs, const at::Tensor ts, const at::Tensor rays, const uint32_t M, const uint32_t N, const float T_thresh, const bool binarize, at::Tensor weights, at::Tensor weights_sum, at::Tensor depth, at::Tensor image) { + + static constexpr uint32_t N_THREAD = 128; + + AT_DISPATCH_FLOATING_TYPES_AND_HALF( + sigmas.scalar_type(), "composite_rays_train_forward", ([&] { + kernel_composite_rays_train_forward<<>>(sigmas.data_ptr(), rgbs.data_ptr(), ts.data_ptr(), rays.data_ptr(), M, N, T_thresh, binarize, weights.data_ptr(), weights_sum.data_ptr(), depth.data_ptr(), image.data_ptr()); + })); +} + + +// grad_weights: [M,] +// grad_weights_sum: [N,] +// grad_image: [N, 3] +// grad_depth: [N,] +// sigmas: [M] +// rgbs: [M, 3] +// ts: [M, 2] +// rays: [N, 2], offset, num_steps +// weights_sum: [N,], weights_sum here +// image: [N, 3] +// grad_sigmas: [M] +// grad_rgbs: [M, 3] +template +__global__ void kernel_composite_rays_train_backward( + const scalar_t * __restrict__ grad_weights, + const scalar_t * __restrict__ grad_weights_sum, + const scalar_t * __restrict__ grad_depth, + const scalar_t * __restrict__ grad_image, + const scalar_t * __restrict__ sigmas, + const scalar_t * __restrict__ rgbs, + const scalar_t * __restrict__ ts, + const int * __restrict__ rays, + const scalar_t * __restrict__ weights_sum, + const scalar_t * __restrict__ depth, + const scalar_t * __restrict__ image, + const uint32_t M, const uint32_t N, const float T_thresh, const bool binarize, + scalar_t * grad_sigmas, + scalar_t * grad_rgbs +) { + // parallel per ray + const uint32_t n = threadIdx.x + blockIdx.x * blockDim.x; + if (n >= N) return; + + // locate + uint32_t offset = rays[n * 2]; + uint32_t num_steps = rays[n * 2 + 1]; + + if (num_steps == 0 || offset + num_steps > M) return; + + grad_weights += offset; + grad_weights_sum += n; + grad_depth += n; + grad_image += n * 3; + weights_sum += n; + depth += n; + image += n * 3; + sigmas += offset; + rgbs += offset * 3; + ts += offset * 2; + grad_sigmas += offset; + grad_rgbs += offset * 3; + + // accumulate + uint32_t step = 0; + + float T = 1.0f; + const float r_final = image[0], g_final = image[1], b_final = image[2], ws_final = weights_sum[0], d_final = depth[0]; + float r = 0, g = 0, b = 0, ws = 0, d = 0; + + while (step < num_steps) { + + const float real_alpha = 1.0f - __expf(- sigmas[0] * ts[1]); + const float alpha = binarize ? (real_alpha > 0.5 ? 1.0 : 0.0) : real_alpha; + const float weight = alpha * T; + + r += weight * rgbs[0]; + g += weight * rgbs[1]; + b += weight * rgbs[2]; + ws += weight; + d += weight * ts[0]; + + T *= 1.0f - alpha; + + // check https://note.kiui.moe/others/nerf_gradient/ for the gradient calculation. + // write grad_rgbs + grad_rgbs[0] = grad_image[0] * weight; + grad_rgbs[1] = grad_image[1] * weight; + grad_rgbs[2] = grad_image[2] * weight; + + // write grad_sigmas + grad_sigmas[0] = ts[1] * ( + grad_image[0] * (T * rgbs[0] - (r_final - r)) + + grad_image[1] * (T * rgbs[1] - (g_final - g)) + + grad_image[2] * (T * rgbs[2] - (b_final - b)) + + (grad_weights_sum[0] + grad_weights[0]) * (T - (ws_final - ws)) + + grad_depth[0] * (T * ts[0] - (d_final - d)) + ); + + //printf("[n=%d] num_steps=%d, T=%f, grad_sigmas=%f, r_final=%f, r=%f\n", n, step, T, grad_sigmas[0], r_final, r); + // minimal remained transmittence + if (T < T_thresh) break; + + // locate + sigmas++; + rgbs += 3; + ts += 2; + grad_weights++; + grad_sigmas++; + grad_rgbs += 3; + + step++; + } +} + + +void composite_rays_train_backward(const at::Tensor grad_weights, const at::Tensor grad_weights_sum, const at::Tensor grad_depth, const at::Tensor grad_image, const at::Tensor sigmas, const at::Tensor rgbs, const at::Tensor ts, const at::Tensor rays, const at::Tensor weights_sum, const at::Tensor depth, const at::Tensor image, const uint32_t M, const uint32_t N, const float T_thresh, const bool binarize, at::Tensor grad_sigmas, at::Tensor grad_rgbs) { + + static constexpr uint32_t N_THREAD = 128; + + AT_DISPATCH_FLOATING_TYPES_AND_HALF( + grad_image.scalar_type(), "composite_rays_train_backward", ([&] { + kernel_composite_rays_train_backward<<>>(grad_weights.data_ptr(), grad_weights_sum.data_ptr(), grad_depth.data_ptr(), grad_image.data_ptr(), sigmas.data_ptr(), rgbs.data_ptr(), ts.data_ptr(), rays.data_ptr(), weights_sum.data_ptr(), depth.data_ptr(), image.data_ptr(), M, N, T_thresh, binarize, grad_sigmas.data_ptr(), grad_rgbs.data_ptr()); + })); +} + + +//////////////////////////////////////////////////// +///////////// infernce ///////////// +//////////////////////////////////////////////////// + +template +__global__ void kernel_march_rays( + const uint32_t n_alive, + const uint32_t n_step, + const int* __restrict__ rays_alive, + const scalar_t* __restrict__ rays_t, + const scalar_t* __restrict__ rays_o, + const scalar_t* __restrict__ rays_d, + const float bound, const bool contract, + const float dt_gamma, const uint32_t max_steps, + const uint32_t C, const uint32_t H, + const uint8_t * __restrict__ grid, + const scalar_t* __restrict__ nears, + const scalar_t* __restrict__ fars, + scalar_t* xyzs, scalar_t* dirs, scalar_t* ts, + const scalar_t* __restrict__ noises +) { + const uint32_t n = threadIdx.x + blockIdx.x * blockDim.x; + if (n >= n_alive) return; + + const int index = rays_alive[n]; // ray id + const float noise = noises[n]; + + // locate + rays_o += index * 3; + rays_d += index * 3; + xyzs += n * n_step * 3; + dirs += n * n_step * 3; + ts += n * n_step * 2; + + const float ox = rays_o[0], oy = rays_o[1], oz = rays_o[2]; + const float dx = rays_d[0], dy = rays_d[1], dz = rays_d[2]; + const float rdx = 1 / dx, rdy = 1 / dy, rdz = 1 / dz; + const float rH = 1 / (float)H; + const float H3 = H * H * H; + + const float near = nears[index], far = fars[index]; + + const float dt_min = 2 * SQRT3() / max_steps; + const float dt_max = 2 * SQRT3() * bound / H; + // const float dt_max = 1e10f; + + // march for n_step steps, record points + float t = rays_t[index]; + t += clamp(t * dt_gamma, dt_min, dt_max) * noise; + uint32_t step = 0; + + while (t < far && step < n_step) { + // current point + const float x = clamp(ox + t * dx, -bound, bound); + const float y = clamp(oy + t * dy, -bound, bound); + const float z = clamp(oz + t * dz, -bound, bound); + + float dt = clamp(t * dt_gamma, dt_min, dt_max); + + // get mip level + const int level = max(mip_from_pos(x, y, z, C), mip_from_dt(dt, H, C)); // range in [0, C - 1] + + const float mip_bound = fminf(scalbnf(1, level), bound); + const float mip_rbound = 1 / mip_bound; + + // contraction + float cx = x, cy = y, cz = z; + const float mag = fmaxf(fabsf(x), fmaxf(fabsf(y), fabsf(z))); + if (contract && mag > 1) { + // L-INF norm + const float Linf_scale = (2 - 1 / mag) / mag; + cx *= Linf_scale; + cy *= Linf_scale; + cz *= Linf_scale; + } + + // convert to nearest grid position + const int nx = clamp(0.5 * (cx * mip_rbound + 1) * H, 0.0f, (float)(H - 1)); + const int ny = clamp(0.5 * (cy * mip_rbound + 1) * H, 0.0f, (float)(H - 1)); + const int nz = clamp(0.5 * (cz * mip_rbound + 1) * H, 0.0f, (float)(H - 1)); + + const uint32_t index = level * H3 + __morton3D(nx, ny, nz); + const bool occ = grid[index / 8] & (1 << (index % 8)); + + // if occpuied, advance a small step, and write to output + if (occ) { + // write step + xyzs[0] = cx; + xyzs[1] = cy; + xyzs[2] = cz; + dirs[0] = dx; + dirs[1] = dy; + dirs[2] = dz; + // calc dt + t += dt; + ts[0] = t; + ts[1] = dt; + // step + xyzs += 3; + dirs += 3; + ts += 2; + step++; + + // contraction case + } else if (contract && mag > 1) { + t += dt; + // else, skip a large step (basically skip a voxel grid) + } else { + // calc distance to next voxel + const float tx = (((nx + 0.5f + 0.5f * signf(dx)) * rH * 2 - 1) * mip_bound - cx) * rdx; + const float ty = (((ny + 0.5f + 0.5f * signf(dy)) * rH * 2 - 1) * mip_bound - cy) * rdy; + const float tz = (((nz + 0.5f + 0.5f * signf(dz)) * rH * 2 - 1) * mip_bound - cz) * rdz; + const float tt = t + fmaxf(0.0f, fminf(tx, fminf(ty, tz))); + // step until next voxel + do { + dt = clamp(t * dt_gamma, dt_min, dt_max); + t += dt; + } while (t < tt); + } + } +} + + +void march_rays(const uint32_t n_alive, const uint32_t n_step, const at::Tensor rays_alive, const at::Tensor rays_t, const at::Tensor rays_o, const at::Tensor rays_d, const float bound, const bool contract, const float dt_gamma, const uint32_t max_steps, const uint32_t C, const uint32_t H, const at::Tensor grid, const at::Tensor near, const at::Tensor far, at::Tensor xyzs, at::Tensor dirs, at::Tensor ts, at::Tensor noises) { + static constexpr uint32_t N_THREAD = 128; + + AT_DISPATCH_FLOATING_TYPES_AND_HALF( + rays_o.scalar_type(), "march_rays", ([&] { + kernel_march_rays<<>>(n_alive, n_step, rays_alive.data_ptr(), rays_t.data_ptr(), rays_o.data_ptr(), rays_d.data_ptr(), bound, contract, dt_gamma, max_steps, C, H, grid.data_ptr(), near.data_ptr(), far.data_ptr(), xyzs.data_ptr(), dirs.data_ptr(), ts.data_ptr(), noises.data_ptr()); + })); +} + + +template +__global__ void kernel_composite_rays( + const uint32_t n_alive, + const uint32_t n_step, + const float T_thresh, const bool binarize, + int* rays_alive, + scalar_t* rays_t, + const scalar_t* __restrict__ sigmas, + const scalar_t* __restrict__ rgbs, + const scalar_t* __restrict__ ts, + scalar_t* weights_sum, scalar_t* depth, scalar_t* image +) { + const uint32_t n = threadIdx.x + blockIdx.x * blockDim.x; + if (n >= n_alive) return; + + const int index = rays_alive[n]; // ray id + + // locate + sigmas += n * n_step; + rgbs += n * n_step * 3; + ts += n * n_step * 2; + + rays_t += index; + weights_sum += index; + depth += index; + image += index * 3; + + float t; + float d = depth[0], r = image[0], g = image[1], b = image[2], weight_sum = weights_sum[0]; + + // accumulate + uint32_t step = 0; + while (step < n_step) { + + // ray is terminated if t == 0 + if (ts[0] == 0) break; + + const float real_alpha = 1.0f - __expf(- sigmas[0] * ts[1]); + const float alpha = binarize ? (real_alpha > 0.5 ? 1.0 : 0.0) : real_alpha; + + /* + T_0 = 1; T_i = \prod_{j=0}^{i-1} (1 - alpha_j) + w_i = alpha_i * T_i + --> + T_i = 1 - \sum_{j=0}^{i-1} w_j + */ + const float T = 1 - weight_sum; + const float weight = alpha * T; + weight_sum += weight; + + t = ts[0]; + d += weight * t; // real depth + r += weight * rgbs[0]; + g += weight * rgbs[1]; + b += weight * rgbs[2]; + + //printf("[n=%d] num_steps=%d, alpha=%f, w=%f, T=%f, sum_dt=%f, d=%f\n", n, step, alpha, weight, T, sum_delta, d); + + // ray is terminated if T is too small + // use a larger bound to further accelerate inference + if (T < T_thresh) break; + + // locate + sigmas++; + rgbs += 3; + ts += 2; + step++; + } + + //printf("[n=%d] rgb=(%f, %f, %f), d=%f\n", n, r, g, b, d); + + // rays_alive = -1 means ray is terminated early. + if (step < n_step) { + rays_alive[n] = -1; + } else { + rays_t[0] = t; + } + + weights_sum[0] = weight_sum; // this is the thing I needed! + depth[0] = d; + image[0] = r; + image[1] = g; + image[2] = b; +} + + +void composite_rays(const uint32_t n_alive, const uint32_t n_step, const float T_thresh, const bool binarize, at::Tensor rays_alive, at::Tensor rays_t, at::Tensor sigmas, at::Tensor rgbs, at::Tensor ts, at::Tensor weights, at::Tensor depth, at::Tensor image) { + static constexpr uint32_t N_THREAD = 128; + AT_DISPATCH_FLOATING_TYPES_AND_HALF( + image.scalar_type(), "composite_rays", ([&] { + kernel_composite_rays<<>>(n_alive, n_step, T_thresh, binarize, rays_alive.data_ptr(), rays_t.data_ptr(), sigmas.data_ptr(), rgbs.data_ptr(), ts.data_ptr(), weights.data_ptr(), depth.data_ptr(), image.data_ptr()); + })); +} \ No newline at end of file diff --git a/raymarching/src/raymarching.h b/raymarching/src/raymarching.h new file mode 100644 index 0000000..a9994d3 --- /dev/null +++ b/raymarching/src/raymarching.h @@ -0,0 +1,19 @@ +#pragma once + +#include +#include + + +void near_far_from_aabb(const at::Tensor rays_o, const at::Tensor rays_d, const at::Tensor aabb, const uint32_t N, const float min_near, at::Tensor nears, at::Tensor fars); +void sph_from_ray(const at::Tensor rays_o, const at::Tensor rays_d, const float radius, const uint32_t N, at::Tensor coords); +void morton3D(const at::Tensor coords, const uint32_t N, at::Tensor indices); +void morton3D_invert(const at::Tensor indices, const uint32_t N, at::Tensor coords); +void packbits(const at::Tensor grid, const uint32_t N, const float density_thresh, at::Tensor bitfield); +void flatten_rays(const at::Tensor rays, const uint32_t N, const uint32_t M, at::Tensor res); + +void march_rays_train(const at::Tensor rays_o, const at::Tensor rays_d, const at::Tensor grid, const float bound, const bool contract, const float dt_gamma, const uint32_t max_steps, const uint32_t N, const uint32_t C, const uint32_t H, const at::Tensor nears, const at::Tensor fars, at::optional xyzs, at::optional dirs, at::optional ts, at::Tensor rays, at::Tensor counter, at::Tensor noises); +void composite_rays_train_forward(const at::Tensor sigmas, const at::Tensor rgbs, const at::Tensor ts, const at::Tensor rays, const uint32_t M, const uint32_t N, const float T_thresh, const bool binarize, at::Tensor weights, at::Tensor weights_sum, at::Tensor depth, at::Tensor image); +void composite_rays_train_backward(const at::Tensor grad_weights, const at::Tensor grad_weights_sum, const at::Tensor grad_depth, const at::Tensor grad_image, const at::Tensor sigmas, const at::Tensor rgbs, const at::Tensor ts, const at::Tensor rays, const at::Tensor weights_sum, const at::Tensor depth, const at::Tensor image, const uint32_t M, const uint32_t N, const float T_thresh, const bool binarize, at::Tensor grad_sigmas, at::Tensor grad_rgbs); + +void march_rays(const uint32_t n_alive, const uint32_t n_step, const at::Tensor rays_alive, const at::Tensor rays_t, const at::Tensor rays_o, const at::Tensor rays_d, const float bound, const bool contract, const float dt_gamma, const uint32_t max_steps, const uint32_t C, const uint32_t H, const at::Tensor grid, const at::Tensor nears, const at::Tensor fars, at::Tensor xyzs, at::Tensor dirs, at::Tensor ts, at::Tensor noises); +void composite_rays(const uint32_t n_alive, const uint32_t n_step, const float T_thresh, const bool binarize, at::Tensor rays_alive, at::Tensor rays_t, at::Tensor sigmas, at::Tensor rgbs, at::Tensor ts, at::Tensor weights_sum, at::Tensor depth, at::Tensor image); \ No newline at end of file diff --git a/readme.md b/readme.md new file mode 100644 index 0000000..13f2cc5 --- /dev/null +++ b/readme.md @@ -0,0 +1,294 @@ +# Magic123: One Image to High-Quality 3D Object Generation Using Both 2D and 3D Diffusion Priors + +[arXiv](https://arxiv.org/abs/2306.17843) | [webpage](https://guochengqian.github.io/project/magic123/) + + + +[Guocheng Qian](https://guochengqian.github.io/) 1,2, [Jinjie Mai](https://cemse.kaust.edu.sa/people/person/jinjie-mai) 1, [Abdullah Hamdi](https://abdullahamdi.com/) 3, [Jian Ren](https://alanspike.github.io/) 2, [Aliaksandr Siarohin](https://aliaksandrsiarohin.github.io/aliaksandr-siarohin-website/) 2, [Bing Li](https://cemse.kaust.edu.sa/people/person/bing-li) 1, [Hsin-Ying Lee](http://hsinyinglee.com/) 2, [Ivan Skorokhodov](https://universome.github.io/) 1,2, [Peter Wonka](https://peterwonka.net/) 1, [Sergey Tulyakov](http://www.stulyakov.com/) 2, [Bernard Ghanem](https://www.bernardghanem.com/) 1 + +1 [King Abdullah University of Science and Technology (KAUST)](https://www.kaust.edu.sa/), +2 [Snap Inc.](https://www.snap.com/), +3 [Visual Geometry Group, University of Oxford](http://www.robots.ox.ac.uk/~vgg/) + + +A demo example of the training convergence: + + + +Compare Magic123 with using only 2D prior (SDS) or using only 3D prior (Zero123): + + + +Official PyTorch Implementation of Magic123: One Image to High-Quality 3D Object Generation Using Both 2D and 3D Diffusion Priors. + + +# NEWS: +- [2023/07/25] Code is available at [GitHub](https://github.com/guochengqian/Magic123) +- [2023/07/03] Paper is available at [arXiv](https://arxiv.org/abs/2306.17843) +- [2023/06/25] Much better performance than the submitted version is achieved by 1）reimplementing Magic123 using [Stable DreamFusion code](https://github.com/ashawkey/stable-dreamfusion), 2）fixing some gradient issues, 3）leveraging the [tricks]((#tips-and-tricks)) +- [2023] Initial version of Magic123 submitted to conference + + +# Install + +### Install Environment + +```bash +source install.sh +``` + +### Download pre-trained models + +* [Zero-1-to-3](https://github.com/cvlab-columbia/zero123) for 3D diffusion prior. + We use `105000.ckpt` by default, reimplementation borrowed from Stable Diffusion repo, and is available in `guidance/zero123_utils.py`. + ```bash + cd pretrained/zero123 + wget https://huggingface.co/cvlab/zero123-weights/resolve/main/105000.ckpt + cd .../../ + ``` + +* [MiDaS](https://github.com/isl-org/MiDaS) for depth estimation. + We use `dpt_beit_large_512.pt`. Put it in folder `pretrained/midas/` + ```bash + mkdir -p pretrained/midas + cd pretrained/midas + wget https://github.com/isl-org/MiDaS/releases/download/v3_1/dpt_beit_large_512.pt + cd ../../ + ``` + +# Usage +## Preprocess [Optional] +We have included all preprocessed files in `./data` directory. Preprocessing is only necessary if you want to test on your own examples. + +### Step1: Extract depth +``` +python preprocess_image.py --path /path/to/image +``` + + +### Step 2: Textural inversion [Optional] +Magic123 uses the defualt [textural inversion](https://huggingface.co/docs/diffusers/training/text_inversion) from diffuers, which consumes around 2.5 hours on a 32G V100. If you do not want to spend time in this textural inversion, you can: (1) study whether there is other faster textural inversion; or (2) do not use textural inversion in the loss of texture and shape consistencies. To run textural inversion: + +``` +bash scripts/texural_inversion/textural_inversion.sh $GPU_IDX runwayml/stable-diffusion-v1-5 /path/to/example/rgba.png /path/to/save $token_name $init_token --max_train_steps 5000 +``` +$token_name is a the special token, usually name that by _examplename_ +$init_token is a single token to describe the image using natural language + +For example: +```bash +bash scripts/texural_inversion/textural_inversion.sh runwayml/stable-diffusion-v1-5 data/demo/ironman/rgba.png out/textual_inversion/ironman _ironman_ ironman --max_train_steps 3000 +``` +Don't forget to move the final `learned_embeds.bin` under data/demo/ironman/ + + +## Run +### Run Magic123 for a single example +Takes ~40 mins for the coarse stage and ~20 mins for the second stage on a 32G V100. +```bash +bash scripts/magic123/run_both_priors.sh $GPU_NO $JOBNAME_First_Stage $JOBNAME_Second_Stage $PATH_to_Example_Directory $IMAGE_BASE_NAME $Enable_First_Stage $Enable_Second_Stage {More_Arugments} +``` + +As an example, run Magic123 in the dragon example using both stages in GPU 0 and set the jobname for the first stage as `default` and the jobname for the second stage as `dmtet`, by the following command: +```bash +bash scripts/magic123/run_both_priors.sh 0 default dmtet data/realfusion15/metal_dragon_statue rgba.png 1 1 +``` + +More arguments (e.g. `--lambda_guidance 1 40`) can be appended to the command line such as: +```bash +bash scripts/magic123/run_both_priors.sh 0 default dmtet data/realfusion15/metal_dragon_statue rgba.png 1 1 --lambda_guidance 1 40 +``` + +### Run Magic123 for a group of examples +- Run all examples in a folder, check the scripts `scripts/magic123/run_folder_both_priors.sh` +- Run all examples in a given list, check the scripts `scripts/magic123/run_list_both_priors.sh` + + +### Run Magic123 on a single example without textural inversion +Textural inversion is tedious (requires ~2.5 hours optimization), if you want to test Magic123 quickly on your own example without texural inversion (might degrade the performance), try the following: + +- first, foreground and depth estimation + ``` + python preprocess_image.py --path data/demo/ironman/ironman.png + ``` + +- Run Magic123 coarse stage without textural inversion, takes ~40 mins + ``` + export RUN_ID='default-a-full-body-ironman' + export DATA_DIR='data/demo/ironman' + export IMAGE_NAME='rgba.png' + export FILENAME=$(basename $DATA_DIR) + export dataset=$(basename $(dirname $DATA_DIR)) + CUDA_VISIBLE_DEVICES=0 python main.py -O \ + --text "A high-resolution DSLR image of a full body ironman" \ + --sd_version 1.5 \ + --image ${DATA_DIR}/${IMAGE_NAME} \ + --workspace out/magic123-${RUN_ID}-coarse/$dataset/magic123_${FILENAME}_${RUN_ID}_coarse \ + --optim adam \ + --iters 5000 \ + --guidance SD zero123 \ + --lambda_guidance 1.0 40 \ + --guidance_scale 100 5 \ + --latent_iter_ratio 0 \ + --normal_iter_ratio 0.2 \ + --t_range 0.2 0.6 \ + --bg_radius -1 \ + --save_mesh + ``` + +- Run Magic123 fine stage without textural inversion, takes around ~20 mins + ``` + export RUN_ID='default-a-full-body-ironman' + export RUN_ID2='dmtet' + export DATA_DIR='data/demo/ironman' + export IMAGE_NAME='rgba.png' + export FILENAME=$(basename $DATA_DIR) + export dataset=$(basename $(dirname $DATA_DIR)) + CUDA_VISIBLE_DEVICES=0 python main.py -O \ + --text "A high-resolution DSLR image of a full body ironman" \ + --sd_version 1.5 \ + --image ${DATA_DIR}/${IMAGE_NAME} \ + --workspace out/magic123-${RUN_ID}-${RUN_ID2}/$dataset/magic123_${FILENAME}_${RUN_ID}_${RUN_ID2} \ + --dmtet --init_ckpt out/magic123-${RUN_ID}-coarse/$dataset/magic123_${FILENAME}_${RUN_ID}_coarse/checkpoints/magic123_${FILENAME}_${RUN_ID}_coarse.pth \ + --iters 5000 \ + --optim adam \ + --known_view_interval 4 \ + --latent_iter_ratio 0 \ + --guidance SD zero123 \ + --lambda_guidance 1e-3 0.01 \ + --guidance_scale 100 5 \ + --rm_edge \ + --bg_radius -1 \ + --save_mesh + ``` + +### Run ablation studies +- Run Magic123 with only 2D prior *with* textural inversion (Like RealFusion but we achieve much better performance through training stragies and the coarse-to-fine pipeline) + ``` + bash scripts/magic123/run_2dprior.sh 0 default dmtet data/realfusion15/metal_dragon_statue rgba.png 1 1 + ``` + +- Run Magic123 with only 2D prior *without* textural inversion (Like RealFusion but we achieve much better performance through training stragies and the coarse-to-fine pipeline) + ``` + bash scripts/magic123/run_2dprior_notextinv_ironman.sh 0 default 1 1 + ``` + note: change the path and the text prompt inside the script if you wana test another example. + +- Run Magic123 with only 3D prior (Like Zero-1-to-3 but we achieve much better performance through training stragies and the coarse-to-fine pipeline) + ``` + bash scripts/magic123/run_3dprior.sh 0 default dmtet data/demo/ironman rgba.png 1 1 + ``` + + +# Tips and Tricks +1. Fix camera distance (*radius_range*) and FOV (*fovy_range*) and tune the camera polar range (*theta_range*). Note it is better to keep camera jittering to reduce grid artifacts. +2. Smaller range of time steps for the defusion noise (t_range). We find *[0.2, 0.6]* gives better performance for image-to-3D tasks. +3. Using normals as latent in the first 2000 improves generated geometry a bit gernerally (but not always). We turn on this for Magic123 corase stage in the script `--normal_iter_ratio 0.2` +4. We erode segmentation edges (makes the segmentation map 2 pixels shrinked towards internal side) to remove artifacts due to segmentation erros. This is turned on in the fine stage in magic123 in the script through `--rm_edge` +5. Other general tricks such as improved texural inversion, advanced diffusion prior (DeepFloyd, SD-XL), stronger 3D prior (Zero123-XL), and larger batch size can be adopted as well but not studied in this work. + + +# Acknowledgement +This work is build upon Stable DreamFusion, many thanks to the author [Kiui Jiaxiang Tang](https://github.com/ashawkey) and many other contributors. + +* [Stable DreamFusion](https://github.com/ashawkey/stable-dreamfusion) + +``` +@misc{stable-dreamfusion, + Author = {Jiaxiang Tang}, + Year = {2022}, + Note = {https://github.com/ashawkey/stable-dreamfusion}, + Title = {Stable-dreamfusion: Text-to-3D with Stable-diffusion} +} +``` + + +We also get inspirations from a list of amazing research works and open-source projects, thanks a lot to all the authors for sharing! + +* [DreamFusion: Text-to-3D using 2D Diffusion](https://dreamfusion3d.github.io/) + ``` + @article{poole2022dreamfusion, + author = {Poole, Ben and Jain, Ajay and Barron, Jonathan T. and Mildenhall, Ben}, + title = {DreamFusion: Text-to-3D using 2D Diffusion}, + journal = {arXiv}, + year = {2022}, + } + ``` + +* [Magic3D: High-Resolution Text-to-3D Content Creation](https://research.nvidia.com/labs/dir/magic3d/) + ``` + @inproceedings{lin2023magic3d, + title={Magic3D: High-Resolution Text-to-3D Content Creation}, + author={Lin, Chen-Hsuan and Gao, Jun and Tang, Luming and Takikawa, Towaki and Zeng, Xiaohui and Huang, Xun and Kreis, Karsten and Fidler, Sanja and Liu, Ming-Yu and Lin, Tsung-Yi}, + booktitle={IEEE Conference on Computer Vision and Pattern Recognition ({CVPR})}, + year={2023} + } + ``` + +* [Zero-1-to-3: Zero-shot One Image to 3D Object](https://github.com/cvlab-columbia/zero123) + ``` + @misc{liu2023zero1to3, + title={Zero-1-to-3: Zero-shot One Image to 3D Object}, + author={Ruoshi Liu and Rundi Wu and Basile Van Hoorick and Pavel Tokmakov and Sergey Zakharov and Carl Vondrick}, + year={2023}, + eprint={2303.11328}, + archivePrefix={arXiv}, + primaryClass={cs.CV} + } + ``` + +* [RealFusion: 360° Reconstruction of Any Object from a Single Image](https://github.com/lukemelas/realfusion) + ``` + @inproceedings{melaskyriazi2023realfusion, + author = {Melas-Kyriazi, Luke and Rupprecht, Christian and Laina, Iro and Vedaldi, Andrea}, + title = {RealFusion: 360 Reconstruction of Any Object from a Single Image}, + booktitle={CVPR} + year = {2023}, + url = {https://arxiv.org/abs/2302.10663}, + } + ``` + +* [Make-it-3d: High-fidelity 3d creation from a single image with diffusion prior](https://arxiv.org/abs/2303.14184) + ``` + @article{tang2023make-it-3d, + title={Make-it-3d: High-fidelity 3d creation from a single image with diffusion prior}, + author={Tang, Junshu and Wang, Tengfei and Zhang, Bo and Zhang, Ting and Yi, Ran and Ma, Lizhuang and Chen, Dong}, + journal={arXiv preprint arXiv:2303.14184}, + year={2023} + } + ``` + +* [Stable Diffusion](https://github.com/CompVis/stable-diffusion) and the [diffusers](https://github.com/huggingface/diffusers) library. + + ``` + @misc{rombach2021highresolution, + title={High-Resolution Image Synthesis with Latent Diffusion Models}, + author={Robin Rombach and Andreas Blattmann and Dominik Lorenz and Patrick Esser and Björn Ommer}, + year={2021}, + eprint={2112.10752}, + archivePrefix={arXiv}, + primaryClass={cs.CV} + } + + @misc{von-platen-etal-2022-diffusers, + author = {Patrick von Platen and Suraj Patil and Anton Lozhkov and Pedro Cuenca and Nathan Lambert and Kashif Rasul and Mishig Davaadorj and Thomas Wolf}, + title = {Diffusers: State-of-the-art diffusion models}, + year = {2022}, + publisher = {GitHub}, + journal = {GitHub repository}, + howpublished = {\url{https://github.com/huggingface/diffusers}} + } + ``` + + +# Cite +If you find this work useful, a citation will be appreciated via: +``` +@article{qian2023magic123, + title={Magic123: One Image to High-Quality 3D Object Generation Using Both 2D and 3D Diffusion Priors}, + author={Qian, Guocheng and Mai, Jinjie and Hamdi, Abdullah and Ren, Jian and Siarohin, Aliaksandr and Li, Bing and Lee, Hsin-Ying and Skorokhodov, Ivan and Wonka, Peter and Tulyakov, Sergey and others}, + journal={arXiv preprint arXiv:2306.17843}, + year={2023} +} +``` + diff --git a/render/light.py b/render/light.py new file mode 100644 index 0000000..7ccfd9e --- /dev/null +++ b/render/light.py @@ -0,0 +1,158 @@ +# Copyright (c) 2020-2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# +# NVIDIA CORPORATION, its affiliates and licensors retain all intellectual +# property and proprietary rights in and to this material, related +# documentation and any modifications thereto. Any use, reproduction, +# disclosure or distribution of this material and related documentation +# without an express license agreement from NVIDIA CORPORATION or +# its affiliates is strictly prohibited. + +import os +import numpy as np +import torch +import nvdiffrast.torch as dr + +from . import util +from . import renderutils as ru + +###################################################################################### +# Utility functions +###################################################################################### + +class cubemap_mip(torch.autograd.Function): + @staticmethod + def forward(ctx, cubemap): + return util.avg_pool_nhwc(cubemap, (2,2)) + + @staticmethod + def backward(ctx, dout): + res = dout.shape[1] * 2 + out = torch.zeros(6, res, res, dout.shape[-1], dtype=torch.float32, device="cuda") + for s in range(6): + gy, gx = torch.meshgrid(torch.linspace(-1.0 + 1.0 / res, 1.0 - 1.0 / res, res, device="cuda"), + torch.linspace(-1.0 + 1.0 / res, 1.0 - 1.0 / res, res, device="cuda"), + ) # indexing='ij') + v = util.safe_normalize(util.cube_to_dir(s, gx, gy)) + out[s, ...] = dr.texture(dout[None, ...] * 0.25, v[None, ...].contiguous(), filter_mode='linear', boundary_mode='cube') + return out + +###################################################################################### +# Split-sum environment map light source with automatic mipmap generation +###################################################################################### + +class EnvironmentLight(torch.nn.Module): + LIGHT_MIN_RES = 16 + + MIN_ROUGHNESS = 0.08 + MAX_ROUGHNESS = 0.5 + + def __init__(self, base): + super(EnvironmentLight, self).__init__() + self.mtx = None + self.base = torch.nn.Parameter(base.clone().detach(), requires_grad=True) + self.register_parameter('env_base', self.base) + + def xfm(self, mtx): + self.mtx = mtx + + def clone(self): + return EnvironmentLight(self.base.clone().detach()) + + def clamp_(self, min=None, max=None): + self.base.clamp_(min, max) + + def get_mip(self, roughness): + return torch.where(roughness < self.MAX_ROUGHNESS + , (torch.clamp(roughness, self.MIN_ROUGHNESS, self.MAX_ROUGHNESS) - self.MIN_ROUGHNESS) / (self.MAX_ROUGHNESS - self.MIN_ROUGHNESS) * (len(self.specular) - 2) + , (torch.clamp(roughness, self.MAX_ROUGHNESS, 1.0) - self.MAX_ROUGHNESS) / (1.0 - self.MAX_ROUGHNESS) + len(self.specular) - 2) + + def build_mips(self, cutoff=0.99): + self.specular = [self.base] + while self.specular[-1].shape[1] > self.LIGHT_MIN_RES: + self.specular += [cubemap_mip.apply(self.specular[-1])] + + self.diffuse = ru.diffuse_cubemap(self.specular[-1]) + + for idx in range(len(self.specular) - 1): + roughness = (idx / (len(self.specular) - 2)) * (self.MAX_ROUGHNESS - self.MIN_ROUGHNESS) + self.MIN_ROUGHNESS + self.specular[idx] = ru.specular_cubemap(self.specular[idx], roughness, cutoff) + self.specular[-1] = ru.specular_cubemap(self.specular[-1], 1.0, cutoff) + + def regularizer(self): + white = (self.base[..., 0:1] + self.base[..., 1:2] + self.base[..., 2:3]) / 3.0 + return torch.mean(torch.abs(self.base - white)) + + def shade(self, gb_pos, gb_normal, kd, ks, view_pos, specular=True): + wo = util.safe_normalize(view_pos - gb_pos) + + if specular: + roughness = ks[..., 1:2] # y component + metallic = ks[..., 2:3] # z component + spec_col = (1.0 - metallic)*0.04 + kd * metallic + diff_col = kd * (1.0 - metallic) + else: + diff_col = kd + + reflvec = util.safe_normalize(util.reflect(wo, gb_normal)) + nrmvec = gb_normal + if self.mtx is not None: # Rotate lookup + mtx = torch.as_tensor(self.mtx, dtype=torch.float32, device='cuda') + reflvec = ru.xfm_vectors(reflvec.view(reflvec.shape[0], reflvec.shape[1] * reflvec.shape[2], reflvec.shape[3]), mtx).view(*reflvec.shape) + nrmvec = ru.xfm_vectors(nrmvec.view(nrmvec.shape[0], nrmvec.shape[1] * nrmvec.shape[2], nrmvec.shape[3]), mtx).view(*nrmvec.shape) + + # Diffuse lookup + diffuse = dr.texture(self.diffuse[None, ...], nrmvec.contiguous(), filter_mode='linear', boundary_mode='cube') + shaded_col = diffuse * diff_col + + if specular: + # Lookup FG term from lookup texture + NdotV = torch.clamp(util.dot(wo, gb_normal), min=1e-4) + fg_uv = torch.cat((NdotV, roughness), dim=-1) + if not hasattr(self, '_FG_LUT'): + self._FG_LUT = torch.as_tensor(np.fromfile('data/irrmaps/bsdf_256_256.bin', dtype=np.float32).reshape(1, 256, 256, 2), dtype=torch.float32, device='cuda') + fg_lookup = dr.texture(self._FG_LUT, fg_uv, filter_mode='linear', boundary_mode='clamp') + + # Roughness adjusted specular env lookup + miplevel = self.get_mip(roughness) + spec = dr.texture(self.specular[0][None, ...], reflvec.contiguous(), mip=list(m[None, ...] for m in self.specular[1:]), mip_level_bias=miplevel[..., 0], filter_mode='linear-mipmap-linear', boundary_mode='cube') + + # Compute aggregate lighting + reflectance = spec_col * fg_lookup[...,0:1] + fg_lookup[...,1:2] + shaded_col += spec * reflectance + + return shaded_col * (1.0 - ks[..., 0:1]) # Modulate by hemisphere visibility + +###################################################################################### +# Load and store +###################################################################################### + +# Load from latlong .HDR file +def _load_env_hdr(fn, scale=1.0): + latlong_img = torch.tensor(util.load_image(fn), dtype=torch.float32, device='cuda')*scale + cubemap = util.latlong_to_cubemap(latlong_img, [512, 512]) + + l = EnvironmentLight(cubemap) + l.build_mips() + + return l + +def load_env(fn, scale=1.0): + if os.path.splitext(fn)[1].lower() == ".hdr": + return _load_env_hdr(fn, scale) + else: + assert False, "Unknown envlight extension %s" % os.path.splitext(fn)[1] + +def save_env_map(fn, light): + assert isinstance(light, EnvironmentLight), "Can only save EnvironmentLight currently" + if isinstance(light, EnvironmentLight): + color = util.cubemap_to_latlong(light.base, [512, 1024]) + util.save_image_raw(fn, color.detach().cpu().numpy()) + +###################################################################################### +# Create trainable env map with random initialization +###################################################################################### + +def create_trainable_env_rnd(base_res, scale=0.5, bias=0.25): + base = torch.rand(6, base_res, base_res, 3, dtype=torch.float32, device='cuda') * scale + bias + return EnvironmentLight(base) + diff --git a/render/material.py b/render/material.py new file mode 100644 index 0000000..892073f --- /dev/null +++ b/render/material.py @@ -0,0 +1,182 @@ +# Copyright (c) 2020-2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# +# NVIDIA CORPORATION, its affiliates and licensors retain all intellectual +# property and proprietary rights in and to this material, related +# documentation and any modifications thereto. Any use, reproduction, +# disclosure or distribution of this material and related documentation +# without an express license agreement from NVIDIA CORPORATION or +# its affiliates is strictly prohibited. + +import os +import numpy as np +import torch + +from . import util +from . import texture + +###################################################################################### +# Wrapper to make materials behave like a python dict, but register textures as +# torch.nn.Module parameters. +###################################################################################### +class Material(torch.nn.Module): + def __init__(self, mat_dict): + super(Material, self).__init__() + self.mat_keys = set() + for key in mat_dict.keys(): + self.mat_keys.add(key) + self[key] = mat_dict[key] + + def __contains__(self, key): + return hasattr(self, key) + + def __getitem__(self, key): + return getattr(self, key) + + def __setitem__(self, key, val): + self.mat_keys.add(key) + setattr(self, key, val) + + def __delitem__(self, key): + self.mat_keys.remove(key) + delattr(self, key) + + def keys(self): + return self.mat_keys + +###################################################################################### +# .mtl material format loading / storing +###################################################################################### +@torch.no_grad() +def load_mtl(fn, clear_ks=True): + import re + mtl_path = os.path.dirname(fn) + + # Read file + with open(fn, 'r') as f: + lines = f.readlines() + + # Parse materials + materials = [] + for line in lines: + split_line = re.split(' +|\t+|\n+', line.strip()) + prefix = split_line[0].lower() + data = split_line[1:] + if 'newmtl' in prefix: + material = Material({'name' : data[0]}) + materials += [material] + elif materials: + if 'bsdf' in prefix or 'map_kd' in prefix or 'map_ks' in prefix or 'bump' in prefix: + material[prefix] = data[0] + else: + material[prefix] = torch.tensor(tuple(float(d) for d in data), dtype=torch.float32, device='cuda') + + # Convert everything to textures. Our code expects 'kd' and 'ks' to be texture maps. So replace constants with 1x1 maps + for mat in materials: + if not 'bsdf' in mat: + mat['bsdf'] = 'pbr' + + if 'map_kd' in mat: + mat['kd'] = texture.load_texture2D(os.path.join(mtl_path, mat['map_kd'])) + else: + mat['kd'] = texture.Texture2D(mat['kd']) + + if 'map_ks' in mat: + mat['ks'] = texture.load_texture2D(os.path.join(mtl_path, mat['map_ks']), channels=3) + else: + mat['ks'] = texture.Texture2D(mat['ks']) + + if 'bump' in mat: + mat['normal'] = texture.load_texture2D(os.path.join(mtl_path, mat['bump']), lambda_fn=lambda x: x * 2 - 1, channels=3) + + # Convert Kd from sRGB to linear RGB + mat['kd'] = texture.srgb_to_rgb(mat['kd']) + + if clear_ks: + # Override ORM occlusion (red) channel by zeros. We hijack this channel + for mip in mat['ks'].getMips(): + mip[..., 0] = 0.0 + + return materials + +@torch.no_grad() +def save_mtl(fn, material): + folder = os.path.dirname(fn) + with open(fn, "w") as f: + f.write('newmtl defaultMat\n') + if material is not None: + f.write('bsdf %s\n' % material['bsdf']) + if 'kd' in material.keys(): + f.write('map_kd texture_kd.png\n') + texture.save_texture2D(os.path.join(folder, 'texture_kd.png'), texture.rgb_to_srgb(material['kd'])) + if 'ks' in material.keys(): + f.write('map_ks texture_ks.png\n') + texture.save_texture2D(os.path.join(folder, 'texture_ks.png'), material['ks']) + if 'normal' in material.keys(): + f.write('bump texture_n.png\n') + texture.save_texture2D(os.path.join(folder, 'texture_n.png'), material['normal'], lambda_fn=lambda x:(util.safe_normalize(x)+1)*0.5) + else: + f.write('Kd 1 1 1\n') + f.write('Ks 0 0 0\n') + f.write('Ka 0 0 0\n') + f.write('Tf 1 1 1\n') + f.write('Ni 1\n') + f.write('Ns 0\n') + +###################################################################################### +# Merge multiple materials into a single uber-material +###################################################################################### + +def _upscale_replicate(x, full_res): + x = x.permute(0, 3, 1, 2) + x = torch.nn.functional.pad(x, (0, full_res[1] - x.shape[3], 0, full_res[0] - x.shape[2]), 'replicate') + return x.permute(0, 2, 3, 1).contiguous() + +def merge_materials(materials, texcoords, tfaces, mfaces): + assert len(materials) > 0 + for mat in materials: + assert mat['bsdf'] == materials[0]['bsdf'], "All materials must have the same BSDF (uber shader)" + assert ('normal' in mat) is ('normal' in materials[0]), "All materials must have either normal map enabled or disabled" + + uber_material = Material({ + 'name' : 'uber_material', + 'bsdf' : materials[0]['bsdf'], + }) + + textures = ['kd', 'ks', 'normal'] + + # Find maximum texture resolution across all materials and textures + max_res = None + for mat in materials: + for tex in textures: + tex_res = np.array(mat[tex].getRes()) if tex in mat else np.array([1, 1]) + max_res = np.maximum(max_res, tex_res) if max_res is not None else tex_res + + # Compute size of compund texture and round up to nearest PoT + full_res = 2**np.ceil(np.log2(max_res * np.array([1, len(materials)]))).astype(np.int) + + # Normalize texture resolution across all materials & combine into a single large texture + for tex in textures: + if tex in materials[0]: + tex_data = torch.cat(tuple(util.scale_img_nhwc(mat[tex].data, tuple(max_res)) for mat in materials), dim=2) # Lay out all textures horizontally, NHWC so dim2 is x + tex_data = _upscale_replicate(tex_data, full_res) + uber_material[tex] = texture.Texture2D(tex_data) + + # Compute scaling values for used / unused texture area + s_coeff = [full_res[0] / max_res[0], full_res[1] / max_res[1]] + + # Recompute texture coordinates to cooincide with new composite texture + new_tverts = {} + new_tverts_data = [] + for fi in range(len(tfaces)): + matIdx = mfaces[fi] + for vi in range(3): + ti = tfaces[fi][vi] + if not (ti in new_tverts): + new_tverts[ti] = {} + if not (matIdx in new_tverts[ti]): # create new vertex + new_tverts_data.append([(matIdx + texcoords[ti][0]) / s_coeff[1], texcoords[ti][1] / s_coeff[0]]) # Offset texture coodrinate (x direction) by material id & scale to local space. Note, texcoords are (u,v) but texture is stored (w,h) so the indexes swap here + new_tverts[ti][matIdx] = len(new_tverts_data) - 1 + tfaces[fi][vi] = new_tverts[ti][matIdx] # reindex vertex + + return uber_material, new_tverts_data, tfaces + diff --git a/render/mesh.py b/render/mesh.py new file mode 100644 index 0000000..d9f10e9 --- /dev/null +++ b/render/mesh.py @@ -0,0 +1,241 @@ +# Copyright (c) 2020-2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# +# NVIDIA CORPORATION, its affiliates and licensors retain all intellectual +# property and proprietary rights in and to this material, related +# documentation and any modifications thereto. Any use, reproduction, +# disclosure or distribution of this material and related documentation +# without an express license agreement from NVIDIA CORPORATION or +# its affiliates is strictly prohibited. + +import os +import numpy as np +import torch + +from . import obj +from . import util + +###################################################################################### +# Base mesh class +###################################################################################### +class Mesh: + def __init__(self, v_pos=None, t_pos_idx=None, v_nrm=None, t_nrm_idx=None, v_tex=None, t_tex_idx=None, v_tng=None, t_tng_idx=None, material=None, base=None): + self.v_pos = v_pos + self.v_nrm = v_nrm + self.v_tex = v_tex + self.v_tng = v_tng + self.t_pos_idx = t_pos_idx + self.t_nrm_idx = t_nrm_idx + self.t_tex_idx = t_tex_idx + self.t_tng_idx = t_tng_idx + self.material = material + + if base is not None: + self.copy_none(base) + + def copy_none(self, other): + if self.v_pos is None: + self.v_pos = other.v_pos + if self.t_pos_idx is None: + self.t_pos_idx = other.t_pos_idx + if self.v_nrm is None: + self.v_nrm = other.v_nrm + if self.t_nrm_idx is None: + self.t_nrm_idx = other.t_nrm_idx + if self.v_tex is None: + self.v_tex = other.v_tex + if self.t_tex_idx is None: + self.t_tex_idx = other.t_tex_idx + if self.v_tng is None: + self.v_tng = other.v_tng + if self.t_tng_idx is None: + self.t_tng_idx = other.t_tng_idx + if self.material is None: + self.material = other.material + + def clone(self): + out = Mesh(base=self) + if out.v_pos is not None: + out.v_pos = out.v_pos.clone().detach() + if out.t_pos_idx is not None: + out.t_pos_idx = out.t_pos_idx.clone().detach() + if out.v_nrm is not None: + out.v_nrm = out.v_nrm.clone().detach() + if out.t_nrm_idx is not None: + out.t_nrm_idx = out.t_nrm_idx.clone().detach() + if out.v_tex is not None: + out.v_tex = out.v_tex.clone().detach() + if out.t_tex_idx is not None: + out.t_tex_idx = out.t_tex_idx.clone().detach() + if out.v_tng is not None: + out.v_tng = out.v_tng.clone().detach() + if out.t_tng_idx is not None: + out.t_tng_idx = out.t_tng_idx.clone().detach() + return out + +###################################################################################### +# Mesh loeading helper +###################################################################################### + +def load_mesh(filename, mtl_override=None): + name, ext = os.path.splitext(filename) + if ext == ".obj": + return obj.load_obj(filename, clear_ks=True, mtl_override=mtl_override) + assert False, "Invalid mesh file extension" + +###################################################################################### +# Compute AABB +###################################################################################### +def aabb(mesh): + return torch.min(mesh.v_pos, dim=0).values, torch.max(mesh.v_pos, dim=0).values + +###################################################################################### +# Compute unique edge list from attribute/vertex index list +###################################################################################### +def compute_edges(attr_idx, return_inverse=False): + with torch.no_grad(): + # Create all edges, packed by triangle + all_edges = torch.cat(( + torch.stack((attr_idx[:, 0], attr_idx[:, 1]), dim=-1), + torch.stack((attr_idx[:, 1], attr_idx[:, 2]), dim=-1), + torch.stack((attr_idx[:, 2], attr_idx[:, 0]), dim=-1), + ), dim=-1).view(-1, 2) + + # Swap edge order so min index is always first + order = (all_edges[:, 0] > all_edges[:, 1]).long().unsqueeze(dim=1) + sorted_edges = torch.cat(( + torch.gather(all_edges, 1, order), + torch.gather(all_edges, 1, 1 - order) + ), dim=-1) + + # Eliminate duplicates and return inverse mapping + return torch.unique(sorted_edges, dim=0, return_inverse=return_inverse) + +###################################################################################### +# Compute unique edge to face mapping from attribute/vertex index list +###################################################################################### +def compute_edge_to_face_mapping(attr_idx, return_inverse=False): + with torch.no_grad(): + # Get unique edges + # Create all edges, packed by triangle + all_edges = torch.cat(( + torch.stack((attr_idx[:, 0], attr_idx[:, 1]), dim=-1), + torch.stack((attr_idx[:, 1], attr_idx[:, 2]), dim=-1), + torch.stack((attr_idx[:, 2], attr_idx[:, 0]), dim=-1), + ), dim=-1).view(-1, 2) + + # Swap edge order so min index is always first + order = (all_edges[:, 0] > all_edges[:, 1]).long().unsqueeze(dim=1) + sorted_edges = torch.cat(( + torch.gather(all_edges, 1, order), + torch.gather(all_edges, 1, 1 - order) + ), dim=-1) + + # Elliminate duplicates and return inverse mapping + unique_edges, idx_map = torch.unique(sorted_edges, dim=0, return_inverse=True) + + tris = torch.arange(attr_idx.shape[0]).repeat_interleave(3).cuda() + + tris_per_edge = torch.zeros((unique_edges.shape[0], 2), dtype=torch.int64).cuda() + + # Compute edge to face table + mask0 = order[:,0] == 0 + mask1 = order[:,0] == 1 + tris_per_edge[idx_map[mask0], 0] = tris[mask0] + tris_per_edge[idx_map[mask1], 1] = tris[mask1] + + return tris_per_edge + +###################################################################################### +# Align base mesh to reference mesh:move & rescale to match bounding boxes. +###################################################################################### +def unit_size(mesh): + with torch.no_grad(): + vmin, vmax = aabb(mesh) + scale = 2 / torch.max(vmax - vmin).item() + v_pos = mesh.v_pos - (vmax + vmin) / 2 # Center mesh on origin + v_pos = v_pos * scale # Rescale to unit size + + return Mesh(v_pos, base=mesh) + +###################################################################################### +# Center & scale mesh for rendering +###################################################################################### +def center_by_reference(base_mesh, ref_aabb, scale): + center = (ref_aabb[0] + ref_aabb[1]) * 0.5 + scale = scale / torch.max(ref_aabb[1] - ref_aabb[0]).item() + v_pos = (base_mesh.v_pos - center[None, ...]) * scale + return Mesh(v_pos, base=base_mesh) + +###################################################################################### +# Simple smooth vertex normal computation +###################################################################################### +def auto_normals(imesh): + + i0 = imesh.t_pos_idx[:, 0] + i1 = imesh.t_pos_idx[:, 1] + i2 = imesh.t_pos_idx[:, 2] + + v0 = imesh.v_pos[i0, :] + v1 = imesh.v_pos[i1, :] + v2 = imesh.v_pos[i2, :] + + face_normals = torch.cross(v1 - v0, v2 - v0) + + # Splat face normals to vertices + v_nrm = torch.zeros_like(imesh.v_pos) + v_nrm.scatter_add_(0, i0[:, None].repeat(1,3), face_normals) + v_nrm.scatter_add_(0, i1[:, None].repeat(1,3), face_normals) + v_nrm.scatter_add_(0, i2[:, None].repeat(1,3), face_normals) + + # Normalize, replace zero (degenerated) normals with some default value + v_nrm = torch.where(util.dot(v_nrm, v_nrm) > 1e-20, v_nrm, torch.tensor([0.0, 0.0, 1.0], dtype=torch.float32, device='cuda')) + v_nrm = util.safe_normalize(v_nrm) + + if torch.is_anomaly_enabled(): + assert torch.all(torch.isfinite(v_nrm)) + + return Mesh(v_nrm=v_nrm, t_nrm_idx=imesh.t_pos_idx, base=imesh) + +###################################################################################### +# Compute tangent space from texture map coordinates +# Follows http://www.mikktspace.com/ conventions +###################################################################################### +def compute_tangents(imesh): + vn_idx = [None] * 3 + pos = [None] * 3 + tex = [None] * 3 + for i in range(0,3): + pos[i] = imesh.v_pos[imesh.t_pos_idx[:, i]] + tex[i] = imesh.v_tex[imesh.t_tex_idx[:, i]] + vn_idx[i] = imesh.t_nrm_idx[:, i] + + tangents = torch.zeros_like(imesh.v_nrm) + tansum = torch.zeros_like(imesh.v_nrm) + + # Compute tangent space for each triangle + uve1 = tex[1] - tex[0] + uve2 = tex[2] - tex[0] + pe1 = pos[1] - pos[0] + pe2 = pos[2] - pos[0] + + nom = (pe1 * uve2[..., 1:2] - pe2 * uve1[..., 1:2]) + denom = (uve1[..., 0:1] * uve2[..., 1:2] - uve1[..., 1:2] * uve2[..., 0:1]) + + # Avoid division by zero for degenerated texture coordinates + tang = nom / torch.where(denom > 0.0, torch.clamp(denom, min=1e-6), torch.clamp(denom, max=-1e-6)) + + # Update all 3 vertices + for i in range(0,3): + idx = vn_idx[i][:, None].repeat(1,3) + tangents.scatter_add_(0, idx, tang) # tangents[n_i] = tangents[n_i] + tang + tansum.scatter_add_(0, idx, torch.ones_like(tang)) # tansum[n_i] = tansum[n_i] + 1 + tangents = tangents / tansum + + # Normalize and make sure tangent is perpendicular to normal + tangents = util.safe_normalize(tangents) + tangents = util.safe_normalize(tangents - util.dot(tangents, imesh.v_nrm) * imesh.v_nrm) + + if torch.is_anomaly_enabled(): + assert torch.all(torch.isfinite(tangents)) + + return Mesh(v_tng=tangents, t_tng_idx=imesh.t_nrm_idx, base=imesh) diff --git a/render/mlptexture.py b/render/mlptexture.py new file mode 100644 index 0000000..51f497e --- /dev/null +++ b/render/mlptexture.py @@ -0,0 +1,111 @@ +# Copyright (c) 2020-2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# +# NVIDIA CORPORATION, its affiliates and licensors retain all intellectual +# property and proprietary rights in and to this material, related +# documentation and any modifications thereto. Any use, reproduction, +# disclosure or distribution of this material and related documentation +# without an express license agreement from NVIDIA CORPORATION or +# its affiliates is strictly prohibited. + +import torch +import numpy as np +# import tinycudann as tcnn +from gridencoder import GridEncoder + +####################################################################################################################################################### +# Small MLP using PyTorch primitives, internal helper class +####################################################################################################################################################### + +class _MLP(torch.nn.Module): + def __init__(self, cfg, loss_scale=1.0): + super(_MLP, self).__init__() + self.loss_scale = loss_scale + + net = (torch.nn.Linear(cfg['n_input_dims'], cfg['n_neurons'], bias=False), torch.nn.ReLU()) + for i in range(cfg['n_hidden_layers']-1): + net = net + (torch.nn.Linear(cfg['n_neurons'], cfg['n_neurons'], bias=False), torch.nn.ReLU()) + net = net + (torch.nn.Linear(cfg['n_neurons'], cfg['n_output_dims'], bias=False),) + self.net = torch.nn.Sequential(*net).cuda() + + self.net.apply(self._init_weights) + + # if self.loss_scale != 1.0: + # self.net.register_full_backward_hook(lambda module, grad_i, grad_o: (grad_i[0] * self.loss_scale, )) + + def forward(self, x): + return self.net(x.to(torch.float32)) + + @staticmethod + def _init_weights(m): + if type(m) == torch.nn.Linear: + torch.nn.init.kaiming_uniform_(m.weight, nonlinearity='relu') + if hasattr(m.bias, 'data'): + m.bias.data.fill_(0.0) + +####################################################################################################################################################### +# Outward visible MLP class +####################################################################################################################################################### + +class MLPTexture3D(torch.nn.Module): + def __init__(self, AABB, channels = 9, internal_dims = 32, hidden = 2, min_max = None): + super(MLPTexture3D, self).__init__() + + self.channels = channels + self.internal_dims = internal_dims + self.AABB = AABB + self.min_max = min_max + + # Setup positional encoding, see https://github.com/NVlabs/tiny-cuda-nn for details + desired_resolution = 4096 + base_grid_resolution = 16 + num_levels = 16 + per_level_scale = np.exp(np.log(desired_resolution / base_grid_resolution) / (num_levels-1)) + + # enc_cfg = { + # "otype": "HashGrid", + # "n_levels": num_levels, + # "n_features_per_level": 2, + # "log2_hashmap_size": 19, + # "base_resolution": base_grid_resolution, + # "per_level_scale" : per_level_scale + # } + + # gradient_scaling = 128.0 + # self.encoder = tcnn.Encoding(3, enc_cfg) + # self.encoder.register_full_backward_hook(lambda module, grad_i, grad_o: (grad_i[0] / gradient_scaling, )) + + self.encoder = GridEncoder(3, num_levels, base_resolution=base_grid_resolution, per_level_scale=per_level_scale).cuda() + + # Setup MLP + mlp_cfg = { + "n_input_dims" : self.encoder.output_dim, + "n_output_dims" : self.channels, + "n_hidden_layers" : hidden, + "n_neurons" : self.internal_dims + } + self.net = _MLP(mlp_cfg) + print("Encoder output: %d dims" % (self.encoder.output_dim)) + + # Sample texture at a given location + def sample(self, texc): + # texc: [n, h, w, 3] + # normalize coords into [0, 1] + _texc = (texc.view(-1, 3) - self.AABB[0][None, ...]) / (self.AABB[1][None, ...] - self.AABB[0][None, ...]) + _texc = torch.clamp(_texc, min=0, max=1) + + p_enc = self.encoder(_texc.contiguous()) + out = self.net.forward(p_enc) + + # Sigmoid limit and scale to the allowed range + out = torch.sigmoid(out) * (self.min_max[1][None, :] - self.min_max[0][None, :]) + self.min_max[0][None, :] + + return out.view(*texc.shape[:-1], self.channels) # Remap to [n, h, w, 9] + + # In-place clamp with no derivative to make sure values are in valid range after training + def clamp_(self): + pass + + def cleanup(self): + # tcnn.free_temporary_memory() + pass + diff --git a/render/obj.py b/render/obj.py new file mode 100644 index 0000000..1cd7f18 --- /dev/null +++ b/render/obj.py @@ -0,0 +1,179 @@ +# Copyright (c) 2020-2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# +# NVIDIA CORPORATION, its affiliates and licensors retain all intellectual +# property and proprietary rights in and to this material, related +# documentation and any modifications thereto. Any use, reproduction, +# disclosure or distribution of this material and related documentation +# without an express license agreement from NVIDIA CORPORATION or +# its affiliates is strictly prohibited. + +import os +import torch + +from . import texture +from . import mesh +from . import material + +###################################################################################### +# Utility functions +###################################################################################### + +def _find_mat(materials, name): + for mat in materials: + if mat['name'] == name: + return mat + return materials[0] # Materials 0 is the default + +###################################################################################### +# Create mesh object from objfile +###################################################################################### + +def load_obj(filename, clear_ks=True, mtl_override=None): + obj_path = os.path.dirname(filename) + + # Read entire file + with open(filename, 'r') as f: + lines = f.readlines() + + # Load materials + all_materials = [ + { + 'name' : '_default_mat', + 'bsdf' : 'pbr', + 'kd' : texture.Texture2D(torch.tensor([0.5, 0.5, 0.5], dtype=torch.float32, device='cuda')), + 'ks' : texture.Texture2D(torch.tensor([0.0, 0.0, 0.0], dtype=torch.float32, device='cuda')) + } + ] + if mtl_override is None: + for line in lines: + if len(line.split()) == 0: + continue + if line.split()[0] == 'mtllib': + all_materials += material.load_mtl(os.path.join(obj_path, line.split()[1]), clear_ks) # Read in entire material library + else: + all_materials += material.load_mtl(mtl_override) + + # load vertices + vertices, texcoords, normals = [], [], [] + for line in lines: + if len(line.split()) == 0: + continue + + prefix = line.split()[0].lower() + if prefix == 'v': + vertices.append([float(v) for v in line.split()[1:]]) + elif prefix == 'vt': + val = [float(v) for v in line.split()[1:]] + texcoords.append([val[0], 1.0 - val[1]]) + elif prefix == 'vn': + normals.append([float(v) for v in line.split()[1:]]) + + # load faces + activeMatIdx = None + used_materials = [] + faces, tfaces, nfaces, mfaces = [], [], [], [] + for line in lines: + if len(line.split()) == 0: + continue + + prefix = line.split()[0].lower() + if prefix == 'usemtl': # Track used materials + mat = _find_mat(all_materials, line.split()[1]) + if not mat in used_materials: + used_materials.append(mat) + activeMatIdx = used_materials.index(mat) + elif prefix == 'f': # Parse face + vs = line.split()[1:] + nv = len(vs) + vv = vs[0].split('/') + v0 = int(vv[0]) - 1 + t0 = int(vv[1]) - 1 if vv[1] != "" else -1 + n0 = int(vv[2]) - 1 if vv[2] != "" else -1 + for i in range(nv - 2): # Triangulate polygons + vv = vs[i + 1].split('/') + v1 = int(vv[0]) - 1 + t1 = int(vv[1]) - 1 if vv[1] != "" else -1 + n1 = int(vv[2]) - 1 if vv[2] != "" else -1 + vv = vs[i + 2].split('/') + v2 = int(vv[0]) - 1 + t2 = int(vv[1]) - 1 if vv[1] != "" else -1 + n2 = int(vv[2]) - 1 if vv[2] != "" else -1 + mfaces.append(activeMatIdx) + faces.append([v0, v1, v2]) + tfaces.append([t0, t1, t2]) + nfaces.append([n0, n1, n2]) + assert len(tfaces) == len(faces) and len(nfaces) == len (faces) + + # Create an "uber" material by combining all textures into a larger texture + if len(used_materials) > 1: + uber_material, texcoords, tfaces = material.merge_materials(used_materials, texcoords, tfaces, mfaces) + else: + uber_material = used_materials[0] + + vertices = torch.tensor(vertices, dtype=torch.float32, device='cuda') + texcoords = torch.tensor(texcoords, dtype=torch.float32, device='cuda') if len(texcoords) > 0 else None + normals = torch.tensor(normals, dtype=torch.float32, device='cuda') if len(normals) > 0 else None + + faces = torch.tensor(faces, dtype=torch.int64, device='cuda') + tfaces = torch.tensor(tfaces, dtype=torch.int64, device='cuda') if texcoords is not None else None + nfaces = torch.tensor(nfaces, dtype=torch.int64, device='cuda') if normals is not None else None + + print(f'[load_obj] vertices: {vertices.shape}, faces: {faces.shape}') + print(f'[load_obj] texcoords: {texcoords.shape if texcoords is not None else "None"}') + + return mesh.Mesh(vertices, faces, normals, nfaces, texcoords, tfaces, material=uber_material) + +###################################################################################### +# Save mesh object to objfile +###################################################################################### + +def write_obj(folder, mesh, save_material=True): + obj_file = os.path.join(folder, 'mesh.obj') + print("Writing mesh: ", obj_file) + with open(obj_file, "w") as f: + f.write("mtllib mesh.mtl\n") + f.write("g default\n") + + v_pos = mesh.v_pos.detach().cpu().numpy() if mesh.v_pos is not None else None + v_nrm = mesh.v_nrm.detach().cpu().numpy() if mesh.v_nrm is not None else None + v_tex = mesh.v_tex.detach().cpu().numpy() if mesh.v_tex is not None else None + + t_pos_idx = mesh.t_pos_idx.detach().cpu().numpy() if mesh.t_pos_idx is not None else None + t_nrm_idx = mesh.t_nrm_idx.detach().cpu().numpy() if mesh.t_nrm_idx is not None else None + t_tex_idx = mesh.t_tex_idx.detach().cpu().numpy() if mesh.t_tex_idx is not None else None + + print(" writing %d vertices" % len(v_pos)) + for v in v_pos: + f.write('v {} {} {} \n'.format(v[0], v[1], v[2])) + + if v_tex is not None: + print(" writing %d texcoords" % len(v_tex)) + assert(len(t_pos_idx) == len(t_tex_idx)) + for v in v_tex: + f.write('vt {} {} \n'.format(v[0], 1.0 - v[1])) + + if v_nrm is not None: + print(" writing %d normals" % len(v_nrm)) + assert(len(t_pos_idx) == len(t_nrm_idx)) + for v in v_nrm: + f.write('vn {} {} {}\n'.format(v[0], v[1], v[2])) + + # faces + f.write("s 1 \n") + f.write("g pMesh1\n") + f.write("usemtl defaultMat\n") + + # Write faces + print(" writing %d faces" % len(t_pos_idx)) + for i in range(len(t_pos_idx)): + f.write("f ") + for j in range(3): + f.write(' %s/%s/%s' % (str(t_pos_idx[i][j]+1), '' if v_tex is None else str(t_tex_idx[i][j]+1), '' if v_nrm is None else str(t_nrm_idx[i][j]+1))) + f.write("\n") + + if save_material: + mtl_file = os.path.join(folder, 'mesh.mtl') + print("Writing material: ", mtl_file) + material.save_mtl(mtl_file, mesh.material) + + print("Done exporting mesh") diff --git a/render/regularizer.py b/render/regularizer.py new file mode 100644 index 0000000..8c74d69 --- /dev/null +++ b/render/regularizer.py @@ -0,0 +1,82 @@ +# Copyright (c) 2020-2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# +# NVIDIA CORPORATION, its affiliates and licensors retain all intellectual +# property and proprietary rights in and to this material, related +# documentation and any modifications thereto. Any use, reproduction, +# disclosure or distribution of this material and related documentation +# without an express license agreement from NVIDIA CORPORATION or +# its affiliates is strictly prohibited. + +import torch +import nvdiffrast.torch as dr + +from . import util +from . import mesh + +###################################################################################### +# Computes the image gradient, useful for kd/ks smoothness losses +###################################################################################### +def image_grad(buf, std=0.01): + t, s = torch.meshgrid(torch.linspace(-1.0 + 1.0 / buf.shape[1], 1.0 - 1.0 / buf.shape[1], buf.shape[1], device="cuda"), + torch.linspace(-1.0 + 1.0 / buf.shape[2], 1.0 - 1.0 / buf.shape[2], buf.shape[2], device="cuda"), + ) # indexing='ij') + tc = torch.normal(mean=0, std=std, size=(buf.shape[0], buf.shape[1], buf.shape[2], 2), device="cuda") + torch.stack((s, t), dim=-1)[None, ...] + tap = dr.texture(buf, tc, filter_mode='linear', boundary_mode='clamp') + return torch.abs(tap[..., :-1] - buf[..., :-1]) * tap[..., -1:] * buf[..., -1:] + +###################################################################################### +# Computes the avergage edge length of a mesh. +# Rough estimate of the tessellation of a mesh. Can be used e.g. to clamp gradients +###################################################################################### +def avg_edge_length(v_pos, t_pos_idx): + e_pos_idx = mesh.compute_edges(t_pos_idx) + edge_len = util.length(v_pos[e_pos_idx[:, 0]] - v_pos[e_pos_idx[:, 1]]) + return torch.mean(edge_len) + +###################################################################################### +# Laplacian regularization using umbrella operator (Fujiwara / Desbrun). +# https://mgarland.org/class/geom04/material/smoothing.pdf +###################################################################################### +def laplace_regularizer_const(v_pos, t_pos_idx): + term = torch.zeros_like(v_pos) + norm = torch.zeros_like(v_pos[..., 0:1]) + + v0 = v_pos[t_pos_idx[:, 0], :] + v1 = v_pos[t_pos_idx[:, 1], :] + v2 = v_pos[t_pos_idx[:, 2], :] + + term.scatter_add_(0, t_pos_idx[:, 0:1].repeat(1,3), (v1 - v0) + (v2 - v0)) + term.scatter_add_(0, t_pos_idx[:, 1:2].repeat(1,3), (v0 - v1) + (v2 - v1)) + term.scatter_add_(0, t_pos_idx[:, 2:3].repeat(1,3), (v0 - v2) + (v1 - v2)) + + two = torch.ones_like(v0) * 2.0 + norm.scatter_add_(0, t_pos_idx[:, 0:1], two) + norm.scatter_add_(0, t_pos_idx[:, 1:2], two) + norm.scatter_add_(0, t_pos_idx[:, 2:3], two) + + term = term / torch.clamp(norm, min=1.0) + + return torch.mean(term**2) + +###################################################################################### +# Smooth vertex normals +###################################################################################### +def normal_consistency(v_pos, t_pos_idx): + # Compute face normals + v0 = v_pos[t_pos_idx[:, 0], :] + v1 = v_pos[t_pos_idx[:, 1], :] + v2 = v_pos[t_pos_idx[:, 2], :] + + face_normals = util.safe_normalize(torch.cross(v1 - v0, v2 - v0)) + + tris_per_edge = mesh.compute_edge_to_face_mapping(t_pos_idx) + + # Fetch normals for both faces sharind an edge + n0 = face_normals[tris_per_edge[:, 0], :] + n1 = face_normals[tris_per_edge[:, 1], :] + + # Compute error metric based on normal difference + term = torch.clamp(util.dot(n0, n1), min=-1.0, max=1.0) + term = (1.0 - term) * 0.5 + + return torch.mean(torch.abs(term)) diff --git a/render/render.py b/render/render.py new file mode 100644 index 0000000..612ea2a --- /dev/null +++ b/render/render.py @@ -0,0 +1,311 @@ +# Copyright (c) 2020-2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# +# NVIDIA CORPORATION, its affiliates and licensors retain all intellectual +# property and proprietary rights in and to this material, related +# documentation and any modifications thereto. Any use, reproduction, +# disclosure or distribution of this material and related documentation +# without an express license agreement from NVIDIA CORPORATION or +# its affiliates is strictly prohibited. + +import torch +import numpy as np +import nvdiffrast.torch as dr + +from . import util +from . import renderutils as ru +from . import light + +# ============================================================================================== +# Helper functions +# ============================================================================================== +def interpolate(attr, rast, attr_idx, rast_db=None): + return dr.interpolate(attr.contiguous(), rast, attr_idx, rast_db=rast_db, diff_attrs=None if rast_db is None else 'all') + +# ============================================================================================== +# pixel shader +# ============================================================================================== +def shade( + gb_pos, gb_mask, + gb_geometric_normal, + gb_normal, + gb_tangent, + gb_texc, + gb_texc_deriv, + view_pos, + lgt, + material, + bsdf + ): + + ################################################################################ + # Texture lookups + ################################################################################ + perturbed_nrm = None + if 'kd_ks_normal' in material: + # Combined texture, used for MLPs because lookups are expensive + all_tex_jitter = material['kd_ks_normal'].sample(gb_pos + torch.normal(mean=0, std=0.01, size=gb_pos.shape, device="cuda")) + all_tex = material['kd_ks_normal'].sample(gb_pos) + assert all_tex.shape[-1] == 9 or all_tex.shape[-1] == 10, "Combined kd_ks_normal must be 9 or 10 channels" + kd, ks, perturbed_nrm = all_tex[..., :-6], all_tex[..., -6:-3], all_tex[..., -3:] + # Compute albedo (kd) gradient, used for material regularizer + kd_grad = torch.sum(torch.abs(all_tex_jitter[..., :-6] - all_tex[..., :-6]), dim=-1, keepdim=True) / 3 + else: + kd_jitter = material['kd'].sample(gb_texc + torch.normal(mean=0, std=0.005, size=gb_texc.shape, device="cuda"), gb_texc_deriv) + kd = material['kd'].sample(gb_texc, gb_texc_deriv) + ks = material['ks'].sample(gb_texc, gb_texc_deriv)[..., 0:3] # skip alpha + if 'normal' in material: + perturbed_nrm = material['normal'].sample(gb_texc, gb_texc_deriv) + kd_grad = torch.sum(torch.abs(kd_jitter[..., 0:3] - kd[..., 0:3]), dim=-1, keepdim=True) / 3 + + # Separate kd into alpha and color, default alpha = 1 + alpha = kd[..., 3:4] if kd.shape[-1] == 4 else torch.ones_like(kd[..., 0:1]) + kd = kd[..., 0:3] + + ################################################################################ + # Normal perturbation & normal bend + ################################################################################ + if 'no_perturbed_nrm' in material and material['no_perturbed_nrm']: + perturbed_nrm = None + + gb_normal = ru.prepare_shading_normal(gb_pos, view_pos, perturbed_nrm, gb_normal, gb_tangent, gb_geometric_normal, two_sided_shading=True, opengl=True) + + ################################################################################ + # Evaluate BSDF + ################################################################################ + + assert 'bsdf' in material or bsdf is not None, "Material must specify a BSDF type" + bsdf = material['bsdf'] if bsdf is None else bsdf + if bsdf == 'pbr': + if isinstance(lgt, light.EnvironmentLight): + shaded_col = lgt.shade(gb_pos, gb_normal, kd, ks, view_pos, specular=True) + else: + assert False, "Invalid light type" + elif bsdf == 'diffuse': + if isinstance(lgt, light.EnvironmentLight): + shaded_col = lgt.shade(gb_pos, gb_normal, kd, ks, view_pos, specular=False) + else: + assert False, "Invalid light type" + elif bsdf == 'normal': + shaded_col = (gb_normal + 1.0)*0.5 + elif bsdf == 'tangent': + shaded_col = (gb_tangent + 1.0)*0.5 + elif bsdf == 'kd': + shaded_col = kd + elif bsdf == 'ks': + shaded_col = ks + else: + assert False, "Invalid BSDF '%s'" % bsdf + + # Return multiple buffers + buffers = { + 'shaded' : torch.cat((shaded_col, alpha), dim=-1), + 'kd_grad' : torch.cat((kd_grad, alpha), dim=-1), + 'occlusion' : torch.cat((ks[..., :1], alpha), dim=-1), + 'normal' : torch.cat(((gb_normal + 1.0) * 0.5, gb_mask), dim=-1), + } + return buffers + +# ============================================================================================== +# Render a depth slice of the mesh (scene), some limitations: +# - Single mesh +# - Single light +# - Single material +# ============================================================================================== +def render_layer( + rast, + rast_deriv, + mesh, + view_pos, + lgt, + resolution, + spp, + msaa, + bsdf + ): + + full_res = [resolution[0]*spp, resolution[1]*spp] + + ################################################################################ + # Rasterize + ################################################################################ + + # Scale down to shading resolution when MSAA is enabled, otherwise shade at full resolution + if spp > 1 and msaa: + rast_out_s = util.scale_img_nhwc(rast, resolution, mag='nearest', min='nearest') + rast_out_deriv_s = util.scale_img_nhwc(rast_deriv, resolution, mag='nearest', min='nearest') * spp + else: + rast_out_s = rast + rast_out_deriv_s = rast_deriv + + ################################################################################ + # Interpolate attributes + ################################################################################ + + # Interpolate world space position + gb_pos, _ = interpolate(mesh.v_pos[None, ...], rast_out_s, mesh.t_pos_idx.int()) + gb_mask, _ = interpolate(torch.ones_like(mesh.v_pos[None, ..., :1]), rast_out_s, mesh.t_pos_idx.int()) + + # Compute geometric normals. We need those because of bent normals trick (for bump mapping) + v0 = mesh.v_pos[mesh.t_pos_idx[:, 0], :] + v1 = mesh.v_pos[mesh.t_pos_idx[:, 1], :] + v2 = mesh.v_pos[mesh.t_pos_idx[:, 2], :] + face_normals = util.safe_normalize(torch.cross(v1 - v0, v2 - v0)) + face_normal_indices = (torch.arange(0, face_normals.shape[0], dtype=torch.int64, device='cuda')[:, None]).repeat(1, 3) + gb_geometric_normal, _ = interpolate(face_normals[None, ...], rast_out_s, face_normal_indices.int()) + + # Compute tangent space + assert mesh.v_nrm is not None and mesh.v_tng is not None + gb_normal, _ = interpolate(mesh.v_nrm[None, ...], rast_out_s, mesh.t_nrm_idx.int()) + gb_tangent, _ = interpolate(mesh.v_tng[None, ...], rast_out_s, mesh.t_tng_idx.int()) # Interpolate tangents + + # Texture coordinate + assert mesh.v_tex is not None + gb_texc, gb_texc_deriv = interpolate(mesh.v_tex[None, ...], rast_out_s, mesh.t_tex_idx.int(), rast_db=rast_out_deriv_s) + + ################################################################################ + # Shade + ################################################################################ + + buffers = shade(gb_pos, gb_mask, gb_geometric_normal, gb_normal, gb_tangent, gb_texc, gb_texc_deriv, view_pos, lgt, mesh.material, bsdf) + + ################################################################################ + # Prepare output + ################################################################################ + + # Scale back up to visibility resolution if using MSAA + if spp > 1 and msaa: + for key in buffers.keys(): + buffers[key] = util.scale_img_nhwc(buffers[key], full_res, mag='nearest', min='nearest') + + # Return buffers + return buffers + +# ============================================================================================== +# Render a depth peeled mesh (scene), some limitations: +# - Single mesh +# - Single light +# - Single material +# ============================================================================================== + +def render_mesh( + ctx, + mesh, + mtx_in, # mvp, [B, 4, 4] + view_pos, # cam pos, [B, 3] + lgt, + resolution, # [2] (check the custom collate in dataset/dataset.py) + spp = 1, + num_layers = 1, # always 1 + msaa = False, + background = None, + bsdf = None + ): + + def prepare_input_vector(x): + x = torch.tensor(x, dtype=torch.float32, device='cuda') if not torch.is_tensor(x) else x + return x[:, None, None, :] if len(x.shape) == 2 else x + + def composite_buffer(key, layers, background, antialias): + accum = background + for buffers, rast in reversed(layers): + alpha = (rast[..., -1:] > 0).float() * buffers[key][..., -1:] + accum = torch.lerp(accum, torch.cat((buffers[key][..., :-1], torch.ones_like(buffers[key][..., -1:])), dim=-1), alpha) + if antialias: + accum = dr.antialias(accum.contiguous(), rast, v_pos_clip, mesh.t_pos_idx.int()) + return accum + + assert mesh.t_pos_idx.shape[0] > 0, "Got empty training triangle mesh (unrecoverable discontinuity)" + assert background is None or (background.shape[1] == resolution[0] and background.shape[2] == resolution[1]) + + full_res = [resolution[0]*spp, resolution[1]*spp] + + # Convert numpy arrays to torch tensors + mtx_in = torch.tensor(mtx_in, dtype=torch.float32, device='cuda') if not torch.is_tensor(mtx_in) else mtx_in + view_pos = prepare_input_vector(view_pos) # [B, 1, 1, 3] + + # clip space transform + v_pos_clip = ru.xfm_points(mesh.v_pos[None, ...], mtx_in) # just the mvp transform, [1, N, 3] + + # Render all layers front-to-back + layers = [] + with dr.DepthPeeler(ctx, v_pos_clip, mesh.t_pos_idx.int(), full_res) as peeler: + for _ in range(num_layers): + rast, db = peeler.rasterize_next_layer() + layers += [(render_layer(rast, db, mesh, view_pos, lgt, resolution, spp, msaa, bsdf), rast)] + + # Setup background + if background is not None: + if spp > 1: + background = util.scale_img_nhwc(background, full_res, mag='nearest', min='nearest') + background = torch.cat((background, torch.zeros_like(background[..., 0:1])), dim=-1) + else: + background = torch.zeros(1, full_res[0], full_res[1], 4, dtype=torch.float32, device='cuda') + + # Composite layers front-to-back + out_buffers = {} + for key in layers[0][0].keys(): + if key == 'shaded': + accum = composite_buffer(key, layers, background, True) + elif key == 'normal': + accum = composite_buffer(key, layers, torch.zeros_like(layers[0][0][key]), True) + else: + accum = composite_buffer(key, layers, torch.zeros_like(layers[0][0][key]), False) + + # Downscale to framebuffer resolution. Use avg pooling + out_buffers[key] = util.avg_pool_nhwc(accum, spp) if spp > 1 else accum + + return out_buffers + +# ============================================================================================== +# Render UVs +# ============================================================================================== +def render_uv(ctx, mesh, resolution, mlp_texture): + + # clip space transform + uv_clip = mesh.v_tex[None, ...]*2.0 - 1.0 + + # pad to four component coordinate + uv_clip4 = torch.cat((uv_clip, torch.zeros_like(uv_clip[...,0:1]), torch.ones_like(uv_clip[...,0:1])), dim = -1) + + # rasterize + rast, _ = dr.rasterize(ctx, uv_clip4, mesh.t_tex_idx.int(), resolution) + + # Interpolate world space position + gb_pos, _ = interpolate(mesh.v_pos[None, ...], rast, mesh.t_pos_idx.int()) + + # Sample out textures from MLP + all_tex = mlp_texture.sample(gb_pos) + assert all_tex.shape[-1] == 9 or all_tex.shape[-1] == 10, "Combined kd_ks_normal must be 9 or 10 channels" + + mask = (rast[..., -1:] > 0).float() + kd = all_tex[..., :-6] + ks = all_tex[..., -6:-3] + perturbed_nrm = util.safe_normalize(all_tex[..., -3:]) + + # antialiasing + from sklearn.neighbors import NearestNeighbors + from scipy.ndimage import binary_dilation, binary_erosion + + mask_np = mask.cpu().numpy() > 0 + + inpaint_region = binary_dilation(mask_np, iterations=3) + inpaint_region[mask_np] = 0 + + search_region = mask_np.copy() + not_search_region = binary_erosion(search_region, iterations=2) + search_region[not_search_region] = 0 + + search_coords = np.stack(np.nonzero(search_region), axis=-1) + inpaint_coords = np.stack(np.nonzero(inpaint_region), axis=-1) + + knn = NearestNeighbors(n_neighbors=1, algorithm='kd_tree').fit(search_coords) + _, indices = knn.kneighbors(inpaint_coords) + + inpaint_coords = torch.from_numpy(inpaint_coords).long().to(kd.device) + target_coords = torch.from_numpy(search_coords[indices[:, 0]]).long().to(kd.device) + + kd[tuple(inpaint_coords.T)] = kd[tuple(target_coords.T)] + ks[tuple(inpaint_coords.T)] = ks[tuple(target_coords.T)] + perturbed_nrm[tuple(inpaint_coords.T)] = perturbed_nrm[tuple(target_coords.T)] + + return mask, kd, ks, perturbed_nrm diff --git a/render/renderutils/__init__.py b/render/renderutils/__init__.py new file mode 100644 index 0000000..f29739f --- /dev/null +++ b/render/renderutils/__init__.py @@ -0,0 +1,11 @@ +# Copyright (c) 2020-2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# +# NVIDIA CORPORATION, its affiliates and licensors retain all intellectual +# property and proprietary rights in and to this material, related +# documentation and any modifications thereto. Any use, reproduction, +# disclosure or distribution of this material and related documentation +# without an express license agreement from NVIDIA CORPORATION or +# its affiliates is strictly prohibited. + +from .ops import xfm_points, xfm_vectors, image_loss, diffuse_cubemap, specular_cubemap, prepare_shading_normal, lambert, frostbite_diffuse, pbr_specular, pbr_bsdf, _fresnel_shlick, _ndf_ggx, _lambda_ggx, _masking_smith +__all__ = ["xfm_vectors", "xfm_points", "image_loss", "diffuse_cubemap","specular_cubemap", "prepare_shading_normal", "lambert", "frostbite_diffuse", "pbr_specular", "pbr_bsdf", "_fresnel_shlick", "_ndf_ggx", "_lambda_ggx", "_masking_smith", ] diff --git a/render/renderutils/bsdf.py b/render/renderutils/bsdf.py new file mode 100644 index 0000000..38457ed --- /dev/null +++ b/render/renderutils/bsdf.py @@ -0,0 +1,151 @@ +# Copyright (c) 2020-2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# +# NVIDIA CORPORATION, its affiliates and licensors retain all intellectual +# property and proprietary rights in and to this material, related +# documentation and any modifications thereto. Any use, reproduction, +# disclosure or distribution of this material and related documentation +# without an express license agreement from NVIDIA CORPORATION or +# its affiliates is strictly prohibited. + +import math +import torch + +NORMAL_THRESHOLD = 0.1 + +################################################################################ +# Vector utility functions +################################################################################ + +def _dot(x, y): + return torch.sum(x*y, -1, keepdim=True) + +def _reflect(x, n): + return 2*_dot(x, n)*n - x + +def _safe_normalize(x): + return torch.nn.functional.normalize(x, dim = -1) + +def _bend_normal(view_vec, smooth_nrm, geom_nrm, two_sided_shading): + # Swap normal direction for backfacing surfaces + if two_sided_shading: + smooth_nrm = torch.where(_dot(geom_nrm, view_vec) > 0, smooth_nrm, -smooth_nrm) + geom_nrm = torch.where(_dot(geom_nrm, view_vec) > 0, geom_nrm, -geom_nrm) + + t = torch.clamp(_dot(view_vec, smooth_nrm) / NORMAL_THRESHOLD, min=0, max=1) + return torch.lerp(geom_nrm, smooth_nrm, t) + + +def _perturb_normal(perturbed_nrm, smooth_nrm, smooth_tng, opengl): + smooth_bitang = _safe_normalize(torch.cross(smooth_tng, smooth_nrm)) + if opengl: + shading_nrm = smooth_tng * perturbed_nrm[..., 0:1] - smooth_bitang * perturbed_nrm[..., 1:2] + smooth_nrm * torch.clamp(perturbed_nrm[..., 2:3], min=0.0) + else: + shading_nrm = smooth_tng * perturbed_nrm[..., 0:1] + smooth_bitang * perturbed_nrm[..., 1:2] + smooth_nrm * torch.clamp(perturbed_nrm[..., 2:3], min=0.0) + return _safe_normalize(shading_nrm) + +def bsdf_prepare_shading_normal(pos, view_pos, perturbed_nrm, smooth_nrm, smooth_tng, geom_nrm, two_sided_shading, opengl): + smooth_nrm = _safe_normalize(smooth_nrm) + smooth_tng = _safe_normalize(smooth_tng) + view_vec = _safe_normalize(view_pos - pos) + shading_nrm = _perturb_normal(perturbed_nrm, smooth_nrm, smooth_tng, opengl) + return _bend_normal(view_vec, shading_nrm, geom_nrm, two_sided_shading) + +################################################################################ +# Simple lambertian diffuse BSDF +################################################################################ + +def bsdf_lambert(nrm, wi): + return torch.clamp(_dot(nrm, wi), min=0.0) / math.pi + +################################################################################ +# Frostbite diffuse +################################################################################ + +def bsdf_frostbite(nrm, wi, wo, linearRoughness): + wiDotN = _dot(wi, nrm) + woDotN = _dot(wo, nrm) + + h = _safe_normalize(wo + wi) + wiDotH = _dot(wi, h) + + energyBias = 0.5 * linearRoughness + energyFactor = 1.0 - (0.51 / 1.51) * linearRoughness + f90 = energyBias + 2.0 * wiDotH * wiDotH * linearRoughness + f0 = 1.0 + + wiScatter = bsdf_fresnel_shlick(f0, f90, wiDotN) + woScatter = bsdf_fresnel_shlick(f0, f90, woDotN) + res = wiScatter * woScatter * energyFactor + return torch.where((wiDotN > 0.0) & (woDotN > 0.0), res, torch.zeros_like(res)) + +################################################################################ +# Phong specular, loosely based on mitsuba implementation +################################################################################ + +def bsdf_phong(nrm, wo, wi, N): + dp_r = torch.clamp(_dot(_reflect(wo, nrm), wi), min=0.0, max=1.0) + dp_l = torch.clamp(_dot(nrm, wi), min=0.0, max=1.0) + return (dp_r ** N) * dp_l * (N + 2) / (2 * math.pi) + +################################################################################ +# PBR's implementation of GGX specular +################################################################################ + +specular_epsilon = 1e-4 + +def bsdf_fresnel_shlick(f0, f90, cosTheta): + _cosTheta = torch.clamp(cosTheta, min=specular_epsilon, max=1.0 - specular_epsilon) + return f0 + (f90 - f0) * (1.0 - _cosTheta) ** 5.0 + +def bsdf_ndf_ggx(alphaSqr, cosTheta): + _cosTheta = torch.clamp(cosTheta, min=specular_epsilon, max=1.0 - specular_epsilon) + d = (_cosTheta * alphaSqr - _cosTheta) * _cosTheta + 1 + return alphaSqr / (d * d * math.pi) + +def bsdf_lambda_ggx(alphaSqr, cosTheta): + _cosTheta = torch.clamp(cosTheta, min=specular_epsilon, max=1.0 - specular_epsilon) + cosThetaSqr = _cosTheta * _cosTheta + tanThetaSqr = (1.0 - cosThetaSqr) / cosThetaSqr + res = 0.5 * (torch.sqrt(1 + alphaSqr * tanThetaSqr) - 1.0) + return res + +def bsdf_masking_smith_ggx_correlated(alphaSqr, cosThetaI, cosThetaO): + lambdaI = bsdf_lambda_ggx(alphaSqr, cosThetaI) + lambdaO = bsdf_lambda_ggx(alphaSqr, cosThetaO) + return 1 / (1 + lambdaI + lambdaO) + +def bsdf_pbr_specular(col, nrm, wo, wi, alpha, min_roughness=0.08): + _alpha = torch.clamp(alpha, min=min_roughness*min_roughness, max=1.0) + alphaSqr = _alpha * _alpha + + h = _safe_normalize(wo + wi) + woDotN = _dot(wo, nrm) + wiDotN = _dot(wi, nrm) + woDotH = _dot(wo, h) + nDotH = _dot(nrm, h) + + D = bsdf_ndf_ggx(alphaSqr, nDotH) + G = bsdf_masking_smith_ggx_correlated(alphaSqr, woDotN, wiDotN) + F = bsdf_fresnel_shlick(col, 1, woDotH) + + w = F * D * G * 0.25 / torch.clamp(woDotN, min=specular_epsilon) + + frontfacing = (woDotN > specular_epsilon) & (wiDotN > specular_epsilon) + return torch.where(frontfacing, w, torch.zeros_like(w)) + +def bsdf_pbr(kd, arm, pos, nrm, view_pos, light_pos, min_roughness, BSDF): + wo = _safe_normalize(view_pos - pos) + wi = _safe_normalize(light_pos - pos) + + spec_str = arm[..., 0:1] # x component + roughness = arm[..., 1:2] # y component + metallic = arm[..., 2:3] # z component + ks = (0.04 * (1.0 - metallic) + kd * metallic) * (1 - spec_str) + kd = kd * (1.0 - metallic) + + if BSDF == 0: + diffuse = kd * bsdf_lambert(nrm, wi) + else: + diffuse = kd * bsdf_frostbite(nrm, wi, wo, roughness) + specular = bsdf_pbr_specular(ks, nrm, wo, wi, roughness*roughness, min_roughness=min_roughness) + return diffuse + specular diff --git a/render/renderutils/c_src/bsdf.cu b/render/renderutils/c_src/bsdf.cu new file mode 100644 index 0000000..c167214 --- /dev/null +++ b/render/renderutils/c_src/bsdf.cu @@ -0,0 +1,710 @@ +/* + * Copyright (c) 2020-2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * + * NVIDIA CORPORATION, its affiliates and licensors retain all intellectual + * property and proprietary rights in and to this material, related + * documentation and any modifications thereto. Any use, reproduction, + * disclosure or distribution of this material and related documentation + * without an express license agreement from NVIDIA CORPORATION or + * its affiliates is strictly prohibited. + */ + +#include "common.h" +#include "bsdf.h" + +#define SPECULAR_EPSILON 1e-4f + +//------------------------------------------------------------------------ +// Lambert functions + +__device__ inline float fwdLambert(const vec3f nrm, const vec3f wi) +{ + return max(dot(nrm, wi) / M_PI, 0.0f); +} + +__device__ inline void bwdLambert(const vec3f nrm, const vec3f wi, vec3f& d_nrm, vec3f& d_wi, const float d_out) +{ + if (dot(nrm, wi) > 0.0f) + bwdDot(nrm, wi, d_nrm, d_wi, d_out / M_PI); +} + +//------------------------------------------------------------------------ +// Fresnel Schlick + +__device__ inline float fwdFresnelSchlick(const float f0, const float f90, const float cosTheta) +{ + float _cosTheta = clamp(cosTheta, SPECULAR_EPSILON, 1.0f - SPECULAR_EPSILON); + float scale = powf(1.0f - _cosTheta, 5.0f); + return f0 * (1.0f - scale) + f90 * scale; +} + +__device__ inline void bwdFresnelSchlick(const float f0, const float f90, const float cosTheta, float& d_f0, float& d_f90, float& d_cosTheta, const float d_out) +{ + float _cosTheta = clamp(cosTheta, SPECULAR_EPSILON, 1.0f - SPECULAR_EPSILON); + float scale = pow(max(1.0f - _cosTheta, 0.0f), 5.0f); + d_f0 += d_out * (1.0 - scale); + d_f90 += d_out * scale; + if (cosTheta >= SPECULAR_EPSILON && cosTheta < 1.0f - SPECULAR_EPSILON) + { + d_cosTheta += d_out * (f90 - f0) * -5.0f * powf(1.0f - cosTheta, 4.0f); + } +} + +__device__ inline vec3f fwdFresnelSchlick(const vec3f f0, const vec3f f90, const float cosTheta) +{ + float _cosTheta = clamp(cosTheta, SPECULAR_EPSILON, 1.0f - SPECULAR_EPSILON); + float scale = powf(1.0f - _cosTheta, 5.0f); + return f0 * (1.0f - scale) + f90 * scale; +} + +__device__ inline void bwdFresnelSchlick(const vec3f f0, const vec3f f90, const float cosTheta, vec3f& d_f0, vec3f& d_f90, float& d_cosTheta, const vec3f d_out) +{ + float _cosTheta = clamp(cosTheta, SPECULAR_EPSILON, 1.0f - SPECULAR_EPSILON); + float scale = pow(max(1.0f - _cosTheta, 0.0f), 5.0f); + d_f0 += d_out * (1.0 - scale); + d_f90 += d_out * scale; + if (cosTheta >= SPECULAR_EPSILON && cosTheta < 1.0f - SPECULAR_EPSILON) + { + d_cosTheta += sum(d_out * (f90 - f0) * -5.0f * powf(1.0f - cosTheta, 4.0f)); + } +} + +//------------------------------------------------------------------------ +// Frostbite diffuse + +__device__ inline float fwdFrostbiteDiffuse(const vec3f nrm, const vec3f wi, const vec3f wo, float linearRoughness) +{ + float wiDotN = dot(wi, nrm); + float woDotN = dot(wo, nrm); + if (wiDotN > 0.0f && woDotN > 0.0f) + { + vec3f h = safeNormalize(wo + wi); + float wiDotH = dot(wi, h); + + float energyBias = 0.5f * linearRoughness; + float energyFactor = 1.0f - (0.51f / 1.51f) * linearRoughness; + float f90 = energyBias + 2.f * wiDotH * wiDotH * linearRoughness; + float f0 = 1.f; + + float wiScatter = fwdFresnelSchlick(f0, f90, wiDotN); + float woScatter = fwdFresnelSchlick(f0, f90, woDotN); + + return wiScatter * woScatter * energyFactor; + } + else return 0.0f; +} + +__device__ inline void bwdFrostbiteDiffuse(const vec3f nrm, const vec3f wi, const vec3f wo, float linearRoughness, vec3f& d_nrm, vec3f& d_wi, vec3f& d_wo, float &d_linearRoughness, const float d_out) +{ + float wiDotN = dot(wi, nrm); + float woDotN = dot(wo, nrm); + + if (wiDotN > 0.0f && woDotN > 0.0f) + { + vec3f h = safeNormalize(wo + wi); + float wiDotH = dot(wi, h); + + float energyBias = 0.5f * linearRoughness; + float energyFactor = 1.0f - (0.51f / 1.51f) * linearRoughness; + float f90 = energyBias + 2.f * wiDotH * wiDotH * linearRoughness; + float f0 = 1.f; + + float wiScatter = fwdFresnelSchlick(f0, f90, wiDotN); + float woScatter = fwdFresnelSchlick(f0, f90, woDotN); + + // -------------- BWD -------------- + // Backprop: return wiScatter * woScatter * energyFactor; + float d_wiScatter = d_out * woScatter * energyFactor; + float d_woScatter = d_out * wiScatter * energyFactor; + float d_energyFactor = d_out * wiScatter * woScatter; + + // Backprop: float woScatter = fwdFresnelSchlick(f0, f90, woDotN); + float d_woDotN = 0.0f, d_f0 = 0.0, d_f90 = 0.0f; + bwdFresnelSchlick(f0, f90, woDotN, d_f0, d_f90, d_woDotN, d_woScatter); + + // Backprop: float wiScatter = fwdFresnelSchlick(fd0, fd90, wiDotN); + float d_wiDotN = 0.0f; + bwdFresnelSchlick(f0, f90, wiDotN, d_f0, d_f90, d_wiDotN, d_wiScatter); + + // Backprop: float f90 = energyBias + 2.f * wiDotH * wiDotH * linearRoughness; + float d_energyBias = d_f90; + float d_wiDotH = d_f90 * 4 * wiDotH * linearRoughness; + d_linearRoughness += d_f90 * 2 * wiDotH * wiDotH; + + // Backprop: float energyFactor = 1.0f - (0.51f / 1.51f) * linearRoughness; + d_linearRoughness -= (0.51f / 1.51f) * d_energyFactor; + + // Backprop: float energyBias = 0.5f * linearRoughness; + d_linearRoughness += 0.5 * d_energyBias; + + // Backprop: float wiDotH = dot(wi, h); + vec3f d_h(0); + bwdDot(wi, h, d_wi, d_h, d_wiDotH); + + // Backprop: vec3f h = safeNormalize(wo + wi); + vec3f d_wo_wi(0); + bwdSafeNormalize(wo + wi, d_wo_wi, d_h); + d_wi += d_wo_wi; d_wo += d_wo_wi; + + bwdDot(wo, nrm, d_wo, d_nrm, d_woDotN); + bwdDot(wi, nrm, d_wi, d_nrm, d_wiDotN); + } +} + +//------------------------------------------------------------------------ +// Ndf GGX + +__device__ inline float fwdNdfGGX(const float alphaSqr, const float cosTheta) +{ + float _cosTheta = clamp(cosTheta, SPECULAR_EPSILON, 1.0f - SPECULAR_EPSILON); + float d = (_cosTheta * alphaSqr - _cosTheta) * _cosTheta + 1.0f; + return alphaSqr / (d * d * M_PI); +} + +__device__ inline void bwdNdfGGX(const float alphaSqr, const float cosTheta, float& d_alphaSqr, float& d_cosTheta, const float d_out) +{ + // Torch only back propagates if clamp doesn't trigger + float _cosTheta = clamp(cosTheta, SPECULAR_EPSILON, 1.0f - SPECULAR_EPSILON); + float cosThetaSqr = _cosTheta * _cosTheta; + d_alphaSqr += d_out * (1.0f - (alphaSqr + 1.0f) * cosThetaSqr) / (M_PI * powf((alphaSqr - 1.0) * cosThetaSqr + 1.0f, 3.0f)); + if (cosTheta > SPECULAR_EPSILON && cosTheta < 1.0f - SPECULAR_EPSILON) + { + d_cosTheta += d_out * -(4.0f * (alphaSqr - 1.0f) * alphaSqr * cosTheta) / (M_PI * powf((alphaSqr - 1.0) * cosThetaSqr + 1.0f, 3.0f)); + } +} + +//------------------------------------------------------------------------ +// Lambda GGX + +__device__ inline float fwdLambdaGGX(const float alphaSqr, const float cosTheta) +{ + float _cosTheta = clamp(cosTheta, SPECULAR_EPSILON, 1.0f - SPECULAR_EPSILON); + float cosThetaSqr = _cosTheta * _cosTheta; + float tanThetaSqr = (1.0 - cosThetaSqr) / cosThetaSqr; + float res = 0.5f * (sqrtf(1.0f + alphaSqr * tanThetaSqr) - 1.0f); + return res; +} + +__device__ inline void bwdLambdaGGX(const float alphaSqr, const float cosTheta, float& d_alphaSqr, float& d_cosTheta, const float d_out) +{ + float _cosTheta = clamp(cosTheta, SPECULAR_EPSILON, 1.0f - SPECULAR_EPSILON); + float cosThetaSqr = _cosTheta * _cosTheta; + float tanThetaSqr = (1.0 - cosThetaSqr) / cosThetaSqr; + float res = 0.5f * (sqrtf(1.0f + alphaSqr * tanThetaSqr) - 1.0f); + + d_alphaSqr += d_out * (0.25 * tanThetaSqr) / sqrtf(alphaSqr * tanThetaSqr + 1.0f); + if (cosTheta > SPECULAR_EPSILON && cosTheta < 1.0f - SPECULAR_EPSILON) + d_cosTheta += d_out * -(0.5 * alphaSqr) / (powf(_cosTheta, 3.0f) * sqrtf(alphaSqr / cosThetaSqr - alphaSqr + 1.0f)); +} + +//------------------------------------------------------------------------ +// Masking GGX + +__device__ inline float fwdMaskingSmithGGXCorrelated(const float alphaSqr, const float cosThetaI, const float cosThetaO) +{ + float lambdaI = fwdLambdaGGX(alphaSqr, cosThetaI); + float lambdaO = fwdLambdaGGX(alphaSqr, cosThetaO); + return 1.0f / (1.0f + lambdaI + lambdaO); +} + +__device__ inline void bwdMaskingSmithGGXCorrelated(const float alphaSqr, const float cosThetaI, const float cosThetaO, float& d_alphaSqr, float& d_cosThetaI, float& d_cosThetaO, const float d_out) +{ + // FWD eval + float lambdaI = fwdLambdaGGX(alphaSqr, cosThetaI); + float lambdaO = fwdLambdaGGX(alphaSqr, cosThetaO); + + // BWD eval + float d_lambdaIO = -d_out / powf(1.0f + lambdaI + lambdaO, 2.0f); + bwdLambdaGGX(alphaSqr, cosThetaI, d_alphaSqr, d_cosThetaI, d_lambdaIO); + bwdLambdaGGX(alphaSqr, cosThetaO, d_alphaSqr, d_cosThetaO, d_lambdaIO); +} + +//------------------------------------------------------------------------ +// GGX specular + +__device__ vec3f fwdPbrSpecular(const vec3f col, const vec3f nrm, const vec3f wo, const vec3f wi, const float alpha, const float min_roughness) +{ + float _alpha = clamp(alpha, min_roughness * min_roughness, 1.0f); + float alphaSqr = _alpha * _alpha; + + vec3f h = safeNormalize(wo + wi); + float woDotN = dot(wo, nrm); + float wiDotN = dot(wi, nrm); + float woDotH = dot(wo, h); + float nDotH = dot(nrm, h); + + float D = fwdNdfGGX(alphaSqr, nDotH); + float G = fwdMaskingSmithGGXCorrelated(alphaSqr, woDotN, wiDotN); + vec3f F = fwdFresnelSchlick(col, 1.0f, woDotH); + vec3f w = F * D * G * 0.25 / woDotN; + + bool frontfacing = (woDotN > SPECULAR_EPSILON) & (wiDotN > SPECULAR_EPSILON); + return frontfacing ? w : 0.0f; +} + +__device__ void bwdPbrSpecular( + const vec3f col, const vec3f nrm, const vec3f wo, const vec3f wi, const float alpha, const float min_roughness, + vec3f& d_col, vec3f& d_nrm, vec3f& d_wo, vec3f& d_wi, float& d_alpha, const vec3f d_out) +{ + /////////////////////////////////////////////////////////////////////// + // FWD eval + + float _alpha = clamp(alpha, min_roughness * min_roughness, 1.0f); + float alphaSqr = _alpha * _alpha; + + vec3f h = safeNormalize(wo + wi); + float woDotN = dot(wo, nrm); + float wiDotN = dot(wi, nrm); + float woDotH = dot(wo, h); + float nDotH = dot(nrm, h); + + float D = fwdNdfGGX(alphaSqr, nDotH); + float G = fwdMaskingSmithGGXCorrelated(alphaSqr, woDotN, wiDotN); + vec3f F = fwdFresnelSchlick(col, 1.0f, woDotH); + vec3f w = F * D * G * 0.25 / woDotN; + bool frontfacing = (woDotN > SPECULAR_EPSILON) & (wiDotN > SPECULAR_EPSILON); + + if (frontfacing) + { + /////////////////////////////////////////////////////////////////////// + // BWD eval + + vec3f d_F = d_out * D * G * 0.25f / woDotN; + float d_D = sum(d_out * F * G * 0.25f / woDotN); + float d_G = sum(d_out * F * D * 0.25f / woDotN); + + float d_woDotN = -sum(d_out * F * D * G * 0.25f / (woDotN * woDotN)); + + vec3f d_f90(0); + float d_woDotH(0), d_wiDotN(0), d_nDotH(0), d_alphaSqr(0); + bwdFresnelSchlick(col, 1.0f, woDotH, d_col, d_f90, d_woDotH, d_F); + bwdMaskingSmithGGXCorrelated(alphaSqr, woDotN, wiDotN, d_alphaSqr, d_woDotN, d_wiDotN, d_G); + bwdNdfGGX(alphaSqr, nDotH, d_alphaSqr, d_nDotH, d_D); + + vec3f d_h(0); + bwdDot(nrm, h, d_nrm, d_h, d_nDotH); + bwdDot(wo, h, d_wo, d_h, d_woDotH); + bwdDot(wi, nrm, d_wi, d_nrm, d_wiDotN); + bwdDot(wo, nrm, d_wo, d_nrm, d_woDotN); + + vec3f d_h_unnorm(0); + bwdSafeNormalize(wo + wi, d_h_unnorm, d_h); + d_wo += d_h_unnorm; + d_wi += d_h_unnorm; + + if (alpha > min_roughness * min_roughness) + d_alpha += d_alphaSqr * 2 * alpha; + } +} + +//------------------------------------------------------------------------ +// Full PBR BSDF + +__device__ vec3f fwdPbrBSDF(const vec3f kd, const vec3f arm, const vec3f pos, const vec3f nrm, const vec3f view_pos, const vec3f light_pos, const float min_roughness, int BSDF) +{ + vec3f wo = safeNormalize(view_pos - pos); + vec3f wi = safeNormalize(light_pos - pos); + + float alpha = arm.y * arm.y; + vec3f spec_col = (0.04f * (1.0f - arm.z) + kd * arm.z) * (1.0 - arm.x); + vec3f diff_col = kd * (1.0f - arm.z); + + float diff = 0.0f; + if (BSDF == 0) + diff = fwdLambert(nrm, wi); + else + diff = fwdFrostbiteDiffuse(nrm, wi, wo, arm.y); + vec3f diffuse = diff_col * diff; + vec3f specular = fwdPbrSpecular(spec_col, nrm, wo, wi, alpha, min_roughness); + + return diffuse + specular; +} + +__device__ void bwdPbrBSDF( + const vec3f kd, const vec3f arm, const vec3f pos, const vec3f nrm, const vec3f view_pos, const vec3f light_pos, const float min_roughness, int BSDF, + vec3f& d_kd, vec3f& d_arm, vec3f& d_pos, vec3f& d_nrm, vec3f& d_view_pos, vec3f& d_light_pos, const vec3f d_out) +{ + //////////////////////////////////////////////////////////////////////// + // FWD + vec3f _wi = light_pos - pos; + vec3f _wo = view_pos - pos; + vec3f wi = safeNormalize(_wi); + vec3f wo = safeNormalize(_wo); + + float alpha = arm.y * arm.y; + vec3f spec_col = (0.04f * (1.0f - arm.z) + kd * arm.z) * (1.0 - arm.x); + vec3f diff_col = kd * (1.0f - arm.z); + float diff = 0.0f; + if (BSDF == 0) + diff = fwdLambert(nrm, wi); + else + diff = fwdFrostbiteDiffuse(nrm, wi, wo, arm.y); + + //////////////////////////////////////////////////////////////////////// + // BWD + + float d_alpha(0); + vec3f d_spec_col(0), d_wi(0), d_wo(0); + bwdPbrSpecular(spec_col, nrm, wo, wi, alpha, min_roughness, d_spec_col, d_nrm, d_wo, d_wi, d_alpha, d_out); + + float d_diff = sum(diff_col * d_out); + if (BSDF == 0) + bwdLambert(nrm, wi, d_nrm, d_wi, d_diff); + else + bwdFrostbiteDiffuse(nrm, wi, wo, arm.y, d_nrm, d_wi, d_wo, d_arm.y, d_diff); + + // Backprop: diff_col = kd * (1.0f - arm.z) + vec3f d_diff_col = d_out * diff; + d_kd += d_diff_col * (1.0f - arm.z); + d_arm.z -= sum(d_diff_col * kd); + + // Backprop: spec_col = (0.04f * (1.0f - arm.z) + kd * arm.z) * (1.0 - arm.x) + d_kd -= d_spec_col * (arm.x - 1.0f) * arm.z; + d_arm.x += sum(d_spec_col * (arm.z * (0.04f - kd) - 0.04f)); + d_arm.z -= sum(d_spec_col * (kd - 0.04f) * (arm.x - 1.0f)); + + // Backprop: alpha = arm.y * arm.y + d_arm.y += d_alpha * 2 * arm.y; + + // Backprop: vec3f wi = safeNormalize(light_pos - pos); + vec3f d__wi(0); + bwdSafeNormalize(_wi, d__wi, d_wi); + d_light_pos += d__wi; + d_pos -= d__wi; + + // Backprop: vec3f wo = safeNormalize(view_pos - pos); + vec3f d__wo(0); + bwdSafeNormalize(_wo, d__wo, d_wo); + d_view_pos += d__wo; + d_pos -= d__wo; +} + +//------------------------------------------------------------------------ +// Kernels + +__global__ void LambertFwdKernel(LambertKernelParams p) +{ + // Calculate pixel position. + unsigned int px = blockIdx.x * blockDim.x + threadIdx.x; + unsigned int py = blockIdx.y * blockDim.y + threadIdx.y; + unsigned int pz = blockIdx.z; + if (px >= p.gridSize.x || py >= p.gridSize.y || pz >= p.gridSize.z) + return; + + vec3f nrm = p.nrm.fetch3(px, py, pz); + vec3f wi = p.wi.fetch3(px, py, pz); + + float res = fwdLambert(nrm, wi); + + p.out.store(px, py, pz, res); +} + +__global__ void LambertBwdKernel(LambertKernelParams p) +{ + // Calculate pixel position. + unsigned int px = blockIdx.x * blockDim.x + threadIdx.x; + unsigned int py = blockIdx.y * blockDim.y + threadIdx.y; + unsigned int pz = blockIdx.z; + if (px >= p.gridSize.x || py >= p.gridSize.y || pz >= p.gridSize.z) + return; + + vec3f nrm = p.nrm.fetch3(px, py, pz); + vec3f wi = p.wi.fetch3(px, py, pz); + float d_out = p.out.fetch1(px, py, pz); + + vec3f d_nrm(0), d_wi(0); + bwdLambert(nrm, wi, d_nrm, d_wi, d_out); + + p.nrm.store_grad(px, py, pz, d_nrm); + p.wi.store_grad(px, py, pz, d_wi); +} + +__global__ void FrostbiteDiffuseFwdKernel(FrostbiteDiffuseKernelParams p) +{ + // Calculate pixel position. + unsigned int px = blockIdx.x * blockDim.x + threadIdx.x; + unsigned int py = blockIdx.y * blockDim.y + threadIdx.y; + unsigned int pz = blockIdx.z; + if (px >= p.gridSize.x || py >= p.gridSize.y || pz >= p.gridSize.z) + return; + + vec3f nrm = p.nrm.fetch3(px, py, pz); + vec3f wi = p.wi.fetch3(px, py, pz); + vec3f wo = p.wo.fetch3(px, py, pz); + float linearRoughness = p.linearRoughness.fetch1(px, py, pz); + + float res = fwdFrostbiteDiffuse(nrm, wi, wo, linearRoughness); + + p.out.store(px, py, pz, res); +} + +__global__ void FrostbiteDiffuseBwdKernel(FrostbiteDiffuseKernelParams p) +{ + // Calculate pixel position. + unsigned int px = blockIdx.x * blockDim.x + threadIdx.x; + unsigned int py = blockIdx.y * blockDim.y + threadIdx.y; + unsigned int pz = blockIdx.z; + if (px >= p.gridSize.x || py >= p.gridSize.y || pz >= p.gridSize.z) + return; + + vec3f nrm = p.nrm.fetch3(px, py, pz); + vec3f wi = p.wi.fetch3(px, py, pz); + vec3f wo = p.wo.fetch3(px, py, pz); + float linearRoughness = p.linearRoughness.fetch1(px, py, pz); + float d_out = p.out.fetch1(px, py, pz); + + float d_linearRoughness = 0.0f; + vec3f d_nrm(0), d_wi(0), d_wo(0); + bwdFrostbiteDiffuse(nrm, wi, wo, linearRoughness, d_nrm, d_wi, d_wo, d_linearRoughness, d_out); + + p.nrm.store_grad(px, py, pz, d_nrm); + p.wi.store_grad(px, py, pz, d_wi); + p.wo.store_grad(px, py, pz, d_wo); + p.linearRoughness.store_grad(px, py, pz, d_linearRoughness); +} + +__global__ void FresnelShlickFwdKernel(FresnelShlickKernelParams p) +{ + // Calculate pixel position. + unsigned int px = blockIdx.x * blockDim.x + threadIdx.x; + unsigned int py = blockIdx.y * blockDim.y + threadIdx.y; + unsigned int pz = blockIdx.z; + if (px >= p.gridSize.x || py >= p.gridSize.y || pz >= p.gridSize.z) + return; + + vec3f f0 = p.f0.fetch3(px, py, pz); + vec3f f90 = p.f90.fetch3(px, py, pz); + float cosTheta = p.cosTheta.fetch1(px, py, pz); + + vec3f res = fwdFresnelSchlick(f0, f90, cosTheta); + p.out.store(px, py, pz, res); +} + +__global__ void FresnelShlickBwdKernel(FresnelShlickKernelParams p) +{ + // Calculate pixel position. + unsigned int px = blockIdx.x * blockDim.x + threadIdx.x; + unsigned int py = blockIdx.y * blockDim.y + threadIdx.y; + unsigned int pz = blockIdx.z; + if (px >= p.gridSize.x || py >= p.gridSize.y || pz >= p.gridSize.z) + return; + + vec3f f0 = p.f0.fetch3(px, py, pz); + vec3f f90 = p.f90.fetch3(px, py, pz); + float cosTheta = p.cosTheta.fetch1(px, py, pz); + vec3f d_out = p.out.fetch3(px, py, pz); + + vec3f d_f0(0), d_f90(0); + float d_cosTheta(0); + bwdFresnelSchlick(f0, f90, cosTheta, d_f0, d_f90, d_cosTheta, d_out); + + p.f0.store_grad(px, py, pz, d_f0); + p.f90.store_grad(px, py, pz, d_f90); + p.cosTheta.store_grad(px, py, pz, d_cosTheta); +} + +__global__ void ndfGGXFwdKernel(NdfGGXParams p) +{ + // Calculate pixel position. + unsigned int px = blockIdx.x * blockDim.x + threadIdx.x; + unsigned int py = blockIdx.y * blockDim.y + threadIdx.y; + unsigned int pz = blockIdx.z; + if (px >= p.gridSize.x || py >= p.gridSize.y || pz >= p.gridSize.z) + return; + + float alphaSqr = p.alphaSqr.fetch1(px, py, pz); + float cosTheta = p.cosTheta.fetch1(px, py, pz); + float res = fwdNdfGGX(alphaSqr, cosTheta); + + p.out.store(px, py, pz, res); +} + +__global__ void ndfGGXBwdKernel(NdfGGXParams p) +{ + // Calculate pixel position. + unsigned int px = blockIdx.x * blockDim.x + threadIdx.x; + unsigned int py = blockIdx.y * blockDim.y + threadIdx.y; + unsigned int pz = blockIdx.z; + if (px >= p.gridSize.x || py >= p.gridSize.y || pz >= p.gridSize.z) + return; + + float alphaSqr = p.alphaSqr.fetch1(px, py, pz); + float cosTheta = p.cosTheta.fetch1(px, py, pz); + float d_out = p.out.fetch1(px, py, pz); + + float d_alphaSqr(0), d_cosTheta(0); + bwdNdfGGX(alphaSqr, cosTheta, d_alphaSqr, d_cosTheta, d_out); + + p.alphaSqr.store_grad(px, py, pz, d_alphaSqr); + p.cosTheta.store_grad(px, py, pz, d_cosTheta); +} + +__global__ void lambdaGGXFwdKernel(NdfGGXParams p) +{ + // Calculate pixel position. + unsigned int px = blockIdx.x * blockDim.x + threadIdx.x; + unsigned int py = blockIdx.y * blockDim.y + threadIdx.y; + unsigned int pz = blockIdx.z; + if (px >= p.gridSize.x || py >= p.gridSize.y || pz >= p.gridSize.z) + return; + + float alphaSqr = p.alphaSqr.fetch1(px, py, pz); + float cosTheta = p.cosTheta.fetch1(px, py, pz); + float res = fwdLambdaGGX(alphaSqr, cosTheta); + + p.out.store(px, py, pz, res); +} + +__global__ void lambdaGGXBwdKernel(NdfGGXParams p) +{ + // Calculate pixel position. + unsigned int px = blockIdx.x * blockDim.x + threadIdx.x; + unsigned int py = blockIdx.y * blockDim.y + threadIdx.y; + unsigned int pz = blockIdx.z; + if (px >= p.gridSize.x || py >= p.gridSize.y || pz >= p.gridSize.z) + return; + + float alphaSqr = p.alphaSqr.fetch1(px, py, pz); + float cosTheta = p.cosTheta.fetch1(px, py, pz); + float d_out = p.out.fetch1(px, py, pz); + + float d_alphaSqr(0), d_cosTheta(0); + bwdLambdaGGX(alphaSqr, cosTheta, d_alphaSqr, d_cosTheta, d_out); + + p.alphaSqr.store_grad(px, py, pz, d_alphaSqr); + p.cosTheta.store_grad(px, py, pz, d_cosTheta); +} + +__global__ void maskingSmithFwdKernel(MaskingSmithParams p) +{ + // Calculate pixel position. + unsigned int px = blockIdx.x * blockDim.x + threadIdx.x; + unsigned int py = blockIdx.y * blockDim.y + threadIdx.y; + unsigned int pz = blockIdx.z; + if (px >= p.gridSize.x || py >= p.gridSize.y || pz >= p.gridSize.z) + return; + + float alphaSqr = p.alphaSqr.fetch1(px, py, pz); + float cosThetaI = p.cosThetaI.fetch1(px, py, pz); + float cosThetaO = p.cosThetaO.fetch1(px, py, pz); + float res = fwdMaskingSmithGGXCorrelated(alphaSqr, cosThetaI, cosThetaO); + + p.out.store(px, py, pz, res); +} + +__global__ void maskingSmithBwdKernel(MaskingSmithParams p) +{ + // Calculate pixel position. + unsigned int px = blockIdx.x * blockDim.x + threadIdx.x; + unsigned int py = blockIdx.y * blockDim.y + threadIdx.y; + unsigned int pz = blockIdx.z; + if (px >= p.gridSize.x || py >= p.gridSize.y || pz >= p.gridSize.z) + return; + + float alphaSqr = p.alphaSqr.fetch1(px, py, pz); + float cosThetaI = p.cosThetaI.fetch1(px, py, pz); + float cosThetaO = p.cosThetaO.fetch1(px, py, pz); + float d_out = p.out.fetch1(px, py, pz); + + float d_alphaSqr(0), d_cosThetaI(0), d_cosThetaO(0); + bwdMaskingSmithGGXCorrelated(alphaSqr, cosThetaI, cosThetaO, d_alphaSqr, d_cosThetaI, d_cosThetaO, d_out); + + p.alphaSqr.store_grad(px, py, pz, d_alphaSqr); + p.cosThetaI.store_grad(px, py, pz, d_cosThetaI); + p.cosThetaO.store_grad(px, py, pz, d_cosThetaO); +} + +__global__ void pbrSpecularFwdKernel(PbrSpecular p) +{ + // Calculate pixel position. + unsigned int px = blockIdx.x * blockDim.x + threadIdx.x; + unsigned int py = blockIdx.y * blockDim.y + threadIdx.y; + unsigned int pz = blockIdx.z; + if (px >= p.gridSize.x || py >= p.gridSize.y || pz >= p.gridSize.z) + return; + + vec3f col = p.col.fetch3(px, py, pz); + vec3f nrm = p.nrm.fetch3(px, py, pz); + vec3f wo = p.wo.fetch3(px, py, pz); + vec3f wi = p.wi.fetch3(px, py, pz); + float alpha = p.alpha.fetch1(px, py, pz); + + vec3f res = fwdPbrSpecular(col, nrm, wo, wi, alpha, p.min_roughness); + + p.out.store(px, py, pz, res); +} + +__global__ void pbrSpecularBwdKernel(PbrSpecular p) +{ + // Calculate pixel position. + unsigned int px = blockIdx.x * blockDim.x + threadIdx.x; + unsigned int py = blockIdx.y * blockDim.y + threadIdx.y; + unsigned int pz = blockIdx.z; + if (px >= p.gridSize.x || py >= p.gridSize.y || pz >= p.gridSize.z) + return; + + vec3f col = p.col.fetch3(px, py, pz); + vec3f nrm = p.nrm.fetch3(px, py, pz); + vec3f wo = p.wo.fetch3(px, py, pz); + vec3f wi = p.wi.fetch3(px, py, pz); + float alpha = p.alpha.fetch1(px, py, pz); + vec3f d_out = p.out.fetch3(px, py, pz); + + float d_alpha(0); + vec3f d_col(0), d_nrm(0), d_wo(0), d_wi(0); + bwdPbrSpecular(col, nrm, wo, wi, alpha, p.min_roughness, d_col, d_nrm, d_wo, d_wi, d_alpha, d_out); + + p.col.store_grad(px, py, pz, d_col); + p.nrm.store_grad(px, py, pz, d_nrm); + p.wo.store_grad(px, py, pz, d_wo); + p.wi.store_grad(px, py, pz, d_wi); + p.alpha.store_grad(px, py, pz, d_alpha); +} + +__global__ void pbrBSDFFwdKernel(PbrBSDF p) +{ + // Calculate pixel position. + unsigned int px = blockIdx.x * blockDim.x + threadIdx.x; + unsigned int py = blockIdx.y * blockDim.y + threadIdx.y; + unsigned int pz = blockIdx.z; + if (px >= p.gridSize.x || py >= p.gridSize.y || pz >= p.gridSize.z) + return; + + vec3f kd = p.kd.fetch3(px, py, pz); + vec3f arm = p.arm.fetch3(px, py, pz); + vec3f pos = p.pos.fetch3(px, py, pz); + vec3f nrm = p.nrm.fetch3(px, py, pz); + vec3f view_pos = p.view_pos.fetch3(px, py, pz); + vec3f light_pos = p.light_pos.fetch3(px, py, pz); + + vec3f res = fwdPbrBSDF(kd, arm, pos, nrm, view_pos, light_pos, p.min_roughness, p.BSDF); + + p.out.store(px, py, pz, res); +} +__global__ void pbrBSDFBwdKernel(PbrBSDF p) +{ + // Calculate pixel position. + unsigned int px = blockIdx.x * blockDim.x + threadIdx.x; + unsigned int py = blockIdx.y * blockDim.y + threadIdx.y; + unsigned int pz = blockIdx.z; + if (px >= p.gridSize.x || py >= p.gridSize.y || pz >= p.gridSize.z) + return; + + vec3f kd = p.kd.fetch3(px, py, pz); + vec3f arm = p.arm.fetch3(px, py, pz); + vec3f pos = p.pos.fetch3(px, py, pz); + vec3f nrm = p.nrm.fetch3(px, py, pz); + vec3f view_pos = p.view_pos.fetch3(px, py, pz); + vec3f light_pos = p.light_pos.fetch3(px, py, pz); + vec3f d_out = p.out.fetch3(px, py, pz); + + vec3f d_kd(0), d_arm(0), d_pos(0), d_nrm(0), d_view_pos(0), d_light_pos(0); + bwdPbrBSDF(kd, arm, pos, nrm, view_pos, light_pos, p.min_roughness, p.BSDF, d_kd, d_arm, d_pos, d_nrm, d_view_pos, d_light_pos, d_out); + + p.kd.store_grad(px, py, pz, d_kd); + p.arm.store_grad(px, py, pz, d_arm); + p.pos.store_grad(px, py, pz, d_pos); + p.nrm.store_grad(px, py, pz, d_nrm); + p.view_pos.store_grad(px, py, pz, d_view_pos); + p.light_pos.store_grad(px, py, pz, d_light_pos); +} diff --git a/render/renderutils/c_src/bsdf.h b/render/renderutils/c_src/bsdf.h new file mode 100644 index 0000000..59adbf0 --- /dev/null +++ b/render/renderutils/c_src/bsdf.h @@ -0,0 +1,84 @@ +/* + * Copyright (c) 2020-2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * + * NVIDIA CORPORATION, its affiliates and licensors retain all intellectual + * property and proprietary rights in and to this material, related + * documentation and any modifications thereto. Any use, reproduction, + * disclosure or distribution of this material and related documentation + * without an express license agreement from NVIDIA CORPORATION or + * its affiliates is strictly prohibited. + */ + +#pragma once + +#include "common.h" + +struct LambertKernelParams +{ + Tensor nrm; + Tensor wi; + Tensor out; + dim3 gridSize; +}; + +struct FrostbiteDiffuseKernelParams +{ + Tensor nrm; + Tensor wi; + Tensor wo; + Tensor linearRoughness; + Tensor out; + dim3 gridSize; +}; + +struct FresnelShlickKernelParams +{ + Tensor f0; + Tensor f90; + Tensor cosTheta; + Tensor out; + dim3 gridSize; +}; + +struct NdfGGXParams +{ + Tensor alphaSqr; + Tensor cosTheta; + Tensor out; + dim3 gridSize; +}; + +struct MaskingSmithParams +{ + Tensor alphaSqr; + Tensor cosThetaI; + Tensor cosThetaO; + Tensor out; + dim3 gridSize; +}; + +struct PbrSpecular +{ + Tensor col; + Tensor nrm; + Tensor wo; + Tensor wi; + Tensor alpha; + Tensor out; + dim3 gridSize; + float min_roughness; +}; + +struct PbrBSDF +{ + Tensor kd; + Tensor arm; + Tensor pos; + Tensor nrm; + Tensor view_pos; + Tensor light_pos; + Tensor out; + dim3 gridSize; + float min_roughness; + int BSDF; +}; diff --git a/render/renderutils/c_src/common.cpp b/render/renderutils/c_src/common.cpp new file mode 100644 index 0000000..445895e --- /dev/null +++ b/render/renderutils/c_src/common.cpp @@ -0,0 +1,74 @@ +/* + * Copyright (c) 2020-2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * + * NVIDIA CORPORATION, its affiliates and licensors retain all intellectual + * property and proprietary rights in and to this material, related + * documentation and any modifications thereto. Any use, reproduction, + * disclosure or distribution of this material and related documentation + * without an express license agreement from NVIDIA CORPORATION or + * its affiliates is strictly prohibited. + */ + +#include +#include + +//------------------------------------------------------------------------ +// Block and grid size calculators for kernel launches. + +dim3 getLaunchBlockSize(int maxWidth, int maxHeight, dim3 dims) +{ + int maxThreads = maxWidth * maxHeight; + if (maxThreads <= 1 || (dims.x * dims.y) <= 1) + return dim3(1, 1, 1); // Degenerate. + + // Start from max size. + int bw = maxWidth; + int bh = maxHeight; + + // Optimizations for weirdly sized buffers. + if (dims.x < bw) + { + // Decrease block width to smallest power of two that covers the buffer width. + while ((bw >> 1) >= dims.x) + bw >>= 1; + + // Maximize height. + bh = maxThreads / bw; + if (bh > dims.y) + bh = dims.y; + } + else if (dims.y < bh) + { + // Halve height and double width until fits completely inside buffer vertically. + while (bh > dims.y) + { + bh >>= 1; + if (bw < dims.x) + bw <<= 1; + } + } + + // Done. + return dim3(bw, bh, 1); +} + +// returns the size of a block that can be reduced using horizontal SIMD operations (e.g. __shfl_xor_sync) +dim3 getWarpSize(dim3 blockSize) +{ + return dim3( + std::min(blockSize.x, 32u), + std::min(std::max(32u / blockSize.x, 1u), std::min(32u, blockSize.y)), + std::min(std::max(32u / (blockSize.x * blockSize.y), 1u), std::min(32u, blockSize.z)) + ); +} + +dim3 getLaunchGridSize(dim3 blockSize, dim3 dims) +{ + dim3 gridSize; + gridSize.x = (dims.x - 1) / blockSize.x + 1; + gridSize.y = (dims.y - 1) / blockSize.y + 1; + gridSize.z = (dims.z - 1) / blockSize.z + 1; + return gridSize; +} + +//------------------------------------------------------------------------ diff --git a/render/renderutils/c_src/common.h b/render/renderutils/c_src/common.h new file mode 100644 index 0000000..5abaeeb --- /dev/null +++ b/render/renderutils/c_src/common.h @@ -0,0 +1,41 @@ +/* + * Copyright (c) 2020-2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * + * NVIDIA CORPORATION, its affiliates and licensors retain all intellectual + * property and proprietary rights in and to this material, related + * documentation and any modifications thereto. Any use, reproduction, + * disclosure or distribution of this material and related documentation + * without an express license agreement from NVIDIA CORPORATION or + * its affiliates is strictly prohibited. + */ + +#pragma once +#include +#include + +#include "vec3f.h" +#include "vec4f.h" +#include "tensor.h" + +dim3 getLaunchBlockSize(int maxWidth, int maxHeight, dim3 dims); +dim3 getLaunchGridSize(dim3 blockSize, dim3 dims); + +#ifdef __CUDACC__ + +#ifdef _MSC_VER +#define M_PI 3.14159265358979323846f +#endif + +__host__ __device__ static inline dim3 getWarpSize(dim3 blockSize) +{ + return dim3( + min(blockSize.x, 32u), + min(max(32u / blockSize.x, 1u), min(32u, blockSize.y)), + min(max(32u / (blockSize.x * blockSize.y), 1u), min(32u, blockSize.z)) + ); +} + +__device__ static inline float clamp(float val, float mn, float mx) { return min(max(val, mn), mx); } +#else +dim3 getWarpSize(dim3 blockSize); +#endif \ No newline at end of file diff --git a/render/renderutils/c_src/cubemap.cu b/render/renderutils/c_src/cubemap.cu new file mode 100644 index 0000000..2ce21d8 --- /dev/null +++ b/render/renderutils/c_src/cubemap.cu @@ -0,0 +1,350 @@ +/* + * Copyright (c) 2020-2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * + * NVIDIA CORPORATION, its affiliates and licensors retain all intellectual + * property and proprietary rights in and to this material, related + * documentation and any modifications thereto. Any use, reproduction, + * disclosure or distribution of this material and related documentation + * without an express license agreement from NVIDIA CORPORATION or + * its affiliates is strictly prohibited. + */ + +#include "common.h" +#include "cubemap.h" +#include + +// https://cgvr.cs.uni-bremen.de/teaching/cg_literatur/Spherical,%20Cubic,%20and%20Parabolic%20Environment%20Mappings.pdf +__device__ float pixel_area(int x, int y, int N) +{ + if (N > 1) + { + int H = N / 2; + x = abs(x - H); + y = abs(y - H); + float dx = atan((float)(x + 1) / (float)H) - atan((float)x / (float)H); + float dy = atan((float)(y + 1) / (float)H) - atan((float)y / (float)H); + return dx * dy; + } + else + return 1; +} + +__device__ vec3f cube_to_dir(int x, int y, int side, int N) +{ + float fx = 2.0f * (((float)x + 0.5f) / (float)N) - 1.0f; + float fy = 2.0f * (((float)y + 0.5f) / (float)N) - 1.0f; + switch (side) + { + case 0: return safeNormalize(vec3f(1, -fy, -fx)); + case 1: return safeNormalize(vec3f(-1, -fy, fx)); + case 2: return safeNormalize(vec3f(fx, 1, fy)); + case 3: return safeNormalize(vec3f(fx, -1, -fy)); + case 4: return safeNormalize(vec3f(fx, -fy, 1)); + case 5: return safeNormalize(vec3f(-fx, -fy, -1)); + } + return vec3f(0,0,0); // Unreachable +} + +__device__ vec3f dir_to_side(int side, vec3f v) +{ + switch (side) + { + case 0: return vec3f(-v.z, -v.y, v.x); + case 1: return vec3f( v.z, -v.y, -v.x); + case 2: return vec3f( v.x, v.z, v.y); + case 3: return vec3f( v.x, -v.z, -v.y); + case 4: return vec3f( v.x, -v.y, v.z); + case 5: return vec3f(-v.x, -v.y, -v.z); + } + return vec3f(0,0,0); // Unreachable +} + +__device__ void extents_1d(float x, float z, float theta, float& _min, float& _max) +{ + float l = sqrtf(x * x + z * z); + float pxr = x + z * tan(theta) * l, pzr = z - x * tan(theta) * l; + float pxl = x - z * tan(theta) * l, pzl = z + x * tan(theta) * l; + if (pzl <= 0.00001f) + _min = pxl > 0.0f ? FLT_MAX : -FLT_MAX; + else + _min = pxl / pzl; + if (pzr <= 0.00001f) + _max = pxr > 0.0f ? FLT_MAX : -FLT_MAX; + else + _max = pxr / pzr; +} + +__device__ void dir_extents(int side, int N, vec3f v, float theta, int &_xmin, int& _xmax, int& _ymin, int& _ymax) +{ + vec3f c = dir_to_side(side, v); // remap to (x,y,z) where side is at z = 1 + + if (theta < 0.785398f) // PI/4 + { + float xmin, xmax, ymin, ymax; + extents_1d(c.x, c.z, theta, xmin, xmax); + extents_1d(c.y, c.z, theta, ymin, ymax); + + if (xmin > 1.0f || xmax < -1.0f || ymin > 1.0f || ymax < -1.0f) + { + _xmin = -1; _xmax = -1; _ymin = -1; _ymax = -1; // Bad aabb + } + else + { + _xmin = (int)min(max((xmin + 1.0f) * (0.5f * (float)N), 0.0f), (float)(N - 1)); + _xmax = (int)min(max((xmax + 1.0f) * (0.5f * (float)N), 0.0f), (float)(N - 1)); + _ymin = (int)min(max((ymin + 1.0f) * (0.5f * (float)N), 0.0f), (float)(N - 1)); + _ymax = (int)min(max((ymax + 1.0f) * (0.5f * (float)N), 0.0f), (float)(N - 1)); + } + } + else + { + _xmin = 0.0f; + _xmax = (float)(N-1); + _ymin = 0.0f; + _ymax = (float)(N-1); + } +} + +/////////////////////////////////////////////////////////////////////////////////////////////////////////// +// Diffuse kernel +__global__ void DiffuseCubemapFwdKernel(DiffuseCubemapKernelParams p) +{ + // Calculate pixel position. + int px = blockIdx.x * blockDim.x + threadIdx.x; + int py = blockIdx.y * blockDim.y + threadIdx.y; + int pz = blockIdx.z; + if (px >= p.gridSize.x || py >= p.gridSize.y || pz >= p.gridSize.z) + return; + + int Npx = p.cubemap.dims[1]; + vec3f N = cube_to_dir(px, py, pz, Npx); + + vec3f col(0); + + for (int s = 0; s < p.cubemap.dims[0]; ++s) + { + for (int y = 0; y < Npx; ++y) + { + for (int x = 0; x < Npx; ++x) + { + vec3f L = cube_to_dir(x, y, s, Npx); + float costheta = min(max(dot(N, L), 0.0f), 0.999f); + float w = costheta * pixel_area(x, y, Npx) / 3.141592f; // pi = area of positive hemisphere + col += p.cubemap.fetch3(x, y, s) * w; + } + } + } + + p.out.store(px, py, pz, col); +} + +__global__ void DiffuseCubemapBwdKernel(DiffuseCubemapKernelParams p) +{ + // Calculate pixel position. + int px = blockIdx.x * blockDim.x + threadIdx.x; + int py = blockIdx.y * blockDim.y + threadIdx.y; + int pz = blockIdx.z; + if (px >= p.gridSize.x || py >= p.gridSize.y || pz >= p.gridSize.z) + return; + + int Npx = p.cubemap.dims[1]; + vec3f N = cube_to_dir(px, py, pz, Npx); + vec3f grad = p.out.fetch3(px, py, pz); + + for (int s = 0; s < p.cubemap.dims[0]; ++s) + { + for (int y = 0; y < Npx; ++y) + { + for (int x = 0; x < Npx; ++x) + { + vec3f L = cube_to_dir(x, y, s, Npx); + float costheta = min(max(dot(N, L), 0.0f), 0.999f); + float w = costheta * pixel_area(x, y, Npx) / 3.141592f; // pi = area of positive hemisphere + atomicAdd((float*)p.cubemap.d_val + p.cubemap.nhwcIndexContinuous(s, y, x, 0), grad.x * w); + atomicAdd((float*)p.cubemap.d_val + p.cubemap.nhwcIndexContinuous(s, y, x, 1), grad.y * w); + atomicAdd((float*)p.cubemap.d_val + p.cubemap.nhwcIndexContinuous(s, y, x, 2), grad.z * w); + } + } + } +} + +/////////////////////////////////////////////////////////////////////////////////////////////////////////// +// GGX splitsum kernel + +__device__ inline float ndfGGX(const float alphaSqr, const float cosTheta) +{ + float _cosTheta = clamp(cosTheta, 0.0, 1.0f); + float d = (_cosTheta * alphaSqr - _cosTheta) * _cosTheta + 1.0f; + return alphaSqr / (d * d * M_PI); +} + +__global__ void SpecularBoundsKernel(SpecularBoundsKernelParams p) +{ + int px = blockIdx.x * blockDim.x + threadIdx.x; + int py = blockIdx.y * blockDim.y + threadIdx.y; + int pz = blockIdx.z; + if (px >= p.gridSize.x || py >= p.gridSize.y || pz >= p.gridSize.z) + return; + + int Npx = p.gridSize.x; + vec3f VNR = cube_to_dir(px, py, pz, Npx); + + const int TILE_SIZE = 16; + + // Brute force entire cubemap and compute bounds for the cone + for (int s = 0; s < p.gridSize.z; ++s) + { + // Assume empty BBox + int _min_x = p.gridSize.x - 1, _max_x = 0; + int _min_y = p.gridSize.y - 1, _max_y = 0; + + // For each (8x8) tile + for (int tx = 0; tx < (p.gridSize.x + TILE_SIZE - 1) / TILE_SIZE; tx++) + { + for (int ty = 0; ty < (p.gridSize.y + TILE_SIZE - 1) / TILE_SIZE; ty++) + { + // Compute tile extents + int tsx = tx * TILE_SIZE, tsy = ty * TILE_SIZE; + int tex = min((tx + 1) * TILE_SIZE, p.gridSize.x), tey = min((ty + 1) * TILE_SIZE, p.gridSize.y); + + // Use some blunt interval arithmetics to cull tiles + vec3f L0 = cube_to_dir(tsx, tsy, s, Npx), L1 = cube_to_dir(tex, tsy, s, Npx); + vec3f L2 = cube_to_dir(tsx, tey, s, Npx), L3 = cube_to_dir(tex, tey, s, Npx); + + float minx = min(min(L0.x, L1.x), min(L2.x, L3.x)), maxx = max(max(L0.x, L1.x), max(L2.x, L3.x)); + float miny = min(min(L0.y, L1.y), min(L2.y, L3.y)), maxy = max(max(L0.y, L1.y), max(L2.y, L3.y)); + float minz = min(min(L0.z, L1.z), min(L2.z, L3.z)), maxz = max(max(L0.z, L1.z), max(L2.z, L3.z)); + + float maxdp = max(minx * VNR.x, maxx * VNR.x) + max(miny * VNR.y, maxy * VNR.y) + max(minz * VNR.z, maxz * VNR.z); + if (maxdp >= p.costheta_cutoff) + { + // Test all pixels in tile. + for (int y = tsy; y < tey; ++y) + { + for (int x = tsx; x < tex; ++x) + { + vec3f L = cube_to_dir(x, y, s, Npx); + if (dot(L, VNR) >= p.costheta_cutoff) + { + _min_x = min(_min_x, x); + _max_x = max(_max_x, x); + _min_y = min(_min_y, y); + _max_y = max(_max_y, y); + } + } + } + } + } + } + p.out.store(p.out._nhwcIndex(pz, py, px, s * 4 + 0), _min_x); + p.out.store(p.out._nhwcIndex(pz, py, px, s * 4 + 1), _max_x); + p.out.store(p.out._nhwcIndex(pz, py, px, s * 4 + 2), _min_y); + p.out.store(p.out._nhwcIndex(pz, py, px, s * 4 + 3), _max_y); + } +} + +__global__ void SpecularCubemapFwdKernel(SpecularCubemapKernelParams p) +{ + // Calculate pixel position. + int px = blockIdx.x * blockDim.x + threadIdx.x; + int py = blockIdx.y * blockDim.y + threadIdx.y; + int pz = blockIdx.z; + if (px >= p.gridSize.x || py >= p.gridSize.y || pz >= p.gridSize.z) + return; + + int Npx = p.cubemap.dims[1]; + vec3f VNR = cube_to_dir(px, py, pz, Npx); + + float alpha = p.roughness * p.roughness; + float alphaSqr = alpha * alpha; + + float wsum = 0.0f; + vec3f col(0); + for (int s = 0; s < p.cubemap.dims[0]; ++s) + { + int xmin, xmax, ymin, ymax; + xmin = (int)p.bounds.fetch(p.bounds._nhwcIndex(pz, py, px, s * 4 + 0)); + xmax = (int)p.bounds.fetch(p.bounds._nhwcIndex(pz, py, px, s * 4 + 1)); + ymin = (int)p.bounds.fetch(p.bounds._nhwcIndex(pz, py, px, s * 4 + 2)); + ymax = (int)p.bounds.fetch(p.bounds._nhwcIndex(pz, py, px, s * 4 + 3)); + + if (xmin <= xmax) + { + for (int y = ymin; y <= ymax; ++y) + { + for (int x = xmin; x <= xmax; ++x) + { + vec3f L = cube_to_dir(x, y, s, Npx); + if (dot(L, VNR) >= p.costheta_cutoff) + { + vec3f H = safeNormalize(L + VNR); + + float wiDotN = max(dot(L, VNR), 0.0f); + float VNRDotH = max(dot(VNR, H), 0.0f); + + float w = wiDotN * ndfGGX(alphaSqr, VNRDotH) * pixel_area(x, y, Npx) / 4.0f; + col += p.cubemap.fetch3(x, y, s) * w; + wsum += w; + } + } + } + } + } + + p.out.store(p.out._nhwcIndex(pz, py, px, 0), col.x); + p.out.store(p.out._nhwcIndex(pz, py, px, 1), col.y); + p.out.store(p.out._nhwcIndex(pz, py, px, 2), col.z); + p.out.store(p.out._nhwcIndex(pz, py, px, 3), wsum); +} + +__global__ void SpecularCubemapBwdKernel(SpecularCubemapKernelParams p) +{ + // Calculate pixel position. + int px = blockIdx.x * blockDim.x + threadIdx.x; + int py = blockIdx.y * blockDim.y + threadIdx.y; + int pz = blockIdx.z; + if (px >= p.gridSize.x || py >= p.gridSize.y || pz >= p.gridSize.z) + return; + + int Npx = p.cubemap.dims[1]; + vec3f VNR = cube_to_dir(px, py, pz, Npx); + + vec3f grad = p.out.fetch3(px, py, pz); + + float alpha = p.roughness * p.roughness; + float alphaSqr = alpha * alpha; + + vec3f col(0); + for (int s = 0; s < p.cubemap.dims[0]; ++s) + { + int xmin, xmax, ymin, ymax; + xmin = (int)p.bounds.fetch(p.bounds._nhwcIndex(pz, py, px, s * 4 + 0)); + xmax = (int)p.bounds.fetch(p.bounds._nhwcIndex(pz, py, px, s * 4 + 1)); + ymin = (int)p.bounds.fetch(p.bounds._nhwcIndex(pz, py, px, s * 4 + 2)); + ymax = (int)p.bounds.fetch(p.bounds._nhwcIndex(pz, py, px, s * 4 + 3)); + + if (xmin <= xmax) + { + for (int y = ymin; y <= ymax; ++y) + { + for (int x = xmin; x <= xmax; ++x) + { + vec3f L = cube_to_dir(x, y, s, Npx); + if (dot(L, VNR) >= p.costheta_cutoff) + { + vec3f H = safeNormalize(L + VNR); + + float wiDotN = max(dot(L, VNR), 0.0f); + float VNRDotH = max(dot(VNR, H), 0.0f); + + float w = wiDotN * ndfGGX(alphaSqr, VNRDotH) * pixel_area(x, y, Npx) / 4.0f; + + atomicAdd((float*)p.cubemap.d_val + p.cubemap.nhwcIndexContinuous(s, y, x, 0), grad.x * w); + atomicAdd((float*)p.cubemap.d_val + p.cubemap.nhwcIndexContinuous(s, y, x, 1), grad.y * w); + atomicAdd((float*)p.cubemap.d_val + p.cubemap.nhwcIndexContinuous(s, y, x, 2), grad.z * w); + } + } + } + } + } +} diff --git a/render/renderutils/c_src/cubemap.h b/render/renderutils/c_src/cubemap.h new file mode 100644 index 0000000..f395cc2 --- /dev/null +++ b/render/renderutils/c_src/cubemap.h @@ -0,0 +1,38 @@ +/* + * Copyright (c) 2020-2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * + * NVIDIA CORPORATION, its affiliates and licensors retain all intellectual + * property and proprietary rights in and to this material, related + * documentation and any modifications thereto. Any use, reproduction, + * disclosure or distribution of this material and related documentation + * without an express license agreement from NVIDIA CORPORATION or + * its affiliates is strictly prohibited. + */ + +#pragma once + +#include "common.h" + +struct DiffuseCubemapKernelParams +{ + Tensor cubemap; + Tensor out; + dim3 gridSize; +}; + +struct SpecularCubemapKernelParams +{ + Tensor cubemap; + Tensor bounds; + Tensor out; + dim3 gridSize; + float costheta_cutoff; + float roughness; +}; + +struct SpecularBoundsKernelParams +{ + float costheta_cutoff; + Tensor out; + dim3 gridSize; +}; diff --git a/render/renderutils/c_src/loss.cu b/render/renderutils/c_src/loss.cu new file mode 100644 index 0000000..aae5272 --- /dev/null +++ b/render/renderutils/c_src/loss.cu @@ -0,0 +1,210 @@ +/* + * Copyright (c) 2020-2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * + * NVIDIA CORPORATION, its affiliates and licensors retain all intellectual + * property and proprietary rights in and to this material, related + * documentation and any modifications thereto. Any use, reproduction, + * disclosure or distribution of this material and related documentation + * without an express license agreement from NVIDIA CORPORATION or + * its affiliates is strictly prohibited. + */ + +#include + +#include "common.h" +#include "loss.h" + +//------------------------------------------------------------------------ +// Utils + +__device__ inline float bwdAbs(float x) { return x == 0.0f ? 0.0f : x < 0.0f ? -1.0f : 1.0f; } + +__device__ float warpSum(float val) { + for (int i = 1; i < 32; i *= 2) + val += __shfl_xor_sync(0xFFFFFFFF, val, i); + return val; +} + +//------------------------------------------------------------------------ +// Tonemapping + +__device__ inline float fwdSRGB(float x) +{ + return x > 0.0031308f ? powf(max(x, 0.0031308f), 1.0f / 2.4f) * 1.055f - 0.055f : 12.92f * max(x, 0.0f); +} + +__device__ inline void bwdSRGB(float x, float &d_x, float d_out) +{ + if (x > 0.0031308f) + d_x += d_out * 0.439583f / powf(x, 0.583333f); + else if (x > 0.0f) + d_x += d_out * 12.92f; +} + +__device__ inline vec3f fwdTonemapLogSRGB(vec3f x) +{ + return vec3f(fwdSRGB(logf(x.x + 1.0f)), fwdSRGB(logf(x.y + 1.0f)), fwdSRGB(logf(x.z + 1.0f))); +} + +__device__ inline void bwdTonemapLogSRGB(vec3f x, vec3f& d_x, vec3f d_out) +{ + if (x.x > 0.0f && x.x < 65535.0f) + { + bwdSRGB(logf(x.x + 1.0f), d_x.x, d_out.x); + d_x.x *= 1 / (x.x + 1.0f); + } + if (x.y > 0.0f && x.y < 65535.0f) + { + bwdSRGB(logf(x.y + 1.0f), d_x.y, d_out.y); + d_x.y *= 1 / (x.y + 1.0f); + } + if (x.z > 0.0f && x.z < 65535.0f) + { + bwdSRGB(logf(x.z + 1.0f), d_x.z, d_out.z); + d_x.z *= 1 / (x.z + 1.0f); + } +} + +__device__ inline float fwdRELMSE(float img, float target, float eps = 0.1f) +{ + return (img - target) * (img - target) / (img * img + target * target + eps); +} + +__device__ inline void bwdRELMSE(float img, float target, float &d_img, float &d_target, float d_out, float eps = 0.1f) +{ + float denom = (target * target + img * img + eps); + d_img += d_out * 2 * (img - target) * (target * (target + img) + eps) / (denom * denom); + d_target -= d_out * 2 * (img - target) * (img * (target + img) + eps) / (denom * denom); +} + +__device__ inline float fwdSMAPE(float img, float target, float eps=0.01f) +{ + return abs(img - target) / (img + target + eps); +} + +__device__ inline void bwdSMAPE(float img, float target, float& d_img, float& d_target, float d_out, float eps = 0.01f) +{ + float denom = (target + img + eps); + d_img += d_out * bwdAbs(img - target) * (2 * target + eps) / (denom * denom); + d_target -= d_out * bwdAbs(img - target) * (2 * img + eps) / (denom * denom); +} + +//------------------------------------------------------------------------ +// Kernels + +__global__ void imgLossFwdKernel(LossKernelParams p) +{ + // Calculate pixel position. + unsigned int px = blockIdx.x * blockDim.x + threadIdx.x; + unsigned int py = blockIdx.y * blockDim.y + threadIdx.y; + unsigned int pz = blockIdx.z; + + float floss = 0.0f; + if (px < p.gridSize.x && py < p.gridSize.y && pz < p.gridSize.z) + { + vec3f img = p.img.fetch3(px, py, pz); + vec3f target = p.target.fetch3(px, py, pz); + + img = vec3f(clamp(img.x, 0.0f, 65535.0f), clamp(img.y, 0.0f, 65535.0f), clamp(img.z, 0.0f, 65535.0f)); + target = vec3f(clamp(target.x, 0.0f, 65535.0f), clamp(target.y, 0.0f, 65535.0f), clamp(target.z, 0.0f, 65535.0f)); + + if (p.tonemapper == TONEMAPPER_LOG_SRGB) + { + img = fwdTonemapLogSRGB(img); + target = fwdTonemapLogSRGB(target); + } + + vec3f vloss(0); + if (p.loss == LOSS_MSE) + vloss = (img - target) * (img - target); + else if (p.loss == LOSS_RELMSE) + vloss = vec3f(fwdRELMSE(img.x, target.x), fwdRELMSE(img.y, target.y), fwdRELMSE(img.z, target.z)); + else if (p.loss == LOSS_SMAPE) + vloss = vec3f(fwdSMAPE(img.x, target.x), fwdSMAPE(img.y, target.y), fwdSMAPE(img.z, target.z)); + else + vloss = vec3f(abs(img.x - target.x), abs(img.y - target.y), abs(img.z - target.z)); + + floss = sum(vloss) / 3.0f; + } + + floss = warpSum(floss); + + dim3 warpSize = getWarpSize(blockDim); + if (px < p.gridSize.x && py < p.gridSize.y && pz < p.gridSize.z && threadIdx.x % warpSize.x == 0 && threadIdx.y % warpSize.y == 0 && threadIdx.z % warpSize.z == 0) + p.out.store(px / warpSize.x, py / warpSize.y, pz / warpSize.z, floss); +} + +__global__ void imgLossBwdKernel(LossKernelParams p) +{ + // Calculate pixel position. + unsigned int px = blockIdx.x * blockDim.x + threadIdx.x; + unsigned int py = blockIdx.y * blockDim.y + threadIdx.y; + unsigned int pz = blockIdx.z; + + if (px >= p.gridSize.x || py >= p.gridSize.y || pz >= p.gridSize.z) + return; + + dim3 warpSize = getWarpSize(blockDim); + + vec3f _img = p.img.fetch3(px, py, pz); + vec3f _target = p.target.fetch3(px, py, pz); + float d_out = p.out.fetch1(px / warpSize.x, py / warpSize.y, pz / warpSize.z); + + ///////////////////////////////////////////////////////////////////// + // FWD + + vec3f img = _img, target = _target; + if (p.tonemapper == TONEMAPPER_LOG_SRGB) + { + img = fwdTonemapLogSRGB(img); + target = fwdTonemapLogSRGB(target); + } + + ///////////////////////////////////////////////////////////////////// + // BWD + + vec3f d_vloss = vec3f(d_out, d_out, d_out) / 3.0f; + + vec3f d_img(0), d_target(0); + if (p.loss == LOSS_MSE) + { + d_img = vec3f(d_vloss.x * 2 * (img.x - target.x), d_vloss.y * 2 * (img.y - target.y), d_vloss.x * 2 * (img.z - target.z)); + d_target = -d_img; + } + else if (p.loss == LOSS_RELMSE) + { + bwdRELMSE(img.x, target.x, d_img.x, d_target.x, d_vloss.x); + bwdRELMSE(img.y, target.y, d_img.y, d_target.y, d_vloss.y); + bwdRELMSE(img.z, target.z, d_img.z, d_target.z, d_vloss.z); + } + else if (p.loss == LOSS_SMAPE) + { + bwdSMAPE(img.x, target.x, d_img.x, d_target.x, d_vloss.x); + bwdSMAPE(img.y, target.y, d_img.y, d_target.y, d_vloss.y); + bwdSMAPE(img.z, target.z, d_img.z, d_target.z, d_vloss.z); + } + else + { + d_img = d_vloss * vec3f(bwdAbs(img.x - target.x), bwdAbs(img.y - target.y), bwdAbs(img.z - target.z)); + d_target = -d_img; + } + + + if (p.tonemapper == TONEMAPPER_LOG_SRGB) + { + vec3f d__img(0), d__target(0); + bwdTonemapLogSRGB(_img, d__img, d_img); + bwdTonemapLogSRGB(_target, d__target, d_target); + d_img = d__img; d_target = d__target; + } + + if (_img.x <= 0.0f || _img.x >= 65535.0f) d_img.x = 0; + if (_img.y <= 0.0f || _img.y >= 65535.0f) d_img.y = 0; + if (_img.z <= 0.0f || _img.z >= 65535.0f) d_img.z = 0; + if (_target.x <= 0.0f || _target.x >= 65535.0f) d_target.x = 0; + if (_target.y <= 0.0f || _target.y >= 65535.0f) d_target.y = 0; + if (_target.z <= 0.0f || _target.z >= 65535.0f) d_target.z = 0; + + p.img.store_grad(px, py, pz, d_img); + p.target.store_grad(px, py, pz, d_target); +} \ No newline at end of file diff --git a/render/renderutils/c_src/loss.h b/render/renderutils/c_src/loss.h new file mode 100644 index 0000000..26790bf --- /dev/null +++ b/render/renderutils/c_src/loss.h @@ -0,0 +1,38 @@ +/* + * Copyright (c) 2020-2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * + * NVIDIA CORPORATION, its affiliates and licensors retain all intellectual + * property and proprietary rights in and to this material, related + * documentation and any modifications thereto. Any use, reproduction, + * disclosure or distribution of this material and related documentation + * without an express license agreement from NVIDIA CORPORATION or + * its affiliates is strictly prohibited. + */ + +#pragma once + +#include "common.h" + +enum TonemapperType +{ + TONEMAPPER_NONE = 0, + TONEMAPPER_LOG_SRGB = 1 +}; + +enum LossType +{ + LOSS_L1 = 0, + LOSS_MSE = 1, + LOSS_RELMSE = 2, + LOSS_SMAPE = 3 +}; + +struct LossKernelParams +{ + Tensor img; + Tensor target; + Tensor out; + dim3 gridSize; + TonemapperType tonemapper; + LossType loss; +}; diff --git a/render/renderutils/c_src/mesh.cu b/render/renderutils/c_src/mesh.cu new file mode 100644 index 0000000..3690ea3 --- /dev/null +++ b/render/renderutils/c_src/mesh.cu @@ -0,0 +1,94 @@ +/* + * Copyright (c) 2020-2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * + * NVIDIA CORPORATION, its affiliates and licensors retain all intellectual + * property and proprietary rights in and to this material, related + * documentation and any modifications thereto. Any use, reproduction, + * disclosure or distribution of this material and related documentation + * without an express license agreement from NVIDIA CORPORATION or + * its affiliates is strictly prohibited. + */ + +#include +#include + +#include "common.h" +#include "mesh.h" + + +//------------------------------------------------------------------------ +// Kernels + +__global__ void xfmPointsFwdKernel(XfmKernelParams p) +{ + unsigned int px = blockIdx.x * blockDim.x + threadIdx.x; + unsigned int pz = blockIdx.z * blockDim.z + threadIdx.z; + + __shared__ float mtx[4][4]; + if (threadIdx.x < 16) + mtx[threadIdx.x % 4][threadIdx.x / 4] = p.matrix.fetch(p.matrix.nhwcIndex(pz, threadIdx.x / 4, threadIdx.x % 4, 0)); + __syncthreads(); + + if (px >= p.gridSize.x) + return; + + vec3f pos( + p.points.fetch(p.points.nhwcIndex(pz, px, 0, 0)), + p.points.fetch(p.points.nhwcIndex(pz, px, 1, 0)), + p.points.fetch(p.points.nhwcIndex(pz, px, 2, 0)) + ); + + if (p.isPoints) + { + p.out.store(p.out.nhwcIndex(pz, px, 0, 0), pos.x * mtx[0][0] + pos.y * mtx[1][0] + pos.z * mtx[2][0] + mtx[3][0]); + p.out.store(p.out.nhwcIndex(pz, px, 1, 0), pos.x * mtx[0][1] + pos.y * mtx[1][1] + pos.z * mtx[2][1] + mtx[3][1]); + p.out.store(p.out.nhwcIndex(pz, px, 2, 0), pos.x * mtx[0][2] + pos.y * mtx[1][2] + pos.z * mtx[2][2] + mtx[3][2]); + p.out.store(p.out.nhwcIndex(pz, px, 3, 0), pos.x * mtx[0][3] + pos.y * mtx[1][3] + pos.z * mtx[2][3] + mtx[3][3]); + } + else + { + p.out.store(p.out.nhwcIndex(pz, px, 0, 0), pos.x * mtx[0][0] + pos.y * mtx[1][0] + pos.z * mtx[2][0]); + p.out.store(p.out.nhwcIndex(pz, px, 1, 0), pos.x * mtx[0][1] + pos.y * mtx[1][1] + pos.z * mtx[2][1]); + p.out.store(p.out.nhwcIndex(pz, px, 2, 0), pos.x * mtx[0][2] + pos.y * mtx[1][2] + pos.z * mtx[2][2]); + } +} + +__global__ void xfmPointsBwdKernel(XfmKernelParams p) +{ + unsigned int px = blockIdx.x * blockDim.x + threadIdx.x; + unsigned int pz = blockIdx.z * blockDim.z + threadIdx.z; + + __shared__ float mtx[4][4]; + if (threadIdx.x < 16) + mtx[threadIdx.x % 4][threadIdx.x / 4] = p.matrix.fetch(p.matrix.nhwcIndex(pz, threadIdx.x / 4, threadIdx.x % 4, 0)); + __syncthreads(); + + if (px >= p.gridSize.x) + return; + + vec3f pos( + p.points.fetch(p.points.nhwcIndex(pz, px, 0, 0)), + p.points.fetch(p.points.nhwcIndex(pz, px, 1, 0)), + p.points.fetch(p.points.nhwcIndex(pz, px, 2, 0)) + ); + + vec4f d_out( + p.out.fetch(p.out.nhwcIndex(pz, px, 0, 0)), + p.out.fetch(p.out.nhwcIndex(pz, px, 1, 0)), + p.out.fetch(p.out.nhwcIndex(pz, px, 2, 0)), + p.out.fetch(p.out.nhwcIndex(pz, px, 3, 0)) + ); + + if (p.isPoints) + { + p.points.store_grad(p.points.nhwcIndexContinuous(pz, px, 0, 0), d_out.x * mtx[0][0] + d_out.y * mtx[0][1] + d_out.z * mtx[0][2] + d_out.w * mtx[0][3]); + p.points.store_grad(p.points.nhwcIndexContinuous(pz, px, 1, 0), d_out.x * mtx[1][0] + d_out.y * mtx[1][1] + d_out.z * mtx[1][2] + d_out.w * mtx[1][3]); + p.points.store_grad(p.points.nhwcIndexContinuous(pz, px, 2, 0), d_out.x * mtx[2][0] + d_out.y * mtx[2][1] + d_out.z * mtx[2][2] + d_out.w * mtx[2][3]); + } + else + { + p.points.store_grad(p.points.nhwcIndexContinuous(pz, px, 0, 0), d_out.x * mtx[0][0] + d_out.y * mtx[0][1] + d_out.z * mtx[0][2]); + p.points.store_grad(p.points.nhwcIndexContinuous(pz, px, 1, 0), d_out.x * mtx[1][0] + d_out.y * mtx[1][1] + d_out.z * mtx[1][2]); + p.points.store_grad(p.points.nhwcIndexContinuous(pz, px, 2, 0), d_out.x * mtx[2][0] + d_out.y * mtx[2][1] + d_out.z * mtx[2][2]); + } +} \ No newline at end of file diff --git a/render/renderutils/c_src/mesh.h b/render/renderutils/c_src/mesh.h new file mode 100644 index 0000000..16e2166 --- /dev/null +++ b/render/renderutils/c_src/mesh.h @@ -0,0 +1,23 @@ +/* + * Copyright (c) 2020-2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * + * NVIDIA CORPORATION, its affiliates and licensors retain all intellectual + * property and proprietary rights in and to this material, related + * documentation and any modifications thereto. Any use, reproduction, + * disclosure or distribution of this material and related documentation + * without an express license agreement from NVIDIA CORPORATION or + * its affiliates is strictly prohibited. + */ + +#pragma once + +#include "common.h" + +struct XfmKernelParams +{ + bool isPoints; + Tensor points; + Tensor matrix; + Tensor out; + dim3 gridSize; +}; diff --git a/render/renderutils/c_src/normal.cu b/render/renderutils/c_src/normal.cu new file mode 100644 index 0000000..a50e49e --- /dev/null +++ b/render/renderutils/c_src/normal.cu @@ -0,0 +1,182 @@ +/* + * Copyright (c) 2020-2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * + * NVIDIA CORPORATION, its affiliates and licensors retain all intellectual + * property and proprietary rights in and to this material, related + * documentation and any modifications thereto. Any use, reproduction, + * disclosure or distribution of this material and related documentation + * without an express license agreement from NVIDIA CORPORATION or + * its affiliates is strictly prohibited. + */ + +#include "common.h" +#include "normal.h" + +#define NORMAL_THRESHOLD 0.1f + +//------------------------------------------------------------------------ +// Perturb shading normal by tangent frame + +__device__ vec3f fwdPerturbNormal(const vec3f perturbed_nrm, const vec3f smooth_nrm, const vec3f smooth_tng, bool opengl) +{ + vec3f _smooth_bitng = cross(smooth_tng, smooth_nrm); + vec3f smooth_bitng = safeNormalize(_smooth_bitng); + vec3f _shading_nrm = smooth_tng * perturbed_nrm.x + (opengl ? -1 : 1) * smooth_bitng * perturbed_nrm.y + smooth_nrm * max(perturbed_nrm.z, 0.0f); + return safeNormalize(_shading_nrm); +} + +__device__ void bwdPerturbNormal(const vec3f perturbed_nrm, const vec3f smooth_nrm, const vec3f smooth_tng, vec3f &d_perturbed_nrm, vec3f &d_smooth_nrm, vec3f &d_smooth_tng, const vec3f d_out, bool opengl) +{ + //////////////////////////////////////////////////////////////////////// + // FWD + vec3f _smooth_bitng = cross(smooth_tng, smooth_nrm); + vec3f smooth_bitng = safeNormalize(_smooth_bitng); + vec3f _shading_nrm = smooth_tng * perturbed_nrm.x + (opengl ? -1 : 1) * smooth_bitng * perturbed_nrm.y + smooth_nrm * max(perturbed_nrm.z, 0.0f); + + //////////////////////////////////////////////////////////////////////// + // BWD + vec3f d_shading_nrm(0); + bwdSafeNormalize(_shading_nrm, d_shading_nrm, d_out); + + vec3f d_smooth_bitng(0); + + if (perturbed_nrm.z > 0.0f) + { + d_smooth_nrm += d_shading_nrm * perturbed_nrm.z; + d_perturbed_nrm.z += sum(d_shading_nrm * smooth_nrm); + } + + d_smooth_bitng += (opengl ? -1 : 1) * d_shading_nrm * perturbed_nrm.y; + d_perturbed_nrm.y += (opengl ? -1 : 1) * sum(d_shading_nrm * smooth_bitng); + + d_smooth_tng += d_shading_nrm * perturbed_nrm.x; + d_perturbed_nrm.x += sum(d_shading_nrm * smooth_tng); + + vec3f d__smooth_bitng(0); + bwdSafeNormalize(_smooth_bitng, d__smooth_bitng, d_smooth_bitng); + + bwdCross(smooth_tng, smooth_nrm, d_smooth_tng, d_smooth_nrm, d__smooth_bitng); +} + +//------------------------------------------------------------------------ +#define bent_nrm_eps 0.001f + +__device__ vec3f fwdBendNormal(const vec3f view_vec, const vec3f smooth_nrm, const vec3f geom_nrm) +{ + float dp = dot(view_vec, smooth_nrm); + float t = clamp(dp / NORMAL_THRESHOLD, 0.0f, 1.0f); + return geom_nrm * (1.0f - t) + smooth_nrm * t; +} + +__device__ void bwdBendNormal(const vec3f view_vec, const vec3f smooth_nrm, const vec3f geom_nrm, vec3f& d_view_vec, vec3f& d_smooth_nrm, vec3f& d_geom_nrm, const vec3f d_out) +{ + //////////////////////////////////////////////////////////////////////// + // FWD + float dp = dot(view_vec, smooth_nrm); + float t = clamp(dp / NORMAL_THRESHOLD, 0.0f, 1.0f); + + //////////////////////////////////////////////////////////////////////// + // BWD + if (dp > NORMAL_THRESHOLD) + d_smooth_nrm += d_out; + else + { + // geom_nrm * (1.0f - t) + smooth_nrm * t; + d_geom_nrm += d_out * (1.0f - t); + d_smooth_nrm += d_out * t; + float d_t = sum(d_out * (smooth_nrm - geom_nrm)); + + float d_dp = dp < 0.0f || dp > NORMAL_THRESHOLD ? 0.0f : d_t / NORMAL_THRESHOLD; + + bwdDot(view_vec, smooth_nrm, d_view_vec, d_smooth_nrm, d_dp); + } +} + +//------------------------------------------------------------------------ +// Kernels + +__global__ void PrepareShadingNormalFwdKernel(PrepareShadingNormalKernelParams p) +{ + // Calculate pixel position. + unsigned int px = blockIdx.x * blockDim.x + threadIdx.x; + unsigned int py = blockIdx.y * blockDim.y + threadIdx.y; + unsigned int pz = blockIdx.z; + if (px >= p.gridSize.x || py >= p.gridSize.y || pz >= p.gridSize.z) + return; + + vec3f pos = p.pos.fetch3(px, py, pz); + vec3f view_pos = p.view_pos.fetch3(px, py, pz); + vec3f perturbed_nrm = p.perturbed_nrm.fetch3(px, py, pz); + vec3f _smooth_nrm = p.smooth_nrm.fetch3(px, py, pz); + vec3f _smooth_tng = p.smooth_tng.fetch3(px, py, pz); + vec3f geom_nrm = p.geom_nrm.fetch3(px, py, pz); + + vec3f smooth_nrm = safeNormalize(_smooth_nrm); + vec3f smooth_tng = safeNormalize(_smooth_tng); + vec3f view_vec = safeNormalize(view_pos - pos); + vec3f shading_nrm = fwdPerturbNormal(perturbed_nrm, smooth_nrm, smooth_tng, p.opengl); + + vec3f res; + if (p.two_sided_shading && dot(view_vec, geom_nrm) < 0.0f) + res = fwdBendNormal(view_vec, -shading_nrm, -geom_nrm); + else + res = fwdBendNormal(view_vec, shading_nrm, geom_nrm); + + p.out.store(px, py, pz, res); +} + +__global__ void PrepareShadingNormalBwdKernel(PrepareShadingNormalKernelParams p) +{ + // Calculate pixel position. + unsigned int px = blockIdx.x * blockDim.x + threadIdx.x; + unsigned int py = blockIdx.y * blockDim.y + threadIdx.y; + unsigned int pz = blockIdx.z; + if (px >= p.gridSize.x || py >= p.gridSize.y || pz >= p.gridSize.z) + return; + + vec3f pos = p.pos.fetch3(px, py, pz); + vec3f view_pos = p.view_pos.fetch3(px, py, pz); + vec3f perturbed_nrm = p.perturbed_nrm.fetch3(px, py, pz); + vec3f _smooth_nrm = p.smooth_nrm.fetch3(px, py, pz); + vec3f _smooth_tng = p.smooth_tng.fetch3(px, py, pz); + vec3f geom_nrm = p.geom_nrm.fetch3(px, py, pz); + vec3f d_out = p.out.fetch3(px, py, pz); + + /////////////////////////////////////////////////////////////////////////////////////////////////// + // FWD + + vec3f smooth_nrm = safeNormalize(_smooth_nrm); + vec3f smooth_tng = safeNormalize(_smooth_tng); + vec3f _view_vec = view_pos - pos; + vec3f view_vec = safeNormalize(view_pos - pos); + + vec3f shading_nrm = fwdPerturbNormal(perturbed_nrm, smooth_nrm, smooth_tng, p.opengl); + + /////////////////////////////////////////////////////////////////////////////////////////////////// + // BWD + + vec3f d_view_vec(0), d_shading_nrm(0), d_geom_nrm(0); + if (p.two_sided_shading && dot(view_vec, geom_nrm) < 0.0f) + { + bwdBendNormal(view_vec, -shading_nrm, -geom_nrm, d_view_vec, d_shading_nrm, d_geom_nrm, d_out); + d_shading_nrm = -d_shading_nrm; + d_geom_nrm = -d_geom_nrm; + } + else + bwdBendNormal(view_vec, shading_nrm, geom_nrm, d_view_vec, d_shading_nrm, d_geom_nrm, d_out); + + vec3f d_perturbed_nrm(0), d_smooth_nrm(0), d_smooth_tng(0); + bwdPerturbNormal(perturbed_nrm, smooth_nrm, smooth_tng, d_perturbed_nrm, d_smooth_nrm, d_smooth_tng, d_shading_nrm, p.opengl); + + vec3f d__view_vec(0), d__smooth_nrm(0), d__smooth_tng(0); + bwdSafeNormalize(_view_vec, d__view_vec, d_view_vec); + bwdSafeNormalize(_smooth_nrm, d__smooth_nrm, d_smooth_nrm); + bwdSafeNormalize(_smooth_tng, d__smooth_tng, d_smooth_tng); + + p.pos.store_grad(px, py, pz, -d__view_vec); + p.view_pos.store_grad(px, py, pz, d__view_vec); + p.perturbed_nrm.store_grad(px, py, pz, d_perturbed_nrm); + p.smooth_nrm.store_grad(px, py, pz, d__smooth_nrm); + p.smooth_tng.store_grad(px, py, pz, d__smooth_tng); + p.geom_nrm.store_grad(px, py, pz, d_geom_nrm); +} \ No newline at end of file diff --git a/render/renderutils/c_src/normal.h b/render/renderutils/c_src/normal.h new file mode 100644 index 0000000..8882c22 --- /dev/null +++ b/render/renderutils/c_src/normal.h @@ -0,0 +1,27 @@ +/* + * Copyright (c) 2020-2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * + * NVIDIA CORPORATION, its affiliates and licensors retain all intellectual + * property and proprietary rights in and to this material, related + * documentation and any modifications thereto. Any use, reproduction, + * disclosure or distribution of this material and related documentation + * without an express license agreement from NVIDIA CORPORATION or + * its affiliates is strictly prohibited. + */ + +#pragma once + +#include "common.h" + +struct PrepareShadingNormalKernelParams +{ + Tensor pos; + Tensor view_pos; + Tensor perturbed_nrm; + Tensor smooth_nrm; + Tensor smooth_tng; + Tensor geom_nrm; + Tensor out; + dim3 gridSize; + bool two_sided_shading, opengl; +}; diff --git a/render/renderutils/c_src/tensor.h b/render/renderutils/c_src/tensor.h new file mode 100644 index 0000000..1dfb4e8 --- /dev/null +++ b/render/renderutils/c_src/tensor.h @@ -0,0 +1,92 @@ +/* + * Copyright (c) 2020-2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * + * NVIDIA CORPORATION, its affiliates and licensors retain all intellectual + * property and proprietary rights in and to this material, related + * documentation and any modifications thereto. Any use, reproduction, + * disclosure or distribution of this material and related documentation + * without an express license agreement from NVIDIA CORPORATION or + * its affiliates is strictly prohibited. + */ + +#pragma once +#if defined(__CUDACC__) && defined(BFLOAT16) +#include // bfloat16 is float32 compatible with less mantissa bits +#endif + +//--------------------------------------------------------------------------------- +// CUDA-side Tensor class for in/out parameter parsing. Can be float32 or bfloat16 + +struct Tensor +{ + void* val; + void* d_val; + int dims[4], _dims[4]; + int strides[4]; + bool fp16; + +#if defined(__CUDA__) && !defined(__CUDA_ARCH__) + Tensor() : val(nullptr), d_val(nullptr), fp16(true), dims{ 0, 0, 0, 0 }, _dims{ 0, 0, 0, 0 }, strides{ 0, 0, 0, 0 } {} +#endif + +#ifdef __CUDACC__ + // Helpers to index and read/write a single element + __device__ inline int _nhwcIndex(int n, int h, int w, int c) const { return n * strides[0] + h * strides[1] + w * strides[2] + c * strides[3]; } + __device__ inline int nhwcIndex(int n, int h, int w, int c) const { return (dims[0] == 1 ? 0 : n * strides[0]) + (dims[1] == 1 ? 0 : h * strides[1]) + (dims[2] == 1 ? 0 : w * strides[2]) + (dims[3] == 1 ? 0 : c * strides[3]); } + __device__ inline int nhwcIndexContinuous(int n, int h, int w, int c) const { return ((n * _dims[1] + h) * _dims[2] + w) * _dims[3] + c; } +#ifdef BFLOAT16 + __device__ inline float fetch(unsigned int idx) const { return fp16 ? __bfloat162float(((__nv_bfloat16*)val)[idx]) : ((float*)val)[idx]; } + __device__ inline void store(unsigned int idx, float _val) { if (fp16) ((__nv_bfloat16*)val)[idx] = __float2bfloat16(_val); else ((float*)val)[idx] = _val; } + __device__ inline void store_grad(unsigned int idx, float _val) { if (fp16) ((__nv_bfloat16*)d_val)[idx] = __float2bfloat16(_val); else ((float*)d_val)[idx] = _val; } +#else + __device__ inline float fetch(unsigned int idx) const { return ((float*)val)[idx]; } + __device__ inline void store(unsigned int idx, float _val) { ((float*)val)[idx] = _val; } + __device__ inline void store_grad(unsigned int idx, float _val) { ((float*)d_val)[idx] = _val; } +#endif + + ////////////////////////////////////////////////////////////////////////////////////////// + // Fetch, use broadcasting for tensor dimensions of size 1 + __device__ inline float fetch1(unsigned int x, unsigned int y, unsigned int z) const + { + return fetch(nhwcIndex(z, y, x, 0)); + } + + __device__ inline vec3f fetch3(unsigned int x, unsigned int y, unsigned int z) const + { + return vec3f( + fetch(nhwcIndex(z, y, x, 0)), + fetch(nhwcIndex(z, y, x, 1)), + fetch(nhwcIndex(z, y, x, 2)) + ); + } + + ///////////////////////////////////////////////////////////////////////////////////////////////////////////// + // Store, no broadcasting here. Assume we output full res gradient and then reduce using torch.sum outside + __device__ inline void store(unsigned int x, unsigned int y, unsigned int z, float _val) + { + store(_nhwcIndex(z, y, x, 0), _val); + } + + __device__ inline void store(unsigned int x, unsigned int y, unsigned int z, vec3f _val) + { + store(_nhwcIndex(z, y, x, 0), _val.x); + store(_nhwcIndex(z, y, x, 1), _val.y); + store(_nhwcIndex(z, y, x, 2), _val.z); + } + + ///////////////////////////////////////////////////////////////////////////////////////////////////////////// + // Store gradient , no broadcasting here. Assume we output full res gradient and then reduce using torch.sum outside + __device__ inline void store_grad(unsigned int x, unsigned int y, unsigned int z, float _val) + { + store_grad(nhwcIndexContinuous(z, y, x, 0), _val); + } + + __device__ inline void store_grad(unsigned int x, unsigned int y, unsigned int z, vec3f _val) + { + store_grad(nhwcIndexContinuous(z, y, x, 0), _val.x); + store_grad(nhwcIndexContinuous(z, y, x, 1), _val.y); + store_grad(nhwcIndexContinuous(z, y, x, 2), _val.z); + } +#endif + +}; diff --git a/render/renderutils/c_src/torch_bindings.cpp b/render/renderutils/c_src/torch_bindings.cpp new file mode 100644 index 0000000..64c9e70 --- /dev/null +++ b/render/renderutils/c_src/torch_bindings.cpp @@ -0,0 +1,1062 @@ +/* + * Copyright (c) 2020-2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * + * NVIDIA CORPORATION, its affiliates and licensors retain all intellectual + * property and proprietary rights in and to this material, related + * documentation and any modifications thereto. Any use, reproduction, + * disclosure or distribution of this material and related documentation + * without an express license agreement from NVIDIA CORPORATION or + * its affiliates is strictly prohibited. + */ + +#ifdef _MSC_VER +#pragma warning(push, 0) +#include +#pragma warning(pop) +#else +#include +#endif + +#include +#include +#include +#include + +#define NVDR_CHECK_CUDA_ERROR(CUDA_CALL) { cudaError_t err = CUDA_CALL; AT_CUDA_CHECK(cudaGetLastError()); } +#define NVDR_CHECK_GL_ERROR(GL_CALL) { GL_CALL; GLenum err = glGetError(); TORCH_CHECK(err == GL_NO_ERROR, "OpenGL error: ", getGLErrorString(err), "[", #GL_CALL, ";]"); } +#define CHECK_TENSOR(X, DIMS, CHANNELS) \ + TORCH_CHECK(X.is_cuda(), #X " must be a cuda tensor") \ + TORCH_CHECK(X.scalar_type() == torch::kFloat || X.scalar_type() == torch::kBFloat16, #X " must be fp32 or bf16") \ + TORCH_CHECK(X.dim() == DIMS, #X " must have " #DIMS " dimensions") \ + TORCH_CHECK(X.size(DIMS - 1) == CHANNELS, #X " must have " #CHANNELS " channels") + +#include "common.h" +#include "loss.h" +#include "normal.h" +#include "cubemap.h" +#include "bsdf.h" +#include "mesh.h" + +#define BLOCK_X 8 +#define BLOCK_Y 8 + +//------------------------------------------------------------------------ +// mesh.cu + +void xfmPointsFwdKernel(XfmKernelParams p); +void xfmPointsBwdKernel(XfmKernelParams p); + +//------------------------------------------------------------------------ +// loss.cu + +void imgLossFwdKernel(LossKernelParams p); +void imgLossBwdKernel(LossKernelParams p); + +//------------------------------------------------------------------------ +// normal.cu + +void PrepareShadingNormalFwdKernel(PrepareShadingNormalKernelParams p); +void PrepareShadingNormalBwdKernel(PrepareShadingNormalKernelParams p); + +//------------------------------------------------------------------------ +// cubemap.cu + +void DiffuseCubemapFwdKernel(DiffuseCubemapKernelParams p); +void DiffuseCubemapBwdKernel(DiffuseCubemapKernelParams p); +void SpecularBoundsKernel(SpecularBoundsKernelParams p); +void SpecularCubemapFwdKernel(SpecularCubemapKernelParams p); +void SpecularCubemapBwdKernel(SpecularCubemapKernelParams p); + +//------------------------------------------------------------------------ +// bsdf.cu + +void LambertFwdKernel(LambertKernelParams p); +void LambertBwdKernel(LambertKernelParams p); + +void FrostbiteDiffuseFwdKernel(FrostbiteDiffuseKernelParams p); +void FrostbiteDiffuseBwdKernel(FrostbiteDiffuseKernelParams p); + +void FresnelShlickFwdKernel(FresnelShlickKernelParams p); +void FresnelShlickBwdKernel(FresnelShlickKernelParams p); + +void ndfGGXFwdKernel(NdfGGXParams p); +void ndfGGXBwdKernel(NdfGGXParams p); + +void lambdaGGXFwdKernel(NdfGGXParams p); +void lambdaGGXBwdKernel(NdfGGXParams p); + +void maskingSmithFwdKernel(MaskingSmithParams p); +void maskingSmithBwdKernel(MaskingSmithParams p); + +void pbrSpecularFwdKernel(PbrSpecular p); +void pbrSpecularBwdKernel(PbrSpecular p); + +void pbrBSDFFwdKernel(PbrBSDF p); +void pbrBSDFBwdKernel(PbrBSDF p); + +//------------------------------------------------------------------------ +// Tensor helpers + +void update_grid(dim3 &gridSize, torch::Tensor x) +{ + gridSize.x = std::max(gridSize.x, (uint32_t)x.size(2)); + gridSize.y = std::max(gridSize.y, (uint32_t)x.size(1)); + gridSize.z = std::max(gridSize.z, (uint32_t)x.size(0)); +} + +template +void update_grid(dim3& gridSize, torch::Tensor x, Ts&&... vs) +{ + gridSize.x = std::max(gridSize.x, (uint32_t)x.size(2)); + gridSize.y = std::max(gridSize.y, (uint32_t)x.size(1)); + gridSize.z = std::max(gridSize.z, (uint32_t)x.size(0)); + update_grid(gridSize, std::forward(vs)...); +} + +Tensor make_cuda_tensor(torch::Tensor val) +{ + Tensor res; + for (int i = 0; i < val.dim(); ++i) + { + res.dims[i] = val.size(i); + res.strides[i] = val.stride(i); + } + res.fp16 = val.scalar_type() == torch::kBFloat16; + res.val = res.fp16 ? (void*)val.data_ptr() : (void*)val.data_ptr(); + res.d_val = nullptr; + return res; +} + +Tensor make_cuda_tensor(torch::Tensor val, dim3 outDims, torch::Tensor* grad = nullptr) +{ + Tensor res; + for (int i = 0; i < val.dim(); ++i) + { + res.dims[i] = val.size(i); + res.strides[i] = val.stride(i); + } + if (val.dim() == 4) + res._dims[0] = outDims.z, res._dims[1] = outDims.y, res._dims[2] = outDims.x, res._dims[3] = val.size(3); + else + res._dims[0] = outDims.z, res._dims[1] = outDims.x, res._dims[2] = val.size(2), res._dims[3] = 1; // Add a trailing one for indexing math to work out + + res.fp16 = val.scalar_type() == torch::kBFloat16; + res.val = res.fp16 ? (void*)val.data_ptr() : (void*)val.data_ptr(); + res.d_val = nullptr; + if (grad != nullptr) + { + if (val.dim() == 4) + *grad = torch::empty({ outDims.z, outDims.y, outDims.x, val.size(3) }, torch::TensorOptions().dtype(res.fp16 ? torch::kBFloat16 : torch::kFloat32).device(torch::kCUDA)); + else // 3 + *grad = torch::empty({ outDims.z, outDims.x, val.size(2) }, torch::TensorOptions().dtype(res.fp16 ? torch::kBFloat16 : torch::kFloat32).device(torch::kCUDA)); + + res.d_val = res.fp16 ? (void*)grad->data_ptr() : (void*)grad->data_ptr(); + } + return res; +} + +//------------------------------------------------------------------------ +// prepare_shading_normal + +torch::Tensor prepare_shading_normal_fwd(torch::Tensor pos, torch::Tensor view_pos, torch::Tensor perturbed_nrm, torch::Tensor smooth_nrm, torch::Tensor smooth_tng, torch::Tensor geom_nrm, bool two_sided_shading, bool opengl, bool fp16) +{ + CHECK_TENSOR(pos, 4, 3); + CHECK_TENSOR(view_pos, 4, 3); + CHECK_TENSOR(perturbed_nrm, 4, 3); + CHECK_TENSOR(smooth_nrm, 4, 3); + CHECK_TENSOR(smooth_tng, 4, 3); + CHECK_TENSOR(geom_nrm, 4, 3); + + cudaStream_t stream = at::cuda::getCurrentCUDAStream(); + + // Extract input parameters. + PrepareShadingNormalKernelParams p; + p.two_sided_shading = two_sided_shading; + p.opengl = opengl; + p.out.fp16 = fp16; + update_grid(p.gridSize, pos, view_pos, perturbed_nrm, smooth_nrm, smooth_tng, geom_nrm); + + // Allocate output tensors. + torch::TensorOptions opts = torch::TensorOptions().dtype(p.out.fp16 ? torch::kBFloat16 : torch::kFloat32).device(torch::kCUDA); + torch::Tensor out = torch::empty({ p.gridSize.z, p.gridSize.y, p.gridSize.x, 3 }, opts); + + // Choose launch parameters. + dim3 blockSize = getLaunchBlockSize(BLOCK_X, BLOCK_Y, p.gridSize); + dim3 gridSize = getLaunchGridSize(blockSize, p.gridSize); + + // Setup tensors + p.pos = make_cuda_tensor(pos, p.gridSize); + p.view_pos = make_cuda_tensor(view_pos, p.gridSize); + p.perturbed_nrm = make_cuda_tensor(perturbed_nrm, p.gridSize); + p.smooth_nrm = make_cuda_tensor(smooth_nrm, p.gridSize); + p.smooth_tng = make_cuda_tensor(smooth_tng, p.gridSize); + p.geom_nrm = make_cuda_tensor(geom_nrm, p.gridSize); + p.out = make_cuda_tensor(out, p.gridSize); + + // Launch CUDA kernel. + void* args[] = { &p }; + NVDR_CHECK_CUDA_ERROR(cudaLaunchKernel((const void*)PrepareShadingNormalFwdKernel, gridSize, blockSize, args, 0, stream)); + + return out; +} + +std::tuple prepare_shading_normal_bwd(torch::Tensor pos, torch::Tensor view_pos, torch::Tensor perturbed_nrm, torch::Tensor smooth_nrm, torch::Tensor smooth_tng, torch::Tensor geom_nrm, torch::Tensor grad, bool two_sided_shading, bool opengl) +{ + cudaStream_t stream = at::cuda::getCurrentCUDAStream(); + + // Extract input parameters. + PrepareShadingNormalKernelParams p; + p.two_sided_shading = two_sided_shading; + p.opengl = opengl; + update_grid(p.gridSize, pos, view_pos, perturbed_nrm, smooth_nrm, smooth_tng, geom_nrm); + + // Choose launch parameters. + dim3 blockSize = getLaunchBlockSize(BLOCK_X, BLOCK_Y, p.gridSize); + dim3 gridSize = getLaunchGridSize(blockSize, p.gridSize); + + // Setup tensors + torch::Tensor pos_grad, view_pos_grad, perturbed_nrm_grad, smooth_nrm_grad, smooth_tng_grad, geom_nrm_grad; + p.pos = make_cuda_tensor(pos, p.gridSize, &pos_grad); + p.view_pos = make_cuda_tensor(view_pos, p.gridSize, &view_pos_grad); + p.perturbed_nrm = make_cuda_tensor(perturbed_nrm, p.gridSize, &perturbed_nrm_grad); + p.smooth_nrm = make_cuda_tensor(smooth_nrm, p.gridSize, &smooth_nrm_grad); + p.smooth_tng = make_cuda_tensor(smooth_tng, p.gridSize, &smooth_tng_grad); + p.geom_nrm = make_cuda_tensor(geom_nrm, p.gridSize, &geom_nrm_grad); + p.out = make_cuda_tensor(grad, p.gridSize); + + // Launch CUDA kernel. + void* args[] = { &p }; + NVDR_CHECK_CUDA_ERROR(cudaLaunchKernel((const void*)PrepareShadingNormalBwdKernel, gridSize, blockSize, args, 0, stream)); + + return std::tuple(pos_grad, view_pos_grad, perturbed_nrm_grad, smooth_nrm_grad, smooth_tng_grad, geom_nrm_grad); +} + +//------------------------------------------------------------------------ +// lambert + +torch::Tensor lambert_fwd(torch::Tensor nrm, torch::Tensor wi, bool fp16) +{ + CHECK_TENSOR(nrm, 4, 3); + CHECK_TENSOR(wi, 4, 3); + + cudaStream_t stream = at::cuda::getCurrentCUDAStream(); + + // Extract input parameters. + LambertKernelParams p; + p.out.fp16 = fp16; + update_grid(p.gridSize, nrm, wi); + + // Allocate output tensors. + torch::TensorOptions opts = torch::TensorOptions().dtype(p.out.fp16 ? torch::kBFloat16 : torch::kFloat32).device(torch::kCUDA); + torch::Tensor out = torch::empty({ p.gridSize.z, p.gridSize.y, p.gridSize.x, 1 }, opts); + + // Choose launch parameters. + dim3 blockSize = getLaunchBlockSize(BLOCK_X, BLOCK_Y, p.gridSize); + dim3 gridSize = getLaunchGridSize(blockSize, p.gridSize); + + p.nrm = make_cuda_tensor(nrm, p.gridSize); + p.wi = make_cuda_tensor(wi, p.gridSize); + p.out = make_cuda_tensor(out, p.gridSize); + + // Launch CUDA kernel. + void* args[] = { &p }; + NVDR_CHECK_CUDA_ERROR(cudaLaunchKernel((const void*)LambertFwdKernel, gridSize, blockSize, args, 0, stream)); + + return out; +} + +std::tuple lambert_bwd(torch::Tensor nrm, torch::Tensor wi, torch::Tensor grad) +{ + cudaStream_t stream = at::cuda::getCurrentCUDAStream(); + + // Extract input parameters. + LambertKernelParams p; + update_grid(p.gridSize, nrm, wi); + + // Choose launch parameters. + dim3 blockSize = getLaunchBlockSize(BLOCK_X, BLOCK_Y, p.gridSize); + dim3 gridSize = getLaunchGridSize(blockSize, p.gridSize); + + torch::Tensor nrm_grad, wi_grad; + p.nrm = make_cuda_tensor(nrm, p.gridSize, &nrm_grad); + p.wi = make_cuda_tensor(wi, p.gridSize, &wi_grad); + p.out = make_cuda_tensor(grad, p.gridSize); + + // Launch CUDA kernel. + void* args[] = { &p }; + NVDR_CHECK_CUDA_ERROR(cudaLaunchKernel((const void*)LambertBwdKernel, gridSize, blockSize, args, 0, stream)); + + return std::tuple(nrm_grad, wi_grad); +} + +//------------------------------------------------------------------------ +// frostbite diffuse + +torch::Tensor frostbite_fwd(torch::Tensor nrm, torch::Tensor wi, torch::Tensor wo, torch::Tensor linearRoughness, bool fp16) +{ + CHECK_TENSOR(nrm, 4, 3); + CHECK_TENSOR(wi, 4, 3); + CHECK_TENSOR(wo, 4, 3); + CHECK_TENSOR(linearRoughness, 4, 1); + + cudaStream_t stream = at::cuda::getCurrentCUDAStream(); + + // Extract input parameters. + FrostbiteDiffuseKernelParams p; + p.out.fp16 = fp16; + update_grid(p.gridSize, nrm, wi, wo, linearRoughness); + + // Allocate output tensors. + torch::TensorOptions opts = torch::TensorOptions().dtype(p.out.fp16 ? torch::kBFloat16 : torch::kFloat32).device(torch::kCUDA); + torch::Tensor out = torch::empty({ p.gridSize.z, p.gridSize.y, p.gridSize.x, 1 }, opts); + + // Choose launch parameters. + dim3 blockSize = getLaunchBlockSize(BLOCK_X, BLOCK_Y, p.gridSize); + dim3 gridSize = getLaunchGridSize(blockSize, p.gridSize); + + p.nrm = make_cuda_tensor(nrm, p.gridSize); + p.wi = make_cuda_tensor(wi, p.gridSize); + p.wo = make_cuda_tensor(wo, p.gridSize); + p.linearRoughness = make_cuda_tensor(linearRoughness, p.gridSize); + p.out = make_cuda_tensor(out, p.gridSize); + + // Launch CUDA kernel. + void* args[] = { &p }; + NVDR_CHECK_CUDA_ERROR(cudaLaunchKernel((const void*)FrostbiteDiffuseFwdKernel, gridSize, blockSize, args, 0, stream)); + + return out; +} + +std::tuple frostbite_bwd(torch::Tensor nrm, torch::Tensor wi, torch::Tensor wo, torch::Tensor linearRoughness, torch::Tensor grad) +{ + cudaStream_t stream = at::cuda::getCurrentCUDAStream(); + + // Extract input parameters. + FrostbiteDiffuseKernelParams p; + update_grid(p.gridSize, nrm, wi, wo, linearRoughness); + + // Choose launch parameters. + dim3 blockSize = getLaunchBlockSize(BLOCK_X, BLOCK_Y, p.gridSize); + dim3 gridSize = getLaunchGridSize(blockSize, p.gridSize); + + torch::Tensor nrm_grad, wi_grad, wo_grad, linearRoughness_grad; + p.nrm = make_cuda_tensor(nrm, p.gridSize, &nrm_grad); + p.wi = make_cuda_tensor(wi, p.gridSize, &wi_grad); + p.wo = make_cuda_tensor(wo, p.gridSize, &wo_grad); + p.linearRoughness = make_cuda_tensor(linearRoughness, p.gridSize, &linearRoughness_grad); + p.out = make_cuda_tensor(grad, p.gridSize); + + // Launch CUDA kernel. + void* args[] = { &p }; + NVDR_CHECK_CUDA_ERROR(cudaLaunchKernel((const void*)FrostbiteDiffuseBwdKernel, gridSize, blockSize, args, 0, stream)); + + return std::tuple(nrm_grad, wi_grad, wo_grad, linearRoughness_grad); +} + +//------------------------------------------------------------------------ +// fresnel_shlick + +torch::Tensor fresnel_shlick_fwd(torch::Tensor f0, torch::Tensor f90, torch::Tensor cosTheta, bool fp16) +{ + CHECK_TENSOR(f0, 4, 3); + CHECK_TENSOR(f90, 4, 3); + CHECK_TENSOR(cosTheta, 4, 1); + + cudaStream_t stream = at::cuda::getCurrentCUDAStream(); + + // Extract input parameters. + FresnelShlickKernelParams p; + p.out.fp16 = fp16; + update_grid(p.gridSize, f0, f90, cosTheta); + + // Allocate output tensors. + torch::TensorOptions opts = torch::TensorOptions().dtype(p.out.fp16 ? torch::kBFloat16 : torch::kFloat32).device(torch::kCUDA); + torch::Tensor out = torch::empty({ p.gridSize.z, p.gridSize.y, p.gridSize.x, 3 }, opts); + + // Choose launch parameters. + dim3 blockSize = getLaunchBlockSize(BLOCK_X, BLOCK_Y, p.gridSize); + dim3 gridSize = getLaunchGridSize(blockSize, p.gridSize); + + p.f0 = make_cuda_tensor(f0, p.gridSize); + p.f90 = make_cuda_tensor(f90, p.gridSize); + p.cosTheta = make_cuda_tensor(cosTheta, p.gridSize); + p.out = make_cuda_tensor(out, p.gridSize); + + // Launch CUDA kernel. + void* args[] = { &p }; + NVDR_CHECK_CUDA_ERROR(cudaLaunchKernel((const void*)FresnelShlickFwdKernel, gridSize, blockSize, args, 0, stream)); + + return out; +} + +std::tuple fresnel_shlick_bwd(torch::Tensor f0, torch::Tensor f90, torch::Tensor cosTheta, torch::Tensor grad) +{ + cudaStream_t stream = at::cuda::getCurrentCUDAStream(); + + // Extract input parameters. + FresnelShlickKernelParams p; + update_grid(p.gridSize, f0, f90, cosTheta); + + // Choose launch parameters. + dim3 blockSize = getLaunchBlockSize(BLOCK_X, BLOCK_Y, p.gridSize); + dim3 gridSize = getLaunchGridSize(blockSize, p.gridSize); + + torch::Tensor f0_grad, f90_grad, cosT_grad; + p.f0 = make_cuda_tensor(f0, p.gridSize, &f0_grad); + p.f90 = make_cuda_tensor(f90, p.gridSize, &f90_grad); + p.cosTheta = make_cuda_tensor(cosTheta, p.gridSize, &cosT_grad); + p.out = make_cuda_tensor(grad, p.gridSize); + + // Launch CUDA kernel. + void* args[] = { &p }; + NVDR_CHECK_CUDA_ERROR(cudaLaunchKernel((const void*)FresnelShlickBwdKernel, gridSize, blockSize, args, 0, stream)); + + return std::tuple(f0_grad, f90_grad, cosT_grad); +} + +//------------------------------------------------------------------------ +// ndf_ggd + +torch::Tensor ndf_ggx_fwd(torch::Tensor alphaSqr, torch::Tensor cosTheta, bool fp16) +{ + CHECK_TENSOR(alphaSqr, 4, 1); + CHECK_TENSOR(cosTheta, 4, 1); + + cudaStream_t stream = at::cuda::getCurrentCUDAStream(); + + // Extract input parameters. + NdfGGXParams p; + p.out.fp16 = fp16; + update_grid(p.gridSize, alphaSqr, cosTheta); + + // Allocate output tensors. + torch::TensorOptions opts = torch::TensorOptions().dtype(p.out.fp16 ? torch::kBFloat16 : torch::kFloat32).device(torch::kCUDA); + torch::Tensor out = torch::empty({ p.gridSize.z, p.gridSize.y, p.gridSize.x, 1 }, opts); + + // Choose launch parameters. + dim3 blockSize = getLaunchBlockSize(BLOCK_X, BLOCK_Y, p.gridSize); + dim3 gridSize = getLaunchGridSize(blockSize, p.gridSize); + + p.alphaSqr = make_cuda_tensor(alphaSqr, p.gridSize); + p.cosTheta = make_cuda_tensor(cosTheta, p.gridSize); + p.out = make_cuda_tensor(out, p.gridSize); + + // Launch CUDA kernel. + void* args[] = { &p }; + NVDR_CHECK_CUDA_ERROR(cudaLaunchKernel((const void*)ndfGGXFwdKernel, gridSize, blockSize, args, 0, stream)); + + return out; +} + +std::tuple ndf_ggx_bwd(torch::Tensor alphaSqr, torch::Tensor cosTheta, torch::Tensor grad) +{ + cudaStream_t stream = at::cuda::getCurrentCUDAStream(); + + // Extract input parameters. + NdfGGXParams p; + update_grid(p.gridSize, alphaSqr, cosTheta); + + // Choose launch parameters. + dim3 blockSize = getLaunchBlockSize(BLOCK_X, BLOCK_Y, p.gridSize); + dim3 gridSize = getLaunchGridSize(blockSize, p.gridSize); + + torch::Tensor alphaSqr_grad, cosTheta_grad; + p.alphaSqr = make_cuda_tensor(alphaSqr, p.gridSize, &alphaSqr_grad); + p.cosTheta = make_cuda_tensor(cosTheta, p.gridSize, &cosTheta_grad); + p.out = make_cuda_tensor(grad, p.gridSize); + + // Launch CUDA kernel. + void* args[] = { &p }; + NVDR_CHECK_CUDA_ERROR(cudaLaunchKernel((const void*)ndfGGXBwdKernel, gridSize, blockSize, args, 0, stream)); + + return std::tuple(alphaSqr_grad, cosTheta_grad); +} + +//------------------------------------------------------------------------ +// lambda_ggx + +torch::Tensor lambda_ggx_fwd(torch::Tensor alphaSqr, torch::Tensor cosTheta, bool fp16) +{ + CHECK_TENSOR(alphaSqr, 4, 1); + CHECK_TENSOR(cosTheta, 4, 1); + + cudaStream_t stream = at::cuda::getCurrentCUDAStream(); + + // Extract input parameters. + NdfGGXParams p; + p.out.fp16 = fp16; + update_grid(p.gridSize, alphaSqr, cosTheta); + + // Allocate output tensors. + torch::TensorOptions opts = torch::TensorOptions().dtype(p.out.fp16 ? torch::kBFloat16 : torch::kFloat32).device(torch::kCUDA); + torch::Tensor out = torch::empty({ p.gridSize.z, p.gridSize.y, p.gridSize.x, 1 }, opts); + + // Choose launch parameters. + dim3 blockSize = getLaunchBlockSize(BLOCK_X, BLOCK_Y, p.gridSize); + dim3 gridSize = getLaunchGridSize(blockSize, p.gridSize); + + p.alphaSqr = make_cuda_tensor(alphaSqr, p.gridSize); + p.cosTheta = make_cuda_tensor(cosTheta, p.gridSize); + p.out = make_cuda_tensor(out, p.gridSize); + + // Launch CUDA kernel. + void* args[] = { &p }; + NVDR_CHECK_CUDA_ERROR(cudaLaunchKernel((const void*)lambdaGGXFwdKernel, gridSize, blockSize, args, 0, stream)); + + return out; +} + +std::tuple lambda_ggx_bwd(torch::Tensor alphaSqr, torch::Tensor cosTheta, torch::Tensor grad) +{ + cudaStream_t stream = at::cuda::getCurrentCUDAStream(); + + // Extract input parameters. + NdfGGXParams p; + update_grid(p.gridSize, alphaSqr, cosTheta); + + // Choose launch parameters. + dim3 blockSize = getLaunchBlockSize(BLOCK_X, BLOCK_Y, p.gridSize); + dim3 gridSize = getLaunchGridSize(blockSize, p.gridSize); + + torch::Tensor alphaSqr_grad, cosTheta_grad; + p.alphaSqr = make_cuda_tensor(alphaSqr, p.gridSize, &alphaSqr_grad); + p.cosTheta = make_cuda_tensor(cosTheta, p.gridSize, &cosTheta_grad); + p.out = make_cuda_tensor(grad, p.gridSize); + + // Launch CUDA kernel. + void* args[] = { &p }; + NVDR_CHECK_CUDA_ERROR(cudaLaunchKernel((const void*)lambdaGGXBwdKernel, gridSize, blockSize, args, 0, stream)); + + return std::tuple(alphaSqr_grad, cosTheta_grad); +} + +//------------------------------------------------------------------------ +// masking_smith + +torch::Tensor masking_smith_fwd(torch::Tensor alphaSqr, torch::Tensor cosThetaI, torch::Tensor cosThetaO, bool fp16) +{ + CHECK_TENSOR(alphaSqr, 4, 1); + CHECK_TENSOR(cosThetaI, 4, 1); + CHECK_TENSOR(cosThetaO, 4, 1); + + cudaStream_t stream = at::cuda::getCurrentCUDAStream(); + + // Extract input parameters. + MaskingSmithParams p; + p.out.fp16 = fp16; + update_grid(p.gridSize, alphaSqr, cosThetaI, cosThetaO); + + // Allocate output tensors. + torch::TensorOptions opts = torch::TensorOptions().dtype(p.out.fp16 ? torch::kBFloat16 : torch::kFloat32).device(torch::kCUDA); + torch::Tensor out = torch::empty({ p.gridSize.z, p.gridSize.y, p.gridSize.x, 1 }, opts); + + // Choose launch parameters. + dim3 blockSize = getLaunchBlockSize(BLOCK_X, BLOCK_Y, p.gridSize); + dim3 gridSize = getLaunchGridSize(blockSize, p.gridSize); + + p.alphaSqr = make_cuda_tensor(alphaSqr, p.gridSize); + p.cosThetaI = make_cuda_tensor(cosThetaI, p.gridSize); + p.cosThetaO = make_cuda_tensor(cosThetaO, p.gridSize); + p.out = make_cuda_tensor(out, p.gridSize); + + // Launch CUDA kernel. + void* args[] = { &p }; + NVDR_CHECK_CUDA_ERROR(cudaLaunchKernel((const void*)maskingSmithFwdKernel, gridSize, blockSize, args, 0, stream)); + + return out; +} + +std::tuple masking_smith_bwd(torch::Tensor alphaSqr, torch::Tensor cosThetaI, torch::Tensor cosThetaO, torch::Tensor grad) +{ + cudaStream_t stream = at::cuda::getCurrentCUDAStream(); + + // Extract input parameters. + MaskingSmithParams p; + update_grid(p.gridSize, alphaSqr, cosThetaI, cosThetaO); + + // Choose launch parameters. + dim3 blockSize = getLaunchBlockSize(BLOCK_X, BLOCK_Y, p.gridSize); + dim3 gridSize = getLaunchGridSize(blockSize, p.gridSize); + + torch::Tensor alphaSqr_grad, cosThetaI_grad, cosThetaO_grad; + p.alphaSqr = make_cuda_tensor(alphaSqr, p.gridSize, &alphaSqr_grad); + p.cosThetaI = make_cuda_tensor(cosThetaI, p.gridSize, &cosThetaI_grad); + p.cosThetaO = make_cuda_tensor(cosThetaO, p.gridSize, &cosThetaO_grad); + p.out = make_cuda_tensor(grad, p.gridSize); + + // Launch CUDA kernel. + void* args[] = { &p }; + NVDR_CHECK_CUDA_ERROR(cudaLaunchKernel((const void*)maskingSmithBwdKernel, gridSize, blockSize, args, 0, stream)); + + return std::tuple(alphaSqr_grad, cosThetaI_grad, cosThetaO_grad); +} + +//------------------------------------------------------------------------ +// pbr_specular + +torch::Tensor pbr_specular_fwd(torch::Tensor col, torch::Tensor nrm, torch::Tensor wo, torch::Tensor wi, torch::Tensor alpha, float min_roughness, bool fp16) +{ + CHECK_TENSOR(col, 4, 3); + CHECK_TENSOR(nrm, 4, 3); + CHECK_TENSOR(wo, 4, 3); + CHECK_TENSOR(wi, 4, 3); + CHECK_TENSOR(alpha, 4, 1); + + cudaStream_t stream = at::cuda::getCurrentCUDAStream(); + + // Extract input parameters. + PbrSpecular p; + p.out.fp16 = fp16; + p.min_roughness = min_roughness; + update_grid(p.gridSize, col, nrm, wo, wi, alpha); + + // Allocate output tensors. + torch::TensorOptions opts = torch::TensorOptions().dtype(p.out.fp16 ? torch::kBFloat16 : torch::kFloat32).device(torch::kCUDA); + torch::Tensor out = torch::empty({ p.gridSize.z, p.gridSize.y, p.gridSize.x, 3 }, opts); + + // Choose launch parameters. + dim3 blockSize = getLaunchBlockSize(BLOCK_X, BLOCK_Y, p.gridSize); + dim3 gridSize = getLaunchGridSize(blockSize, p.gridSize); + + p.col = make_cuda_tensor(col, p.gridSize); + p.nrm = make_cuda_tensor(nrm, p.gridSize); + p.wo = make_cuda_tensor(wo, p.gridSize); + p.wi = make_cuda_tensor(wi, p.gridSize); + p.alpha = make_cuda_tensor(alpha, p.gridSize); + p.out = make_cuda_tensor(out, p.gridSize); + + // Launch CUDA kernel. + void* args[] = { &p }; + NVDR_CHECK_CUDA_ERROR(cudaLaunchKernel((const void*)pbrSpecularFwdKernel, gridSize, blockSize, args, 0, stream)); + + return out; +} + +std::tuple pbr_specular_bwd(torch::Tensor col, torch::Tensor nrm, torch::Tensor wo, torch::Tensor wi, torch::Tensor alpha, float min_roughness, torch::Tensor grad) +{ + cudaStream_t stream = at::cuda::getCurrentCUDAStream(); + + // Extract input parameters. + PbrSpecular p; + update_grid(p.gridSize, col, nrm, wo, wi, alpha); + p.min_roughness = min_roughness; + + // Choose launch parameters. + dim3 blockSize = getLaunchBlockSize(BLOCK_X, BLOCK_Y, p.gridSize); + dim3 gridSize = getLaunchGridSize(blockSize, p.gridSize); + + torch::Tensor col_grad, nrm_grad, wo_grad, wi_grad, alpha_grad; + p.col = make_cuda_tensor(col, p.gridSize, &col_grad); + p.nrm = make_cuda_tensor(nrm, p.gridSize, &nrm_grad); + p.wo = make_cuda_tensor(wo, p.gridSize, &wo_grad); + p.wi = make_cuda_tensor(wi, p.gridSize, &wi_grad); + p.alpha = make_cuda_tensor(alpha, p.gridSize, &alpha_grad); + p.out = make_cuda_tensor(grad, p.gridSize); + + // Launch CUDA kernel. + void* args[] = { &p }; + NVDR_CHECK_CUDA_ERROR(cudaLaunchKernel((const void*)pbrSpecularBwdKernel, gridSize, blockSize, args, 0, stream)); + + return std::tuple(col_grad, nrm_grad, wo_grad, wi_grad, alpha_grad); +} + +//------------------------------------------------------------------------ +// pbr_bsdf + +torch::Tensor pbr_bsdf_fwd(torch::Tensor kd, torch::Tensor arm, torch::Tensor pos, torch::Tensor nrm, torch::Tensor view_pos, torch::Tensor light_pos, float min_roughness, int BSDF, bool fp16) +{ + CHECK_TENSOR(kd, 4, 3); + CHECK_TENSOR(arm, 4, 3); + CHECK_TENSOR(pos, 4, 3); + CHECK_TENSOR(nrm, 4, 3); + CHECK_TENSOR(view_pos, 4, 3); + CHECK_TENSOR(light_pos, 4, 3); + + cudaStream_t stream = at::cuda::getCurrentCUDAStream(); + + // Extract input parameters. + PbrBSDF p; + p.out.fp16 = fp16; + p.min_roughness = min_roughness; + p.BSDF = BSDF; + update_grid(p.gridSize, kd, arm, pos, nrm, view_pos, light_pos); + + // Allocate output tensors. + torch::TensorOptions opts = torch::TensorOptions().dtype(p.out.fp16 ? torch::kBFloat16 : torch::kFloat32).device(torch::kCUDA); + torch::Tensor out = torch::empty({ p.gridSize.z, p.gridSize.y, p.gridSize.x, 3 }, opts); + + // Choose launch parameters. + dim3 blockSize = getLaunchBlockSize(BLOCK_X, BLOCK_Y, p.gridSize); + dim3 gridSize = getLaunchGridSize(blockSize, p.gridSize); + + p.kd = make_cuda_tensor(kd, p.gridSize); + p.arm = make_cuda_tensor(arm, p.gridSize); + p.pos = make_cuda_tensor(pos, p.gridSize); + p.nrm = make_cuda_tensor(nrm, p.gridSize); + p.view_pos = make_cuda_tensor(view_pos, p.gridSize); + p.light_pos = make_cuda_tensor(light_pos, p.gridSize); + p.out = make_cuda_tensor(out, p.gridSize); + + // Launch CUDA kernel. + void* args[] = { &p }; + NVDR_CHECK_CUDA_ERROR(cudaLaunchKernel((const void*)pbrBSDFFwdKernel, gridSize, blockSize, args, 0, stream)); + + return out; +} + +std::tuple pbr_bsdf_bwd(torch::Tensor kd, torch::Tensor arm, torch::Tensor pos, torch::Tensor nrm, torch::Tensor view_pos, torch::Tensor light_pos, float min_roughness, int BSDF, torch::Tensor grad) +{ + cudaStream_t stream = at::cuda::getCurrentCUDAStream(); + + // Extract input parameters. + PbrBSDF p; + update_grid(p.gridSize, kd, arm, pos, nrm, view_pos, light_pos); + p.min_roughness = min_roughness; + p.BSDF = BSDF; + + // Choose launch parameters. + dim3 blockSize = getLaunchBlockSize(BLOCK_X, BLOCK_Y, p.gridSize); + dim3 gridSize = getLaunchGridSize(blockSize, p.gridSize); + + torch::Tensor kd_grad, arm_grad, pos_grad, nrm_grad, view_pos_grad, light_pos_grad; + p.kd = make_cuda_tensor(kd, p.gridSize, &kd_grad); + p.arm = make_cuda_tensor(arm, p.gridSize, &arm_grad); + p.pos = make_cuda_tensor(pos, p.gridSize, &pos_grad); + p.nrm = make_cuda_tensor(nrm, p.gridSize, &nrm_grad); + p.view_pos = make_cuda_tensor(view_pos, p.gridSize, &view_pos_grad); + p.light_pos = make_cuda_tensor(light_pos, p.gridSize, &light_pos_grad); + p.out = make_cuda_tensor(grad, p.gridSize); + + // Launch CUDA kernel. + void* args[] = { &p }; + NVDR_CHECK_CUDA_ERROR(cudaLaunchKernel((const void*)pbrBSDFBwdKernel, gridSize, blockSize, args, 0, stream)); + + return std::tuple(kd_grad, arm_grad, pos_grad, nrm_grad, view_pos_grad, light_pos_grad); +} + +//------------------------------------------------------------------------ +// filter_cubemap + +torch::Tensor diffuse_cubemap_fwd(torch::Tensor cubemap) +{ + CHECK_TENSOR(cubemap, 4, 3); + + cudaStream_t stream = at::cuda::getCurrentCUDAStream(); + + // Extract input parameters. + DiffuseCubemapKernelParams p; + update_grid(p.gridSize, cubemap); + + // Allocate output tensors. + torch::TensorOptions opts = torch::TensorOptions().dtype(torch::kFloat32).device(torch::kCUDA); + torch::Tensor out = torch::empty({ p.gridSize.z, p.gridSize.y, p.gridSize.x, 3 }, opts); + + // Choose launch parameters. + dim3 blockSize = getLaunchBlockSize(BLOCK_X, BLOCK_Y, p.gridSize); + dim3 gridSize = getLaunchGridSize(blockSize, p.gridSize); + + // Setup tensors + p.cubemap = make_cuda_tensor(cubemap, p.gridSize); + p.out = make_cuda_tensor(out, p.gridSize); + + // Launch CUDA kernel. + void* args[] = { &p }; + NVDR_CHECK_CUDA_ERROR(cudaLaunchKernel((const void*)DiffuseCubemapFwdKernel, gridSize, blockSize, args, 0, stream)); + + return out; +} + +torch::Tensor diffuse_cubemap_bwd(torch::Tensor cubemap, torch::Tensor grad) +{ + CHECK_TENSOR(cubemap, 4, 3); + CHECK_TENSOR(grad, 4, 3); + + cudaStream_t stream = at::cuda::getCurrentCUDAStream(); + + // Extract input parameters. + DiffuseCubemapKernelParams p; + update_grid(p.gridSize, cubemap); + + // Choose launch parameters. + dim3 blockSize = getLaunchBlockSize(BLOCK_X, BLOCK_Y, p.gridSize); + dim3 gridSize = getLaunchGridSize(blockSize, p.gridSize); + + // Setup tensors + torch::Tensor cubemap_grad; + p.cubemap = make_cuda_tensor(cubemap, p.gridSize); + p.out = make_cuda_tensor(grad, p.gridSize); + + cubemap_grad = torch::zeros({ p.gridSize.z, p.gridSize.y, p.gridSize.x, cubemap.size(3) }, torch::TensorOptions().dtype(torch::kFloat32).device(torch::kCUDA)); + p.cubemap.d_val = (void*)cubemap_grad.data_ptr(); + + // Launch CUDA kernel. + void* args[] = { &p }; + NVDR_CHECK_CUDA_ERROR(cudaLaunchKernel((const void*)DiffuseCubemapBwdKernel, gridSize, blockSize, args, 0, stream)); + + return cubemap_grad; +} + +torch::Tensor specular_bounds(int resolution, float costheta_cutoff) +{ + cudaStream_t stream = at::cuda::getCurrentCUDAStream(); + + // Extract input parameters. + SpecularBoundsKernelParams p; + p.costheta_cutoff = costheta_cutoff; + p.gridSize = dim3(resolution, resolution, 6); + + // Allocate output tensors. + torch::TensorOptions opts = torch::TensorOptions().dtype(torch::kFloat32).device(torch::kCUDA); + torch::Tensor out = torch::zeros({ p.gridSize.z, p.gridSize.y, p.gridSize.x, 6*4 }, opts); + + // Choose launch parameters. + dim3 blockSize = getLaunchBlockSize(BLOCK_X, BLOCK_Y, p.gridSize); + dim3 gridSize = getLaunchGridSize(blockSize, p.gridSize); + + // Setup tensors + p.out = make_cuda_tensor(out, p.gridSize); + + // Launch CUDA kernel. + void* args[] = { &p }; + NVDR_CHECK_CUDA_ERROR(cudaLaunchKernel((const void*)SpecularBoundsKernel, gridSize, blockSize, args, 0, stream)); + + return out; +} + +torch::Tensor specular_cubemap_fwd(torch::Tensor cubemap, torch::Tensor bounds, float roughness, float costheta_cutoff) +{ + CHECK_TENSOR(cubemap, 4, 3); + CHECK_TENSOR(bounds, 4, 6*4); + + cudaStream_t stream = at::cuda::getCurrentCUDAStream(); + + // Extract input parameters. + SpecularCubemapKernelParams p; + p.roughness = roughness; + p.costheta_cutoff = costheta_cutoff; + update_grid(p.gridSize, cubemap); + + // Allocate output tensors. + torch::TensorOptions opts = torch::TensorOptions().dtype(torch::kFloat32).device(torch::kCUDA); + torch::Tensor out = torch::empty({ p.gridSize.z, p.gridSize.y, p.gridSize.x, 4 }, opts); + + // Choose launch parameters. + dim3 blockSize = getLaunchBlockSize(BLOCK_X, BLOCK_Y, p.gridSize); + dim3 gridSize = getLaunchGridSize(blockSize, p.gridSize); + + // Setup tensors + p.cubemap = make_cuda_tensor(cubemap, p.gridSize); + p.bounds = make_cuda_tensor(bounds, p.gridSize); + p.out = make_cuda_tensor(out, p.gridSize); + + // Launch CUDA kernel. + void* args[] = { &p }; + NVDR_CHECK_CUDA_ERROR(cudaLaunchKernel((const void*)SpecularCubemapFwdKernel, gridSize, blockSize, args, 0, stream)); + + return out; +} + +torch::Tensor specular_cubemap_bwd(torch::Tensor cubemap, torch::Tensor bounds, torch::Tensor grad, float roughness, float costheta_cutoff) +{ + CHECK_TENSOR(cubemap, 4, 3); + CHECK_TENSOR(bounds, 4, 6*4); + + cudaStream_t stream = at::cuda::getCurrentCUDAStream(); + + // Extract input parameters. + SpecularCubemapKernelParams p; + p.roughness = roughness; + p.costheta_cutoff = costheta_cutoff; + update_grid(p.gridSize, cubemap); + + // Choose launch parameters. + dim3 blockSize = getLaunchBlockSize(BLOCK_X, BLOCK_Y, p.gridSize); + dim3 gridSize = getLaunchGridSize(blockSize, p.gridSize); + + // Setup tensors + torch::Tensor cubemap_grad; + p.cubemap = make_cuda_tensor(cubemap, p.gridSize); + p.bounds = make_cuda_tensor(bounds, p.gridSize); + p.out = make_cuda_tensor(grad, p.gridSize); + + cubemap_grad = torch::zeros({ p.gridSize.z, p.gridSize.y, p.gridSize.x, cubemap.size(3) }, torch::TensorOptions().dtype(torch::kFloat32).device(torch::kCUDA)); + p.cubemap.d_val = (void*)cubemap_grad.data_ptr(); + + // Launch CUDA kernel. + void* args[] = { &p }; + NVDR_CHECK_CUDA_ERROR(cudaLaunchKernel((const void*)SpecularCubemapBwdKernel, gridSize, blockSize, args, 0, stream)); + + return cubemap_grad; +} + +//------------------------------------------------------------------------ +// loss function + +LossType strToLoss(std::string str) +{ + if (str == "mse") + return LOSS_MSE; + else if (str == "relmse") + return LOSS_RELMSE; + else if (str == "smape") + return LOSS_SMAPE; + else + return LOSS_L1; +} + +torch::Tensor image_loss_fwd(torch::Tensor img, torch::Tensor target, std::string loss, std::string tonemapper, bool fp16) +{ + CHECK_TENSOR(img, 4, 3); + CHECK_TENSOR(target, 4, 3); + + cudaStream_t stream = at::cuda::getCurrentCUDAStream(); + + // Extract input parameters. + LossKernelParams p; + p.out.fp16 = fp16; + p.loss = strToLoss(loss); + p.tonemapper = tonemapper == "log_srgb" ? TONEMAPPER_LOG_SRGB : TONEMAPPER_NONE; + update_grid(p.gridSize, img, target); + + // Choose launch parameters. + dim3 blockSize = getLaunchBlockSize(BLOCK_X, BLOCK_Y, p.gridSize); + dim3 warpSize = getWarpSize(blockSize); + dim3 gridSize = getLaunchGridSize(blockSize, p.gridSize); + + // Allocate output tensors. + torch::TensorOptions opts = torch::TensorOptions().dtype(p.out.fp16 ? torch::kBFloat16 : torch::kFloat32).device(torch::kCUDA); + torch::Tensor out = torch::empty({ (p.gridSize.z - 1)/ warpSize.z + 1, (p.gridSize.y - 1) / warpSize.y + 1, (p.gridSize.x - 1) / warpSize.x + 1, 1 }, opts); + + p.img = make_cuda_tensor(img, p.gridSize); + p.target = make_cuda_tensor(target, p.gridSize); + p.out = make_cuda_tensor(out, p.gridSize); + + // Launch CUDA kernel. + void* args[] = { &p }; + NVDR_CHECK_CUDA_ERROR(cudaLaunchKernel((const void*)imgLossFwdKernel, gridSize, blockSize, args, 0, stream)); + + return out; +} + +std::tuple image_loss_bwd(torch::Tensor img, torch::Tensor target, torch::Tensor grad, std::string loss, std::string tonemapper) +{ + cudaStream_t stream = at::cuda::getCurrentCUDAStream(); + + // Extract input parameters. + LossKernelParams p; + p.loss = strToLoss(loss); + p.tonemapper = tonemapper == "log_srgb" ? TONEMAPPER_LOG_SRGB : TONEMAPPER_NONE; + update_grid(p.gridSize, img, target); + + // Choose launch parameters. + dim3 blockSize = getLaunchBlockSize(BLOCK_X, BLOCK_Y, p.gridSize); + dim3 warpSize = getWarpSize(blockSize); + dim3 gridSize = getLaunchGridSize(blockSize, p.gridSize); + + torch::Tensor img_grad, target_grad; + p.img = make_cuda_tensor(img, p.gridSize, &img_grad); + p.target = make_cuda_tensor(target, p.gridSize, &target_grad); + p.out = make_cuda_tensor(grad, p.gridSize); + + // Launch CUDA kernel. + void* args[] = { &p }; + NVDR_CHECK_CUDA_ERROR(cudaLaunchKernel((const void*)imgLossBwdKernel, gridSize, blockSize, args, 0, stream)); + + return std::tuple(img_grad, target_grad); +} + +//------------------------------------------------------------------------ +// transform function + +torch::Tensor xfm_fwd(torch::Tensor points, torch::Tensor matrix, bool isPoints, bool fp16) +{ + CHECK_TENSOR(points, 3, 3); + CHECK_TENSOR(matrix, 3, 4); + + cudaStream_t stream = at::cuda::getCurrentCUDAStream(); + + // Extract input parameters. + XfmKernelParams p; + p.out.fp16 = fp16; + p.isPoints = isPoints; + p.gridSize.x = points.size(1); + p.gridSize.y = 1; + p.gridSize.z = std::max(matrix.size(0), points.size(0)); + + // Choose launch parameters. + dim3 blockSize(BLOCK_X * BLOCK_Y, 1, 1); + dim3 warpSize = getWarpSize(blockSize); + dim3 gridSize = getLaunchGridSize(blockSize, p.gridSize); + + // Allocate output tensors. + torch::TensorOptions opts = torch::TensorOptions().dtype(p.out.fp16 ? torch::kBFloat16 : torch::kFloat32).device(torch::kCUDA); + torch::Tensor out = isPoints ? torch::empty({ matrix.size(0), points.size(1), 4 }, opts) : torch::empty({ matrix.size(0), points.size(1), 3 }, opts); + + p.points = make_cuda_tensor(points, p.gridSize); + p.matrix = make_cuda_tensor(matrix, p.gridSize); + p.out = make_cuda_tensor(out, p.gridSize); + + // Launch CUDA kernel. + void* args[] = { &p }; + NVDR_CHECK_CUDA_ERROR(cudaLaunchKernel((const void*)xfmPointsFwdKernel, gridSize, blockSize, args, 0, stream)); + + return out; +} + +torch::Tensor xfm_bwd(torch::Tensor points, torch::Tensor matrix, torch::Tensor grad, bool isPoints) +{ + cudaStream_t stream = at::cuda::getCurrentCUDAStream(); + + // Extract input parameters. + XfmKernelParams p; + p.isPoints = isPoints; + p.gridSize.x = points.size(1); + p.gridSize.y = 1; + p.gridSize.z = std::max(matrix.size(0), points.size(0)); + + // Choose launch parameters. + dim3 blockSize(BLOCK_X * BLOCK_Y, 1, 1); + dim3 warpSize = getWarpSize(blockSize); + dim3 gridSize = getLaunchGridSize(blockSize, p.gridSize); + + torch::Tensor points_grad; + p.points = make_cuda_tensor(points, p.gridSize, &points_grad); + p.matrix = make_cuda_tensor(matrix, p.gridSize); + p.out = make_cuda_tensor(grad, p.gridSize); + + // Launch CUDA kernel. + void* args[] = { &p }; + NVDR_CHECK_CUDA_ERROR(cudaLaunchKernel((const void*)xfmPointsBwdKernel, gridSize, blockSize, args, 0, stream)); + + return points_grad; +} + +PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) { + m.def("prepare_shading_normal_fwd", &prepare_shading_normal_fwd, "prepare_shading_normal_fwd"); + m.def("prepare_shading_normal_bwd", &prepare_shading_normal_bwd, "prepare_shading_normal_bwd"); + m.def("lambert_fwd", &lambert_fwd, "lambert_fwd"); + m.def("lambert_bwd", &lambert_bwd, "lambert_bwd"); + m.def("frostbite_fwd", &frostbite_fwd, "frostbite_fwd"); + m.def("frostbite_bwd", &frostbite_bwd, "frostbite_bwd"); + m.def("fresnel_shlick_fwd", &fresnel_shlick_fwd, "fresnel_shlick_fwd"); + m.def("fresnel_shlick_bwd", &fresnel_shlick_bwd, "fresnel_shlick_bwd"); + m.def("ndf_ggx_fwd", &ndf_ggx_fwd, "ndf_ggx_fwd"); + m.def("ndf_ggx_bwd", &ndf_ggx_bwd, "ndf_ggx_bwd"); + m.def("lambda_ggx_fwd", &lambda_ggx_fwd, "lambda_ggx_fwd"); + m.def("lambda_ggx_bwd", &lambda_ggx_bwd, "lambda_ggx_bwd"); + m.def("masking_smith_fwd", &masking_smith_fwd, "masking_smith_fwd"); + m.def("masking_smith_bwd", &masking_smith_bwd, "masking_smith_bwd"); + m.def("pbr_specular_fwd", &pbr_specular_fwd, "pbr_specular_fwd"); + m.def("pbr_specular_bwd", &pbr_specular_bwd, "pbr_specular_bwd"); + m.def("pbr_bsdf_fwd", &pbr_bsdf_fwd, "pbr_bsdf_fwd"); + m.def("pbr_bsdf_bwd", &pbr_bsdf_bwd, "pbr_bsdf_bwd"); + m.def("diffuse_cubemap_fwd", &diffuse_cubemap_fwd, "diffuse_cubemap_fwd"); + m.def("diffuse_cubemap_bwd", &diffuse_cubemap_bwd, "diffuse_cubemap_bwd"); + m.def("specular_bounds", &specular_bounds, "specular_bounds"); + m.def("specular_cubemap_fwd", &specular_cubemap_fwd, "specular_cubemap_fwd"); + m.def("specular_cubemap_bwd", &specular_cubemap_bwd, "specular_cubemap_bwd"); + m.def("image_loss_fwd", &image_loss_fwd, "image_loss_fwd"); + m.def("image_loss_bwd", &image_loss_bwd, "image_loss_bwd"); + m.def("xfm_fwd", &xfm_fwd, "xfm_fwd"); + m.def("xfm_bwd", &xfm_bwd, "xfm_bwd"); +} \ No newline at end of file diff --git a/render/renderutils/c_src/vec3f.h b/render/renderutils/c_src/vec3f.h new file mode 100644 index 0000000..7e67454 --- /dev/null +++ b/render/renderutils/c_src/vec3f.h @@ -0,0 +1,109 @@ +/* + * Copyright (c) 2020-2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * + * NVIDIA CORPORATION, its affiliates and licensors retain all intellectual + * property and proprietary rights in and to this material, related + * documentation and any modifications thereto. Any use, reproduction, + * disclosure or distribution of this material and related documentation + * without an express license agreement from NVIDIA CORPORATION or + * its affiliates is strictly prohibited. + */ + +#pragma once + +struct vec3f +{ + float x, y, z; + +#ifdef __CUDACC__ + __device__ vec3f() { } + __device__ vec3f(float v) { x = v; y = v; z = v; } + __device__ vec3f(float _x, float _y, float _z) { x = _x; y = _y; z = _z; } + __device__ vec3f(float3 v) { x = v.x; y = v.y; z = v.z; } + + __device__ inline vec3f& operator+=(const vec3f& b) { x += b.x; y += b.y; z += b.z; return *this; } + __device__ inline vec3f& operator-=(const vec3f& b) { x -= b.x; y -= b.y; z -= b.z; return *this; } + __device__ inline vec3f& operator*=(const vec3f& b) { x *= b.x; y *= b.y; z *= b.z; return *this; } + __device__ inline vec3f& operator/=(const vec3f& b) { x /= b.x; y /= b.y; z /= b.z; return *this; } +#endif +}; + +#ifdef __CUDACC__ +__device__ static inline vec3f operator+(const vec3f& a, const vec3f& b) { return vec3f(a.x + b.x, a.y + b.y, a.z + b.z); } +__device__ static inline vec3f operator-(const vec3f& a, const vec3f& b) { return vec3f(a.x - b.x, a.y - b.y, a.z - b.z); } +__device__ static inline vec3f operator*(const vec3f& a, const vec3f& b) { return vec3f(a.x * b.x, a.y * b.y, a.z * b.z); } +__device__ static inline vec3f operator/(const vec3f& a, const vec3f& b) { return vec3f(a.x / b.x, a.y / b.y, a.z / b.z); } +__device__ static inline vec3f operator-(const vec3f& a) { return vec3f(-a.x, -a.y, -a.z); } + +__device__ static inline float sum(vec3f a) +{ + return a.x + a.y + a.z; +} + +__device__ static inline vec3f cross(vec3f a, vec3f b) +{ + vec3f out; + out.x = a.y * b.z - a.z * b.y; + out.y = a.z * b.x - a.x * b.z; + out.z = a.x * b.y - a.y * b.x; + return out; +} + +__device__ static inline void bwdCross(vec3f a, vec3f b, vec3f &d_a, vec3f &d_b, vec3f d_out) +{ + d_a.x += d_out.z * b.y - d_out.y * b.z; + d_a.y += d_out.x * b.z - d_out.z * b.x; + d_a.z += d_out.y * b.x - d_out.x * b.y; + + d_b.x += d_out.y * a.z - d_out.z * a.y; + d_b.y += d_out.z * a.x - d_out.x * a.z; + d_b.z += d_out.x * a.y - d_out.y * a.x; +} + +__device__ static inline float dot(vec3f a, vec3f b) +{ + return a.x * b.x + a.y * b.y + a.z * b.z; +} + +__device__ static inline void bwdDot(vec3f a, vec3f b, vec3f& d_a, vec3f& d_b, float d_out) +{ + d_a.x += d_out * b.x; d_a.y += d_out * b.y; d_a.z += d_out * b.z; + d_b.x += d_out * a.x; d_b.y += d_out * a.y; d_b.z += d_out * a.z; +} + +__device__ static inline vec3f reflect(vec3f x, vec3f n) +{ + return n * 2.0f * dot(n, x) - x; +} + +__device__ static inline void bwdReflect(vec3f x, vec3f n, vec3f& d_x, vec3f& d_n, const vec3f d_out) +{ + d_x.x += d_out.x * (2 * n.x * n.x - 1) + d_out.y * (2 * n.x * n.y) + d_out.z * (2 * n.x * n.z); + d_x.y += d_out.x * (2 * n.x * n.y) + d_out.y * (2 * n.y * n.y - 1) + d_out.z * (2 * n.y * n.z); + d_x.z += d_out.x * (2 * n.x * n.z) + d_out.y * (2 * n.y * n.z) + d_out.z * (2 * n.z * n.z - 1); + + d_n.x += d_out.x * (2 * (2 * n.x * x.x + n.y * x.y + n.z * x.z)) + d_out.y * (2 * n.y * x.x) + d_out.z * (2 * n.z * x.x); + d_n.y += d_out.x * (2 * n.x * x.y) + d_out.y * (2 * (n.x * x.x + 2 * n.y * x.y + n.z * x.z)) + d_out.z * (2 * n.z * x.y); + d_n.z += d_out.x * (2 * n.x * x.z) + d_out.y * (2 * n.y * x.z) + d_out.z * (2 * (n.x * x.x + n.y * x.y + 2 * n.z * x.z)); +} + +__device__ static inline vec3f safeNormalize(vec3f v) +{ + float l = sqrtf(v.x * v.x + v.y * v.y + v.z * v.z); + return l > 0.0f ? (v / l) : vec3f(0.0f); +} + +__device__ static inline void bwdSafeNormalize(const vec3f v, vec3f& d_v, const vec3f d_out) +{ + + float l = sqrtf(v.x * v.x + v.y * v.y + v.z * v.z); + if (l > 0.0f) + { + float fac = 1.0 / powf(v.x * v.x + v.y * v.y + v.z * v.z, 1.5f); + d_v.x += (d_out.x * (v.y * v.y + v.z * v.z) - d_out.y * (v.x * v.y) - d_out.z * (v.x * v.z)) * fac; + d_v.y += (d_out.y * (v.x * v.x + v.z * v.z) - d_out.x * (v.y * v.x) - d_out.z * (v.y * v.z)) * fac; + d_v.z += (d_out.z * (v.x * v.x + v.y * v.y) - d_out.x * (v.z * v.x) - d_out.y * (v.z * v.y)) * fac; + } +} + +#endif \ No newline at end of file diff --git a/render/renderutils/c_src/vec4f.h b/render/renderutils/c_src/vec4f.h new file mode 100644 index 0000000..e3f3077 --- /dev/null +++ b/render/renderutils/c_src/vec4f.h @@ -0,0 +1,25 @@ +/* + * Copyright (c) 2020-2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * + * NVIDIA CORPORATION, its affiliates and licensors retain all intellectual + * property and proprietary rights in and to this material, related + * documentation and any modifications thereto. Any use, reproduction, + * disclosure or distribution of this material and related documentation + * without an express license agreement from NVIDIA CORPORATION or + * its affiliates is strictly prohibited. + */ + +#pragma once + +struct vec4f +{ + float x, y, z, w; + +#ifdef __CUDACC__ + __device__ vec4f() { } + __device__ vec4f(float v) { x = v; y = v; z = v; w = v; } + __device__ vec4f(float _x, float _y, float _z, float _w) { x = _x; y = _y; z = _z; w = _w; } + __device__ vec4f(float4 v) { x = v.x; y = v.y; z = v.z; w = v.w; } +#endif +}; + diff --git a/render/renderutils/loss.py b/render/renderutils/loss.py new file mode 100644 index 0000000..92a24c0 --- /dev/null +++ b/render/renderutils/loss.py @@ -0,0 +1,41 @@ +# Copyright (c) 2020-2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# +# NVIDIA CORPORATION, its affiliates and licensors retain all intellectual +# property and proprietary rights in and to this material, related +# documentation and any modifications thereto. Any use, reproduction, +# disclosure or distribution of this material and related documentation +# without an express license agreement from NVIDIA CORPORATION or +# its affiliates is strictly prohibited. + +import torch + +#---------------------------------------------------------------------------- +# HDR image losses +#---------------------------------------------------------------------------- + +def _tonemap_srgb(f): + return torch.where(f > 0.0031308, torch.pow(torch.clamp(f, min=0.0031308), 1.0/2.4)*1.055 - 0.055, 12.92*f) + +def _SMAPE(img, target, eps=0.01): + nom = torch.abs(img - target) + denom = torch.abs(img) + torch.abs(target) + 0.01 + return torch.mean(nom / denom) + +def _RELMSE(img, target, eps=0.1): + nom = (img - target) * (img - target) + denom = img * img + target * target + 0.1 + return torch.mean(nom / denom) + +def image_loss_fn(img, target, loss, tonemapper): + if tonemapper == 'log_srgb': + img = _tonemap_srgb(torch.log(torch.clamp(img, min=0, max=65535) + 1)) + target = _tonemap_srgb(torch.log(torch.clamp(target, min=0, max=65535) + 1)) + + if loss == 'mse': + return torch.nn.functional.mse_loss(img, target) + elif loss == 'smape': + return _SMAPE(img, target) + elif loss == 'relmse': + return _RELMSE(img, target) + else: + return torch.nn.functional.l1_loss(img, target) diff --git a/render/renderutils/ops.py b/render/renderutils/ops.py new file mode 100644 index 0000000..b23bf5e --- /dev/null +++ b/render/renderutils/ops.py @@ -0,0 +1,554 @@ +# Copyright (c) 2020-2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# +# NVIDIA CORPORATION, its affiliates and licensors retain all intellectual +# property and proprietary rights in and to this material, related +# documentation and any modifications thereto. Any use, reproduction, +# disclosure or distribution of this material and related documentation +# without an express license agreement from NVIDIA CORPORATION or +# its affiliates is strictly prohibited. + +import numpy as np +import os +import sys +import torch +import torch.utils.cpp_extension + +from .bsdf import * +from .loss import * + +#---------------------------------------------------------------------------- +# C++/Cuda plugin compiler/loader. + +_cached_plugin = None +def _get_plugin(): + # Return cached plugin if already loaded. + global _cached_plugin + if _cached_plugin is not None: + return _cached_plugin + + # Make sure we can find the necessary compiler and libary binaries. + if os.name == 'nt': + def find_cl_path(): + import glob + for edition in ['Enterprise', 'Professional', 'BuildTools', 'Community']: + paths = sorted(glob.glob(r"C:\Program Files (x86)\Microsoft Visual Studio\*\%s\VC\Tools\MSVC\*\bin\Hostx64\x64" % edition), reverse=True) + if paths: + return paths[0] + + # If cl.exe is not on path, try to find it. + if os.system("where cl.exe >nul 2>nul") != 0: + cl_path = find_cl_path() + if cl_path is None: + raise RuntimeError("Could not locate a supported Microsoft Visual C++ installation") + os.environ['PATH'] += ';' + cl_path + + # Compiler options. + opts = ['-DNVDR_TORCH'] + + # Linker options. + if os.name == 'posix': + ldflags = ['-lcuda', '-lnvrtc'] + elif os.name == 'nt': + ldflags = ['cuda.lib', 'advapi32.lib', 'nvrtc.lib'] + + # List of sources. + source_files = [ + 'c_src/mesh.cu', + 'c_src/loss.cu', + 'c_src/bsdf.cu', + 'c_src/normal.cu', + 'c_src/cubemap.cu', + 'c_src/common.cpp', + 'c_src/torch_bindings.cpp' + ] + + # Some containers set this to contain old architectures that won't compile. We only need the one installed in the machine. + os.environ['TORCH_CUDA_ARCH_LIST'] = '' + + # Try to detect if a stray lock file is left in cache directory and show a warning. This sometimes happens on Windows if the build is interrupted at just the right moment. + try: + lock_fn = os.path.join(torch.utils.cpp_extension._get_build_directory('renderutils_plugin', False), 'lock') + if os.path.exists(lock_fn): + print("Warning: Lock file exists in build directory: '%s'" % lock_fn) + except: + pass + + # Compile and load. + source_paths = [os.path.join(os.path.dirname(__file__), fn) for fn in source_files] + torch.utils.cpp_extension.load(name='renderutils_plugin', sources=source_paths, extra_cflags=opts, + extra_cuda_cflags=opts, extra_ldflags=ldflags, with_cuda=True, verbose=True) + + # Import, cache, and return the compiled module. + import renderutils_plugin + _cached_plugin = renderutils_plugin + return _cached_plugin + +#---------------------------------------------------------------------------- +# Internal kernels, just used for testing functionality + +class _fresnel_shlick_func(torch.autograd.Function): + @staticmethod + def forward(ctx, f0, f90, cosTheta): + out = _get_plugin().fresnel_shlick_fwd(f0, f90, cosTheta, False) + ctx.save_for_backward(f0, f90, cosTheta) + return out + + @staticmethod + def backward(ctx, dout): + f0, f90, cosTheta = ctx.saved_variables + return _get_plugin().fresnel_shlick_bwd(f0, f90, cosTheta, dout) + (None,) + +def _fresnel_shlick(f0, f90, cosTheta, use_python=False): + if use_python: + out = bsdf_fresnel_shlick(f0, f90, cosTheta) + else: + out = _fresnel_shlick_func.apply(f0, f90, cosTheta) + + if torch.is_anomaly_enabled(): + assert torch.all(torch.isfinite(out)), "Output of _fresnel_shlick contains inf or NaN" + return out + + +class _ndf_ggx_func(torch.autograd.Function): + @staticmethod + def forward(ctx, alphaSqr, cosTheta): + out = _get_plugin().ndf_ggx_fwd(alphaSqr, cosTheta, False) + ctx.save_for_backward(alphaSqr, cosTheta) + return out + + @staticmethod + def backward(ctx, dout): + alphaSqr, cosTheta = ctx.saved_variables + return _get_plugin().ndf_ggx_bwd(alphaSqr, cosTheta, dout) + (None,) + +def _ndf_ggx(alphaSqr, cosTheta, use_python=False): + if use_python: + out = bsdf_ndf_ggx(alphaSqr, cosTheta) + else: + out = _ndf_ggx_func.apply(alphaSqr, cosTheta) + + if torch.is_anomaly_enabled(): + assert torch.all(torch.isfinite(out)), "Output of _ndf_ggx contains inf or NaN" + return out + +class _lambda_ggx_func(torch.autograd.Function): + @staticmethod + def forward(ctx, alphaSqr, cosTheta): + out = _get_plugin().lambda_ggx_fwd(alphaSqr, cosTheta, False) + ctx.save_for_backward(alphaSqr, cosTheta) + return out + + @staticmethod + def backward(ctx, dout): + alphaSqr, cosTheta = ctx.saved_variables + return _get_plugin().lambda_ggx_bwd(alphaSqr, cosTheta, dout) + (None,) + +def _lambda_ggx(alphaSqr, cosTheta, use_python=False): + if use_python: + out = bsdf_lambda_ggx(alphaSqr, cosTheta) + else: + out = _lambda_ggx_func.apply(alphaSqr, cosTheta) + + if torch.is_anomaly_enabled(): + assert torch.all(torch.isfinite(out)), "Output of _lambda_ggx contains inf or NaN" + return out + +class _masking_smith_func(torch.autograd.Function): + @staticmethod + def forward(ctx, alphaSqr, cosThetaI, cosThetaO): + ctx.save_for_backward(alphaSqr, cosThetaI, cosThetaO) + out = _get_plugin().masking_smith_fwd(alphaSqr, cosThetaI, cosThetaO, False) + return out + + @staticmethod + def backward(ctx, dout): + alphaSqr, cosThetaI, cosThetaO = ctx.saved_variables + return _get_plugin().masking_smith_bwd(alphaSqr, cosThetaI, cosThetaO, dout) + (None,) + +def _masking_smith(alphaSqr, cosThetaI, cosThetaO, use_python=False): + if use_python: + out = bsdf_masking_smith_ggx_correlated(alphaSqr, cosThetaI, cosThetaO) + else: + out = _masking_smith_func.apply(alphaSqr, cosThetaI, cosThetaO) + + if torch.is_anomaly_enabled(): + assert torch.all(torch.isfinite(out)), "Output of _masking_smith contains inf or NaN" + return out + +#---------------------------------------------------------------------------- +# Shading normal setup (bump mapping + bent normals) + +class _prepare_shading_normal_func(torch.autograd.Function): + @staticmethod + def forward(ctx, pos, view_pos, perturbed_nrm, smooth_nrm, smooth_tng, geom_nrm, two_sided_shading, opengl): + ctx.two_sided_shading, ctx.opengl = two_sided_shading, opengl + out = _get_plugin().prepare_shading_normal_fwd(pos, view_pos, perturbed_nrm, smooth_nrm, smooth_tng, geom_nrm, two_sided_shading, opengl, False) + ctx.save_for_backward(pos, view_pos, perturbed_nrm, smooth_nrm, smooth_tng, geom_nrm) + return out + + @staticmethod + def backward(ctx, dout): + pos, view_pos, perturbed_nrm, smooth_nrm, smooth_tng, geom_nrm = ctx.saved_variables + return _get_plugin().prepare_shading_normal_bwd(pos, view_pos, perturbed_nrm, smooth_nrm, smooth_tng, geom_nrm, dout, ctx.two_sided_shading, ctx.opengl) + (None, None, None) + +def prepare_shading_normal(pos, view_pos, perturbed_nrm, smooth_nrm, smooth_tng, geom_nrm, two_sided_shading=True, opengl=True, use_python=False): + '''Takes care of all corner cases and produces a final normal used for shading: + - Constructs tangent space + - Flips normal direction based on geometric normal for two sided Shading + - Perturbs shading normal by normal map + - Bends backfacing normals towards the camera to avoid shading artifacts + + All tensors assume a shape of [minibatch_size, height, width, 3] or broadcastable equivalent. + + Args: + pos: World space g-buffer position. + view_pos: Camera position in world space (typically using broadcasting). + perturbed_nrm: Trangent-space normal perturbation from normal map lookup. + smooth_nrm: Interpolated vertex normals. + smooth_tng: Interpolated vertex tangents. + geom_nrm: Geometric (face) normals. + two_sided_shading: Use one/two sided shading + opengl: Use OpenGL/DirectX normal map conventions + use_python: Use PyTorch implementation (for validation) + Returns: + Final shading normal + ''' + + if perturbed_nrm is None: + perturbed_nrm = torch.tensor([0, 0, 1], dtype=torch.float32, device='cuda', requires_grad=False)[None, None, None, ...] + + if use_python: + out = bsdf_prepare_shading_normal(pos, view_pos, perturbed_nrm, smooth_nrm, smooth_tng, geom_nrm, two_sided_shading, opengl) + else: + out = _prepare_shading_normal_func.apply(pos, view_pos, perturbed_nrm, smooth_nrm, smooth_tng, geom_nrm, two_sided_shading, opengl) + + if torch.is_anomaly_enabled(): + assert torch.all(torch.isfinite(out)), "Output of prepare_shading_normal contains inf or NaN" + return out + +#---------------------------------------------------------------------------- +# BSDF functions + +class _lambert_func(torch.autograd.Function): + @staticmethod + def forward(ctx, nrm, wi): + out = _get_plugin().lambert_fwd(nrm, wi, False) + ctx.save_for_backward(nrm, wi) + return out + + @staticmethod + def backward(ctx, dout): + nrm, wi = ctx.saved_variables + return _get_plugin().lambert_bwd(nrm, wi, dout) + (None,) + +def lambert(nrm, wi, use_python=False): + '''Lambertian bsdf. + All tensors assume a shape of [minibatch_size, height, width, 3] or broadcastable equivalent. + + Args: + nrm: World space shading normal. + wi: World space light vector. + use_python: Use PyTorch implementation (for validation) + + Returns: + Shaded diffuse value with shape [minibatch_size, height, width, 1] + ''' + + if use_python: + out = bsdf_lambert(nrm, wi) + else: + out = _lambert_func.apply(nrm, wi) + + if torch.is_anomaly_enabled(): + assert torch.all(torch.isfinite(out)), "Output of lambert contains inf or NaN" + return out + +class _frostbite_diffuse_func(torch.autograd.Function): + @staticmethod + def forward(ctx, nrm, wi, wo, linearRoughness): + out = _get_plugin().frostbite_fwd(nrm, wi, wo, linearRoughness, False) + ctx.save_for_backward(nrm, wi, wo, linearRoughness) + return out + + @staticmethod + def backward(ctx, dout): + nrm, wi, wo, linearRoughness = ctx.saved_variables + return _get_plugin().frostbite_bwd(nrm, wi, wo, linearRoughness, dout) + (None,) + +def frostbite_diffuse(nrm, wi, wo, linearRoughness, use_python=False): + '''Frostbite, normalized Disney Diffuse bsdf. + All tensors assume a shape of [minibatch_size, height, width, 3] or broadcastable equivalent. + + Args: + nrm: World space shading normal. + wi: World space light vector. + wo: World space camera vector. + linearRoughness: Material roughness + use_python: Use PyTorch implementation (for validation) + + Returns: + Shaded diffuse value with shape [minibatch_size, height, width, 1] + ''' + + if use_python: + out = bsdf_frostbite(nrm, wi, wo, linearRoughness) + else: + out = _frostbite_diffuse_func.apply(nrm, wi, wo, linearRoughness) + + if torch.is_anomaly_enabled(): + assert torch.all(torch.isfinite(out)), "Output of lambert contains inf or NaN" + return out + +class _pbr_specular_func(torch.autograd.Function): + @staticmethod + def forward(ctx, col, nrm, wo, wi, alpha, min_roughness): + ctx.save_for_backward(col, nrm, wo, wi, alpha) + ctx.min_roughness = min_roughness + out = _get_plugin().pbr_specular_fwd(col, nrm, wo, wi, alpha, min_roughness, False) + return out + + @staticmethod + def backward(ctx, dout): + col, nrm, wo, wi, alpha = ctx.saved_variables + return _get_plugin().pbr_specular_bwd(col, nrm, wo, wi, alpha, ctx.min_roughness, dout) + (None, None) + +def pbr_specular(col, nrm, wo, wi, alpha, min_roughness=0.08, use_python=False): + '''Physically-based specular bsdf. + All tensors assume a shape of [minibatch_size, height, width, 3] or broadcastable equivalent unless otherwise noted. + + Args: + col: Specular lobe color + nrm: World space shading normal. + wo: World space camera vector. + wi: World space light vector + alpha: Specular roughness parameter with shape [minibatch_size, height, width, 1] + min_roughness: Scalar roughness clamping threshold + + use_python: Use PyTorch implementation (for validation) + Returns: + Shaded specular color + ''' + + if use_python: + out = bsdf_pbr_specular(col, nrm, wo, wi, alpha, min_roughness=min_roughness) + else: + out = _pbr_specular_func.apply(col, nrm, wo, wi, alpha, min_roughness) + + if torch.is_anomaly_enabled(): + assert torch.all(torch.isfinite(out)), "Output of pbr_specular contains inf or NaN" + return out + +class _pbr_bsdf_func(torch.autograd.Function): + @staticmethod + def forward(ctx, kd, arm, pos, nrm, view_pos, light_pos, min_roughness, BSDF): + ctx.save_for_backward(kd, arm, pos, nrm, view_pos, light_pos) + ctx.min_roughness = min_roughness + ctx.BSDF = BSDF + out = _get_plugin().pbr_bsdf_fwd(kd, arm, pos, nrm, view_pos, light_pos, min_roughness, BSDF, False) + return out + + @staticmethod + def backward(ctx, dout): + kd, arm, pos, nrm, view_pos, light_pos = ctx.saved_variables + return _get_plugin().pbr_bsdf_bwd(kd, arm, pos, nrm, view_pos, light_pos, ctx.min_roughness, ctx.BSDF, dout) + (None, None, None) + +def pbr_bsdf(kd, arm, pos, nrm, view_pos, light_pos, min_roughness=0.08, bsdf="lambert", use_python=False): + '''Physically-based bsdf, both diffuse & specular lobes + All tensors assume a shape of [minibatch_size, height, width, 3] or broadcastable equivalent unless otherwise noted. + + Args: + kd: Diffuse albedo. + arm: Specular parameters (attenuation, linear roughness, metalness). + pos: World space position. + nrm: World space shading normal. + view_pos: Camera position in world space, typically using broadcasting. + light_pos: Light position in world space, typically using broadcasting. + min_roughness: Scalar roughness clamping threshold + bsdf: Controls diffuse BSDF, can be either 'lambert' or 'frostbite' + + use_python: Use PyTorch implementation (for validation) + + Returns: + Shaded color. + ''' + + BSDF = 0 + if bsdf == 'frostbite': + BSDF = 1 + + if use_python: + out = bsdf_pbr(kd, arm, pos, nrm, view_pos, light_pos, min_roughness, BSDF) + else: + out = _pbr_bsdf_func.apply(kd, arm, pos, nrm, view_pos, light_pos, min_roughness, BSDF) + + if torch.is_anomaly_enabled(): + assert torch.all(torch.isfinite(out)), "Output of pbr_bsdf contains inf or NaN" + return out + +#---------------------------------------------------------------------------- +# cubemap filter with filtering across edges + +class _diffuse_cubemap_func(torch.autograd.Function): + @staticmethod + def forward(ctx, cubemap): + out = _get_plugin().diffuse_cubemap_fwd(cubemap) + ctx.save_for_backward(cubemap) + return out + + @staticmethod + def backward(ctx, dout): + cubemap, = ctx.saved_variables + cubemap_grad = _get_plugin().diffuse_cubemap_bwd(cubemap, dout) + return cubemap_grad, None + +def diffuse_cubemap(cubemap, use_python=False): + if use_python: + assert False + else: + out = _diffuse_cubemap_func.apply(cubemap) + if torch.is_anomaly_enabled(): + assert torch.all(torch.isfinite(out)), "Output of diffuse_cubemap contains inf or NaN" + return out + +class _specular_cubemap(torch.autograd.Function): + @staticmethod + def forward(ctx, cubemap, roughness, costheta_cutoff, bounds): + out = _get_plugin().specular_cubemap_fwd(cubemap, bounds, roughness, costheta_cutoff) + ctx.save_for_backward(cubemap, bounds) + ctx.roughness, ctx.theta_cutoff = roughness, costheta_cutoff + return out + + @staticmethod + def backward(ctx, dout): + cubemap, bounds = ctx.saved_variables + cubemap_grad = _get_plugin().specular_cubemap_bwd(cubemap, bounds, dout, ctx.roughness, ctx.theta_cutoff) + return cubemap_grad, None, None, None + +# Compute the bounds of the GGX NDF lobe to retain "cutoff" percent of the energy +def __ndfBounds(res, roughness, cutoff): + def ndfGGX(alphaSqr, costheta): + costheta = np.clip(costheta, 0.0, 1.0) + d = (costheta * alphaSqr - costheta) * costheta + 1.0 + return alphaSqr / (d * d * np.pi) + + # Sample out cutoff angle + nSamples = 1000000 + costheta = np.cos(np.linspace(0, np.pi/2.0, nSamples)) + D = np.cumsum(ndfGGX(roughness**4, costheta)) + idx = np.argmax(D >= D[..., -1] * cutoff) + + # Brute force compute lookup table with bounds + bounds = _get_plugin().specular_bounds(res, costheta[idx]) + + return costheta[idx], bounds +__ndfBoundsDict = {} + +def specular_cubemap(cubemap, roughness, cutoff=0.99, use_python=False): + assert cubemap.shape[0] == 6 and cubemap.shape[1] == cubemap.shape[2], "Bad shape for cubemap tensor: %s" % str(cubemap.shape) + + if use_python: + assert False + else: + key = (cubemap.shape[1], roughness, cutoff) + if key not in __ndfBoundsDict: + __ndfBoundsDict[key] = __ndfBounds(*key) + out = _specular_cubemap.apply(cubemap, roughness, *__ndfBoundsDict[key]) + if torch.is_anomaly_enabled(): + assert torch.all(torch.isfinite(out)), "Output of specular_cubemap contains inf or NaN" + return out[..., 0:3] / out[..., 3:] + +#---------------------------------------------------------------------------- +# Fast image loss function + +class _image_loss_func(torch.autograd.Function): + @staticmethod + def forward(ctx, img, target, loss, tonemapper): + ctx.loss, ctx.tonemapper = loss, tonemapper + ctx.save_for_backward(img, target) + out = _get_plugin().image_loss_fwd(img, target, loss, tonemapper, False) + return out + + @staticmethod + def backward(ctx, dout): + img, target = ctx.saved_variables + return _get_plugin().image_loss_bwd(img, target, dout, ctx.loss, ctx.tonemapper) + (None, None, None) + +def image_loss(img, target, loss='l1', tonemapper='none', use_python=False): + '''Compute HDR image loss. Combines tonemapping and loss into a single kernel for better perf. + All tensors assume a shape of [minibatch_size, height, width, 3] or broadcastable equivalent unless otherwise noted. + + Args: + img: Input image. + target: Target (reference) image. + loss: Type of loss. Valid options are ['l1', 'mse', 'smape', 'relmse'] + tonemapper: Tonemapping operations. Valid options are ['none', 'log_srgb'] + use_python: Use PyTorch implementation (for validation) + + Returns: + Image space loss (scalar value). + ''' + if use_python: + out = image_loss_fn(img, target, loss, tonemapper) + else: + out = _image_loss_func.apply(img, target, loss, tonemapper) + out = torch.sum(out) / (img.shape[0]*img.shape[1]*img.shape[2]) + + if torch.is_anomaly_enabled(): + assert torch.all(torch.isfinite(out)), "Output of image_loss contains inf or NaN" + return out + +#---------------------------------------------------------------------------- +# Transform points function + +class _xfm_func(torch.autograd.Function): + @staticmethod + def forward(ctx, points, matrix, isPoints): + ctx.save_for_backward(points, matrix) + ctx.isPoints = isPoints + return _get_plugin().xfm_fwd(points, matrix, isPoints, False) + + @staticmethod + def backward(ctx, dout): + points, matrix = ctx.saved_variables + return (_get_plugin().xfm_bwd(points, matrix, dout, ctx.isPoints),) + (None, None, None) + +def xfm_points(points, matrix, use_python=False): + '''Transform points. + Args: + points: Tensor containing 3D points with shape [minibatch_size, num_vertices, 3] or [1, num_vertices, 3] + matrix: A 4x4 transform matrix with shape [minibatch_size, 4, 4] + use_python: Use PyTorch's torch.matmul (for validation) + Returns: + Transformed points in homogeneous 4D with shape [minibatch_size, num_vertices, 4]. + ''' + if use_python: + out = torch.matmul(torch.nn.functional.pad(points, pad=(0,1), mode='constant', value=1.0), torch.transpose(matrix, 1, 2)) + else: + out = _xfm_func.apply(points, matrix, True) + + if torch.is_anomaly_enabled(): + assert torch.all(torch.isfinite(out)), "Output of xfm_points contains inf or NaN" + return out + +def xfm_vectors(vectors, matrix, use_python=False): + '''Transform vectors. + Args: + vectors: Tensor containing 3D vectors with shape [minibatch_size, num_vertices, 3] or [1, num_vertices, 3] + matrix: A 4x4 transform matrix with shape [minibatch_size, 4, 4] + use_python: Use PyTorch's torch.matmul (for validation) + + Returns: + Transformed vectors in homogeneous 4D with shape [minibatch_size, num_vertices, 4]. + ''' + + if use_python: + out = torch.matmul(torch.nn.functional.pad(vectors, pad=(0,1), mode='constant', value=0.0), torch.transpose(matrix, 1, 2))[..., 0:3].contiguous() + else: + out = _xfm_func.apply(vectors, matrix, False) + + if torch.is_anomaly_enabled(): + assert torch.all(torch.isfinite(out)), "Output of xfm_vectors contains inf or NaN" + return out + + + diff --git a/render/renderutils/tests/test_bsdf.py b/render/renderutils/tests/test_bsdf.py new file mode 100644 index 0000000..b0b60c3 --- /dev/null +++ b/render/renderutils/tests/test_bsdf.py @@ -0,0 +1,296 @@ +# Copyright (c) 2020-2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# +# NVIDIA CORPORATION, its affiliates and licensors retain all intellectual +# property and proprietary rights in and to this material, related +# documentation and any modifications thereto. Any use, reproduction, +# disclosure or distribution of this material and related documentation +# without an express license agreement from NVIDIA CORPORATION or +# its affiliates is strictly prohibited. + +import torch + +import os +import sys +sys.path.insert(0, os.path.join(sys.path[0], '../..')) +import renderutils as ru + +RES = 4 +DTYPE = torch.float32 + +def relative_loss(name, ref, cuda): + ref = ref.float() + cuda = cuda.float() + print(name, torch.max(torch.abs(ref - cuda) / torch.abs(ref + 1e-7)).item()) + +def test_normal(): + pos_cuda = torch.rand(1, RES, RES, 3, dtype=DTYPE, device='cuda', requires_grad=True) + pos_ref = pos_cuda.clone().detach().requires_grad_(True) + view_pos_cuda = torch.rand(1, RES, RES, 3, dtype=DTYPE, device='cuda', requires_grad=True) + view_pos_ref = view_pos_cuda.clone().detach().requires_grad_(True) + perturbed_nrm_cuda = torch.rand(1, RES, RES, 3, dtype=DTYPE, device='cuda', requires_grad=True) + perturbed_nrm_ref = perturbed_nrm_cuda.clone().detach().requires_grad_(True) + smooth_nrm_cuda = torch.rand(1, RES, RES, 3, dtype=DTYPE, device='cuda', requires_grad=True) + smooth_nrm_ref = smooth_nrm_cuda.clone().detach().requires_grad_(True) + smooth_tng_cuda = torch.rand(1, RES, RES, 3, dtype=DTYPE, device='cuda', requires_grad=True) + smooth_tng_ref = smooth_tng_cuda.clone().detach().requires_grad_(True) + geom_nrm_cuda = torch.rand(1, RES, RES, 3, dtype=DTYPE, device='cuda', requires_grad=True) + geom_nrm_ref = geom_nrm_cuda.clone().detach().requires_grad_(True) + target = torch.rand(1, RES, RES, 3, dtype=DTYPE, device='cuda') + + ref = ru.prepare_shading_normal(pos_ref, view_pos_ref, perturbed_nrm_ref, smooth_nrm_ref, smooth_tng_ref, geom_nrm_ref, True, use_python=True) + ref_loss = torch.nn.MSELoss()(ref, target) + ref_loss.backward() + + cuda = ru.prepare_shading_normal(pos_cuda, view_pos_cuda, perturbed_nrm_cuda, smooth_nrm_cuda, smooth_tng_cuda, geom_nrm_cuda, True) + cuda_loss = torch.nn.MSELoss()(cuda, target) + cuda_loss.backward() + + print("-------------------------------------------------------------") + print(" bent normal") + print("-------------------------------------------------------------") + relative_loss("res:", ref, cuda) + relative_loss("pos:", pos_ref.grad, pos_cuda.grad) + relative_loss("view_pos:", view_pos_ref.grad, view_pos_cuda.grad) + relative_loss("perturbed_nrm:", perturbed_nrm_ref.grad, perturbed_nrm_cuda.grad) + relative_loss("smooth_nrm:", smooth_nrm_ref.grad, smooth_nrm_cuda.grad) + relative_loss("smooth_tng:", smooth_tng_ref.grad, smooth_tng_cuda.grad) + relative_loss("geom_nrm:", geom_nrm_ref.grad, geom_nrm_cuda.grad) + +def test_schlick(): + f0_cuda = torch.rand(1, RES, RES, 3, dtype=DTYPE, device='cuda', requires_grad=True) + f0_ref = f0_cuda.clone().detach().requires_grad_(True) + f90_cuda = torch.rand(1, RES, RES, 3, dtype=DTYPE, device='cuda', requires_grad=True) + f90_ref = f90_cuda.clone().detach().requires_grad_(True) + cosT_cuda = torch.rand(1, RES, RES, 1, dtype=DTYPE, device='cuda', requires_grad=True) * 2.0 + cosT_cuda = cosT_cuda.clone().detach().requires_grad_(True) + cosT_ref = cosT_cuda.clone().detach().requires_grad_(True) + target = torch.rand(1, RES, RES, 3, dtype=DTYPE, device='cuda') + + ref = ru._fresnel_shlick(f0_ref, f90_ref, cosT_ref, use_python=True) + ref_loss = torch.nn.MSELoss()(ref, target) + ref_loss.backward() + + cuda = ru._fresnel_shlick(f0_cuda, f90_cuda, cosT_cuda) + cuda_loss = torch.nn.MSELoss()(cuda, target) + cuda_loss.backward() + + print("-------------------------------------------------------------") + print(" Fresnel shlick") + print("-------------------------------------------------------------") + relative_loss("res:", ref, cuda) + relative_loss("f0:", f0_ref.grad, f0_cuda.grad) + relative_loss("f90:", f90_ref.grad, f90_cuda.grad) + relative_loss("cosT:", cosT_ref.grad, cosT_cuda.grad) + +def test_ndf_ggx(): + alphaSqr_cuda = torch.rand(1, RES, RES, 1, dtype=DTYPE, device='cuda', requires_grad=True) + alphaSqr_cuda = alphaSqr_cuda.clone().detach().requires_grad_(True) + alphaSqr_ref = alphaSqr_cuda.clone().detach().requires_grad_(True) + cosT_cuda = torch.rand(1, RES, RES, 1, dtype=DTYPE, device='cuda', requires_grad=True) * 3.0 - 1 + cosT_cuda = cosT_cuda.clone().detach().requires_grad_(True) + cosT_ref = cosT_cuda.clone().detach().requires_grad_(True) + target = torch.rand(1, RES, RES, 1, dtype=DTYPE, device='cuda') + + ref = ru._ndf_ggx(alphaSqr_ref, cosT_ref, use_python=True) + ref_loss = torch.nn.MSELoss()(ref, target) + ref_loss.backward() + + cuda = ru._ndf_ggx(alphaSqr_cuda, cosT_cuda) + cuda_loss = torch.nn.MSELoss()(cuda, target) + cuda_loss.backward() + + print("-------------------------------------------------------------") + print(" Ndf GGX") + print("-------------------------------------------------------------") + relative_loss("res:", ref, cuda) + relative_loss("alpha:", alphaSqr_ref.grad, alphaSqr_cuda.grad) + relative_loss("cosT:", cosT_ref.grad, cosT_cuda.grad) + +def test_lambda_ggx(): + alphaSqr_cuda = torch.rand(1, RES, RES, 1, dtype=DTYPE, device='cuda', requires_grad=True) + alphaSqr_ref = alphaSqr_cuda.clone().detach().requires_grad_(True) + cosT_cuda = torch.rand(1, RES, RES, 1, dtype=DTYPE, device='cuda', requires_grad=True) * 3.0 - 1 + cosT_cuda = cosT_cuda.clone().detach().requires_grad_(True) + cosT_ref = cosT_cuda.clone().detach().requires_grad_(True) + target = torch.rand(1, RES, RES, 1, dtype=DTYPE, device='cuda') + + ref = ru._lambda_ggx(alphaSqr_ref, cosT_ref, use_python=True) + ref_loss = torch.nn.MSELoss()(ref, target) + ref_loss.backward() + + cuda = ru._lambda_ggx(alphaSqr_cuda, cosT_cuda) + cuda_loss = torch.nn.MSELoss()(cuda, target) + cuda_loss.backward() + + print("-------------------------------------------------------------") + print(" Lambda GGX") + print("-------------------------------------------------------------") + relative_loss("res:", ref, cuda) + relative_loss("alpha:", alphaSqr_ref.grad, alphaSqr_cuda.grad) + relative_loss("cosT:", cosT_ref.grad, cosT_cuda.grad) + +def test_masking_smith(): + alphaSqr_cuda = torch.rand(1, RES, RES, 1, dtype=DTYPE, device='cuda', requires_grad=True) + alphaSqr_ref = alphaSqr_cuda.clone().detach().requires_grad_(True) + cosThetaI_cuda = torch.rand(1, RES, RES, 1, dtype=DTYPE, device='cuda', requires_grad=True) + cosThetaI_ref = cosThetaI_cuda.clone().detach().requires_grad_(True) + cosThetaO_cuda = torch.rand(1, RES, RES, 1, dtype=DTYPE, device='cuda', requires_grad=True) + cosThetaO_ref = cosThetaO_cuda.clone().detach().requires_grad_(True) + target = torch.rand(1, RES, RES, 1, dtype=DTYPE, device='cuda') + + ref = ru._masking_smith(alphaSqr_ref, cosThetaI_ref, cosThetaO_ref, use_python=True) + ref_loss = torch.nn.MSELoss()(ref, target) + ref_loss.backward() + + cuda = ru._masking_smith(alphaSqr_cuda, cosThetaI_cuda, cosThetaO_cuda) + cuda_loss = torch.nn.MSELoss()(cuda, target) + cuda_loss.backward() + + print("-------------------------------------------------------------") + print(" Smith masking term") + print("-------------------------------------------------------------") + relative_loss("res:", ref, cuda) + relative_loss("alpha:", alphaSqr_ref.grad, alphaSqr_cuda.grad) + relative_loss("cosThetaI:", cosThetaI_ref.grad, cosThetaI_cuda.grad) + relative_loss("cosThetaO:", cosThetaO_ref.grad, cosThetaO_cuda.grad) + +def test_lambert(): + normals_cuda = torch.rand(1, RES, RES, 3, dtype=DTYPE, device='cuda', requires_grad=True) + normals_ref = normals_cuda.clone().detach().requires_grad_(True) + wi_cuda = torch.rand(1, RES, RES, 3, dtype=DTYPE, device='cuda', requires_grad=True) + wi_ref = wi_cuda.clone().detach().requires_grad_(True) + target = torch.rand(1, RES, RES, 1, dtype=DTYPE, device='cuda') + + ref = ru.lambert(normals_ref, wi_ref, use_python=True) + ref_loss = torch.nn.MSELoss()(ref, target) + ref_loss.backward() + + cuda = ru.lambert(normals_cuda, wi_cuda) + cuda_loss = torch.nn.MSELoss()(cuda, target) + cuda_loss.backward() + + print("-------------------------------------------------------------") + print(" Lambert") + print("-------------------------------------------------------------") + relative_loss("res:", ref, cuda) + relative_loss("nrm:", normals_ref.grad, normals_cuda.grad) + relative_loss("wi:", wi_ref.grad, wi_cuda.grad) + +def test_frostbite(): + normals_cuda = torch.rand(1, RES, RES, 3, dtype=DTYPE, device='cuda', requires_grad=True) + normals_ref = normals_cuda.clone().detach().requires_grad_(True) + wi_cuda = torch.rand(1, RES, RES, 3, dtype=DTYPE, device='cuda', requires_grad=True) + wi_ref = wi_cuda.clone().detach().requires_grad_(True) + wo_cuda = torch.rand(1, RES, RES, 3, dtype=DTYPE, device='cuda', requires_grad=True) + wo_ref = wo_cuda.clone().detach().requires_grad_(True) + rough_cuda = torch.rand(1, RES, RES, 1, dtype=DTYPE, device='cuda', requires_grad=True) + rough_ref = rough_cuda.clone().detach().requires_grad_(True) + target = torch.rand(1, RES, RES, 1, dtype=DTYPE, device='cuda') + + ref = ru.frostbite_diffuse(normals_ref, wi_ref, wo_ref, rough_ref, use_python=True) + ref_loss = torch.nn.MSELoss()(ref, target) + ref_loss.backward() + + cuda = ru.frostbite_diffuse(normals_cuda, wi_cuda, wo_cuda, rough_cuda) + cuda_loss = torch.nn.MSELoss()(cuda, target) + cuda_loss.backward() + + print("-------------------------------------------------------------") + print(" Frostbite") + print("-------------------------------------------------------------") + relative_loss("res:", ref, cuda) + relative_loss("nrm:", normals_ref.grad, normals_cuda.grad) + relative_loss("wo:", wo_ref.grad, wo_cuda.grad) + relative_loss("wi:", wi_ref.grad, wi_cuda.grad) + relative_loss("rough:", rough_ref.grad, rough_cuda.grad) + +def test_pbr_specular(): + col_cuda = torch.rand(1, RES, RES, 3, dtype=DTYPE, device='cuda', requires_grad=True) + col_ref = col_cuda.clone().detach().requires_grad_(True) + nrm_cuda = torch.rand(1, RES, RES, 3, dtype=DTYPE, device='cuda', requires_grad=True) + nrm_ref = nrm_cuda.clone().detach().requires_grad_(True) + wi_cuda = torch.rand(1, RES, RES, 3, dtype=DTYPE, device='cuda', requires_grad=True) + wi_ref = wi_cuda.clone().detach().requires_grad_(True) + wo_cuda = torch.rand(1, RES, RES, 3, dtype=DTYPE, device='cuda', requires_grad=True) + wo_ref = wo_cuda.clone().detach().requires_grad_(True) + alpha_cuda = torch.rand(1, RES, RES, 1, dtype=DTYPE, device='cuda', requires_grad=True) + alpha_ref = alpha_cuda.clone().detach().requires_grad_(True) + target = torch.rand(1, RES, RES, 3, dtype=DTYPE, device='cuda') + + ref = ru.pbr_specular(col_ref, nrm_ref, wo_ref, wi_ref, alpha_ref, use_python=True) + ref_loss = torch.nn.MSELoss()(ref, target) + ref_loss.backward() + + cuda = ru.pbr_specular(col_cuda, nrm_cuda, wo_cuda, wi_cuda, alpha_cuda) + cuda_loss = torch.nn.MSELoss()(cuda, target) + cuda_loss.backward() + + print("-------------------------------------------------------------") + print(" Pbr specular") + print("-------------------------------------------------------------") + + relative_loss("res:", ref, cuda) + if col_ref.grad is not None: + relative_loss("col:", col_ref.grad, col_cuda.grad) + if nrm_ref.grad is not None: + relative_loss("nrm:", nrm_ref.grad, nrm_cuda.grad) + if wi_ref.grad is not None: + relative_loss("wi:", wi_ref.grad, wi_cuda.grad) + if wo_ref.grad is not None: + relative_loss("wo:", wo_ref.grad, wo_cuda.grad) + if alpha_ref.grad is not None: + relative_loss("alpha:", alpha_ref.grad, alpha_cuda.grad) + +def test_pbr_bsdf(bsdf): + kd_cuda = torch.rand(1, RES, RES, 3, dtype=DTYPE, device='cuda', requires_grad=True) + kd_ref = kd_cuda.clone().detach().requires_grad_(True) + arm_cuda = torch.rand(1, RES, RES, 3, dtype=DTYPE, device='cuda', requires_grad=True) + arm_ref = arm_cuda.clone().detach().requires_grad_(True) + pos_cuda = torch.rand(1, RES, RES, 3, dtype=DTYPE, device='cuda', requires_grad=True) + pos_ref = pos_cuda.clone().detach().requires_grad_(True) + nrm_cuda = torch.rand(1, RES, RES, 3, dtype=DTYPE, device='cuda', requires_grad=True) + nrm_ref = nrm_cuda.clone().detach().requires_grad_(True) + view_cuda = torch.rand(1, RES, RES, 3, dtype=DTYPE, device='cuda', requires_grad=True) + view_ref = view_cuda.clone().detach().requires_grad_(True) + light_cuda = torch.rand(1, RES, RES, 3, dtype=DTYPE, device='cuda', requires_grad=True) + light_ref = light_cuda.clone().detach().requires_grad_(True) + target = torch.rand(1, RES, RES, 3, dtype=DTYPE, device='cuda') + + ref = ru.pbr_bsdf(kd_ref, arm_ref, pos_ref, nrm_ref, view_ref, light_ref, use_python=True, bsdf=bsdf) + ref_loss = torch.nn.MSELoss()(ref, target) + ref_loss.backward() + + cuda = ru.pbr_bsdf(kd_cuda, arm_cuda, pos_cuda, nrm_cuda, view_cuda, light_cuda, bsdf=bsdf) + cuda_loss = torch.nn.MSELoss()(cuda, target) + cuda_loss.backward() + + print("-------------------------------------------------------------") + print(" Pbr BSDF") + print("-------------------------------------------------------------") + + relative_loss("res:", ref, cuda) + if kd_ref.grad is not None: + relative_loss("kd:", kd_ref.grad, kd_cuda.grad) + if arm_ref.grad is not None: + relative_loss("arm:", arm_ref.grad, arm_cuda.grad) + if pos_ref.grad is not None: + relative_loss("pos:", pos_ref.grad, pos_cuda.grad) + if nrm_ref.grad is not None: + relative_loss("nrm:", nrm_ref.grad, nrm_cuda.grad) + if view_ref.grad is not None: + relative_loss("view:", view_ref.grad, view_cuda.grad) + if light_ref.grad is not None: + relative_loss("light:", light_ref.grad, light_cuda.grad) + +test_normal() + +test_schlick() +test_ndf_ggx() +test_lambda_ggx() +test_masking_smith() + +test_lambert() +test_frostbite() +test_pbr_specular() +test_pbr_bsdf('lambert') +test_pbr_bsdf('frostbite') diff --git a/render/renderutils/tests/test_cubemap.py b/render/renderutils/tests/test_cubemap.py new file mode 100644 index 0000000..a1ae0a2 --- /dev/null +++ b/render/renderutils/tests/test_cubemap.py @@ -0,0 +1,47 @@ +# Copyright (c) 2020-2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# +# NVIDIA CORPORATION, its affiliates and licensors retain all intellectual +# property and proprietary rights in and to this material, related +# documentation and any modifications thereto. Any use, reproduction, +# disclosure or distribution of this material and related documentation +# without an express license agreement from NVIDIA CORPORATION or +# its affiliates is strictly prohibited. + +import torch + +import os +import sys +sys.path.insert(0, os.path.join(sys.path[0], '../..')) +import renderutils as ru + +RES = 4 +DTYPE = torch.float32 + +def relative_loss(name, ref, cuda): + ref = ref.float() + cuda = cuda.float() + print(name, torch.max(torch.abs(ref - cuda) / torch.abs(ref + 1e-7)).item()) + +def test_cubemap(): + cubemap_cuda = torch.rand(6, RES, RES, 3, dtype=DTYPE, device='cuda', requires_grad=True) + cubemap_ref = cubemap_cuda.clone().detach().requires_grad_(True) + weights = torch.rand(3, 3, 1, dtype=DTYPE, device='cuda') + target = torch.rand(6, RES, RES, 3, dtype=DTYPE, device='cuda') + + ref = ru.filter_cubemap(cubemap_ref, weights, use_python=True) + ref_loss = torch.nn.MSELoss()(ref, target) + ref_loss.backward() + + cuda = ru.filter_cubemap(cubemap_cuda, weights, use_python=False) + cuda_loss = torch.nn.MSELoss()(cuda, target) + cuda_loss.backward() + + print("-------------------------------------------------------------") + print(" Cubemap:") + print("-------------------------------------------------------------") + + relative_loss("flt:", ref, cuda) + relative_loss("cubemap:", cubemap_ref.grad, cubemap_cuda.grad) + + +test_cubemap() diff --git a/render/renderutils/tests/test_loss.py b/render/renderutils/tests/test_loss.py new file mode 100644 index 0000000..7a68f3f --- /dev/null +++ b/render/renderutils/tests/test_loss.py @@ -0,0 +1,61 @@ +# Copyright (c) 2020-2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# +# NVIDIA CORPORATION, its affiliates and licensors retain all intellectual +# property and proprietary rights in and to this material, related +# documentation and any modifications thereto. Any use, reproduction, +# disclosure or distribution of this material and related documentation +# without an express license agreement from NVIDIA CORPORATION or +# its affiliates is strictly prohibited. + +import torch + +import os +import sys +sys.path.insert(0, os.path.join(sys.path[0], '../..')) +import renderutils as ru + +RES = 8 +DTYPE = torch.float32 + +def tonemap_srgb(f): + return torch.where(f > 0.0031308, torch.pow(torch.clamp(f, min=0.0031308), 1.0/2.4)*1.055 - 0.055, 12.92*f) + +def l1(output, target): + x = torch.clamp(output, min=0, max=65535) + r = torch.clamp(target, min=0, max=65535) + x = tonemap_srgb(torch.log(x + 1)) + r = tonemap_srgb(torch.log(r + 1)) + return torch.nn.functional.l1_loss(x,r) + +def relative_loss(name, ref, cuda): + ref = ref.float() + cuda = cuda.float() + print(name, torch.max(torch.abs(ref - cuda) / torch.abs(ref + 1e-7)).item()) + +def test_loss(loss, tonemapper): + img_cuda = torch.rand(1, RES, RES, 3, dtype=DTYPE, device='cuda', requires_grad=True) + img_ref = img_cuda.clone().detach().requires_grad_(True) + target_cuda = torch.rand(1, RES, RES, 3, dtype=DTYPE, device='cuda', requires_grad=True) + target_ref = target_cuda.clone().detach().requires_grad_(True) + + ref_loss = ru.image_loss(img_ref, target_ref, loss=loss, tonemapper=tonemapper, use_python=True) + ref_loss.backward() + + cuda_loss = ru.image_loss(img_cuda, target_cuda, loss=loss, tonemapper=tonemapper) + cuda_loss.backward() + + print("-------------------------------------------------------------") + print(" Loss: %s, %s" % (loss, tonemapper)) + print("-------------------------------------------------------------") + + relative_loss("res:", ref_loss, cuda_loss) + relative_loss("img:", img_ref.grad, img_cuda.grad) + relative_loss("target:", target_ref.grad, target_cuda.grad) + + +test_loss('l1', 'none') +test_loss('l1', 'log_srgb') +test_loss('mse', 'log_srgb') +test_loss('smape', 'none') +test_loss('relmse', 'none') +test_loss('mse', 'none') \ No newline at end of file diff --git a/render/renderutils/tests/test_mesh.py b/render/renderutils/tests/test_mesh.py new file mode 100644 index 0000000..4856c5c --- /dev/null +++ b/render/renderutils/tests/test_mesh.py @@ -0,0 +1,90 @@ +# Copyright (c) 2020-2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# +# NVIDIA CORPORATION, its affiliates and licensors retain all intellectual +# property and proprietary rights in and to this material, related +# documentation and any modifications thereto. Any use, reproduction, +# disclosure or distribution of this material and related documentation +# without an express license agreement from NVIDIA CORPORATION or +# its affiliates is strictly prohibited. + +import torch + +import os +import sys +sys.path.insert(0, os.path.join(sys.path[0], '../..')) +import renderutils as ru + +BATCH = 8 +RES = 1024 +DTYPE = torch.float32 + +torch.manual_seed(0) + +def tonemap_srgb(f): + return torch.where(f > 0.0031308, torch.pow(torch.clamp(f, min=0.0031308), 1.0/2.4)*1.055 - 0.055, 12.92*f) + +def l1(output, target): + x = torch.clamp(output, min=0, max=65535) + r = torch.clamp(target, min=0, max=65535) + x = tonemap_srgb(torch.log(x + 1)) + r = tonemap_srgb(torch.log(r + 1)) + return torch.nn.functional.l1_loss(x,r) + +def relative_loss(name, ref, cuda): + ref = ref.float() + cuda = cuda.float() + print(name, torch.max(torch.abs(ref - cuda) / torch.abs(ref)).item()) + +def test_xfm_points(): + points_cuda = torch.rand(1, RES, 3, dtype=DTYPE, device='cuda', requires_grad=True) + points_ref = points_cuda.clone().detach().requires_grad_(True) + mtx_cuda = torch.rand(BATCH, 4, 4, dtype=DTYPE, device='cuda', requires_grad=False) + mtx_ref = mtx_cuda.clone().detach().requires_grad_(True) + target = torch.rand(BATCH, RES, 4, dtype=DTYPE, device='cuda', requires_grad=True) + + ref_out = ru.xfm_points(points_ref, mtx_ref, use_python=True) + ref_loss = torch.nn.MSELoss()(ref_out, target) + ref_loss.backward() + + cuda_out = ru.xfm_points(points_cuda, mtx_cuda) + cuda_loss = torch.nn.MSELoss()(cuda_out, target) + cuda_loss.backward() + + print("-------------------------------------------------------------") + + relative_loss("res:", ref_out, cuda_out) + relative_loss("points:", points_ref.grad, points_cuda.grad) + +def test_xfm_vectors(): + points_cuda = torch.rand(1, RES, 3, dtype=DTYPE, device='cuda', requires_grad=True) + points_ref = points_cuda.clone().detach().requires_grad_(True) + points_cuda_p = points_cuda.clone().detach().requires_grad_(True) + points_ref_p = points_cuda.clone().detach().requires_grad_(True) + mtx_cuda = torch.rand(BATCH, 4, 4, dtype=DTYPE, device='cuda', requires_grad=False) + mtx_ref = mtx_cuda.clone().detach().requires_grad_(True) + target = torch.rand(BATCH, RES, 4, dtype=DTYPE, device='cuda', requires_grad=True) + + ref_out = ru.xfm_vectors(points_ref.contiguous(), mtx_ref, use_python=True) + ref_loss = torch.nn.MSELoss()(ref_out, target[..., 0:3]) + ref_loss.backward() + + cuda_out = ru.xfm_vectors(points_cuda.contiguous(), mtx_cuda) + cuda_loss = torch.nn.MSELoss()(cuda_out, target[..., 0:3]) + cuda_loss.backward() + + ref_out_p = ru.xfm_points(points_ref_p.contiguous(), mtx_ref, use_python=True) + ref_loss_p = torch.nn.MSELoss()(ref_out_p, target) + ref_loss_p.backward() + + cuda_out_p = ru.xfm_points(points_cuda_p.contiguous(), mtx_cuda) + cuda_loss_p = torch.nn.MSELoss()(cuda_out_p, target) + cuda_loss_p.backward() + + print("-------------------------------------------------------------") + + relative_loss("res:", ref_out, cuda_out) + relative_loss("points:", points_ref.grad, points_cuda.grad) + relative_loss("points_p:", points_ref_p.grad, points_cuda_p.grad) + +test_xfm_points() +test_xfm_vectors() diff --git a/render/renderutils/tests/test_perf.py b/render/renderutils/tests/test_perf.py new file mode 100644 index 0000000..ffc143e --- /dev/null +++ b/render/renderutils/tests/test_perf.py @@ -0,0 +1,57 @@ +# Copyright (c) 2020-2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# +# NVIDIA CORPORATION, its affiliates and licensors retain all intellectual +# property and proprietary rights in and to this material, related +# documentation and any modifications thereto. Any use, reproduction, +# disclosure or distribution of this material and related documentation +# without an express license agreement from NVIDIA CORPORATION or +# its affiliates is strictly prohibited. + +import torch + +import os +import sys +sys.path.insert(0, os.path.join(sys.path[0], '../..')) +import renderutils as ru + +DTYPE=torch.float32 + +def test_bsdf(BATCH, RES, ITR): + kd_cuda = torch.rand(BATCH, RES, RES, 3, dtype=DTYPE, device='cuda', requires_grad=True) + kd_ref = kd_cuda.clone().detach().requires_grad_(True) + arm_cuda = torch.rand(BATCH, RES, RES, 3, dtype=DTYPE, device='cuda', requires_grad=True) + arm_ref = arm_cuda.clone().detach().requires_grad_(True) + pos_cuda = torch.rand(BATCH, RES, RES, 3, dtype=DTYPE, device='cuda', requires_grad=True) + pos_ref = pos_cuda.clone().detach().requires_grad_(True) + nrm_cuda = torch.rand(BATCH, RES, RES, 3, dtype=DTYPE, device='cuda', requires_grad=True) + nrm_ref = nrm_cuda.clone().detach().requires_grad_(True) + view_cuda = torch.rand(BATCH, RES, RES, 3, dtype=DTYPE, device='cuda', requires_grad=True) + view_ref = view_cuda.clone().detach().requires_grad_(True) + light_cuda = torch.rand(BATCH, RES, RES, 3, dtype=DTYPE, device='cuda', requires_grad=True) + light_ref = light_cuda.clone().detach().requires_grad_(True) + target = torch.rand(BATCH, RES, RES, 3, device='cuda') + + start = torch.cuda.Event(enable_timing=True) + end = torch.cuda.Event(enable_timing=True) + + ru.pbr_bsdf(kd_cuda, arm_cuda, pos_cuda, nrm_cuda, view_cuda, light_cuda) + + print("--- Testing: [%d, %d, %d] ---" % (BATCH, RES, RES)) + + start.record() + for i in range(ITR): + ref = ru.pbr_bsdf(kd_ref, arm_ref, pos_ref, nrm_ref, view_ref, light_ref, use_python=True) + end.record() + torch.cuda.synchronize() + print("Pbr BSDF python:", start.elapsed_time(end)) + + start.record() + for i in range(ITR): + cuda = ru.pbr_bsdf(kd_cuda, arm_cuda, pos_cuda, nrm_cuda, view_cuda, light_cuda) + end.record() + torch.cuda.synchronize() + print("Pbr BSDF cuda:", start.elapsed_time(end)) + +test_bsdf(1, 512, 1000) +test_bsdf(16, 512, 1000) +test_bsdf(1, 2048, 1000) diff --git a/render/texture.py b/render/texture.py new file mode 100644 index 0000000..542cf27 --- /dev/null +++ b/render/texture.py @@ -0,0 +1,186 @@ +# Copyright (c) 2020-2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# +# NVIDIA CORPORATION, its affiliates and licensors retain all intellectual +# property and proprietary rights in and to this material, related +# documentation and any modifications thereto. Any use, reproduction, +# disclosure or distribution of this material and related documentation +# without an express license agreement from NVIDIA CORPORATION or +# its affiliates is strictly prohibited. + +import os +import numpy as np +import torch +import nvdiffrast.torch as dr + +from . import util + +###################################################################################### +# Smooth pooling / mip computation with linear gradient upscaling +###################################################################################### + +class texture2d_mip(torch.autograd.Function): + @staticmethod + def forward(ctx, texture): + return util.avg_pool_nhwc(texture, (2,2)) + + @staticmethod + def backward(ctx, dout): + gy, gx = torch.meshgrid(torch.linspace(0.0 + 0.25 / dout.shape[1], 1.0 - 0.25 / dout.shape[1], dout.shape[1]*2, device="cuda"), + torch.linspace(0.0 + 0.25 / dout.shape[2], 1.0 - 0.25 / dout.shape[2], dout.shape[2]*2, device="cuda"), + ) # indexing='ij') + uv = torch.stack((gx, gy), dim=-1) + return dr.texture(dout * 0.25, uv[None, ...].contiguous(), filter_mode='linear', boundary_mode='clamp') + +######################################################################################################## +# Simple texture class. A texture can be either +# - A 3D tensor (using auto mipmaps) +# - A list of 3D tensors (full custom mip hierarchy) +######################################################################################################## + +class Texture2D(torch.nn.Module): + # Initializes a texture from image data. + # Input can be constant value (1D array) or texture (3D array) or mip hierarchy (list of 3d arrays) + def __init__(self, init, min_max=None): + super(Texture2D, self).__init__() + + if isinstance(init, np.ndarray): + init = torch.tensor(init, dtype=torch.float32, device='cuda') + elif isinstance(init, list) and len(init) == 1: + init = init[0] + + if isinstance(init, list): + self.data = list(torch.nn.Parameter(mip.clone().detach(), requires_grad=True) for mip in init) + elif len(init.shape) == 4: + self.data = torch.nn.Parameter(init.clone().detach(), requires_grad=True) + elif len(init.shape) == 3: + self.data = torch.nn.Parameter(init[None, ...].clone().detach(), requires_grad=True) + elif len(init.shape) == 1: + self.data = torch.nn.Parameter(init[None, None, None, :].clone().detach(), requires_grad=True) # Convert constant to 1x1 tensor + else: + assert False, "Invalid texture object" + + self.min_max = min_max + + # Filtered (trilinear) sample texture at a given location + def sample(self, texc, texc_deriv, filter_mode='linear-mipmap-linear'): + if isinstance(self.data, list): + out = dr.texture(self.data[0], texc, texc_deriv, mip=self.data[1:], filter_mode=filter_mode) + else: + if self.data.shape[1] > 1 and self.data.shape[2] > 1: + mips = [self.data] + while mips[-1].shape[1] > 1 and mips[-1].shape[2] > 1: + mips += [texture2d_mip.apply(mips[-1])] + out = dr.texture(mips[0], texc, texc_deriv, mip=mips[1:], filter_mode=filter_mode) + else: + out = dr.texture(self.data, texc, texc_deriv, filter_mode=filter_mode) + return out + + def getRes(self): + return self.getMips()[0].shape[1:3] + + def getChannels(self): + return self.getMips()[0].shape[3] + + def getMips(self): + if isinstance(self.data, list): + return self.data + else: + return [self.data] + + # In-place clamp with no derivative to make sure values are in valid range after training + def clamp_(self): + if self.min_max is not None: + for mip in self.getMips(): + for i in range(mip.shape[-1]): + mip[..., i].clamp_(min=self.min_max[0][i], max=self.min_max[1][i]) + + # In-place clamp with no derivative to make sure values are in valid range after training + def normalize_(self): + with torch.no_grad(): + for mip in self.getMips(): + mip = util.safe_normalize(mip) + +######################################################################################################## +# Helper function to create a trainable texture from a regular texture. The trainable weights are +# initialized with texture data as an initial guess +######################################################################################################## + +def create_trainable(init, res=None, auto_mipmaps=True, min_max=None): + with torch.no_grad(): + if isinstance(init, Texture2D): + assert isinstance(init.data, torch.Tensor) + min_max = init.min_max if min_max is None else min_max + init = init.data + elif isinstance(init, np.ndarray): + init = torch.tensor(init, dtype=torch.float32, device='cuda') + + # Pad to NHWC if needed + if len(init.shape) == 1: # Extend constant to NHWC tensor + init = init[None, None, None, :] + elif len(init.shape) == 3: + init = init[None, ...] + + # Scale input to desired resolution. + if res is not None: + init = util.scale_img_nhwc(init, res) + + # Genreate custom mipchain + if not auto_mipmaps: + mip_chain = [init.clone().detach().requires_grad_(True)] + while mip_chain[-1].shape[1] > 1 or mip_chain[-1].shape[2] > 1: + new_size = [max(mip_chain[-1].shape[1] // 2, 1), max(mip_chain[-1].shape[2] // 2, 1)] + mip_chain += [util.scale_img_nhwc(mip_chain[-1], new_size)] + return Texture2D(mip_chain, min_max=min_max) + else: + return Texture2D(init, min_max=min_max) + +######################################################################################################## +# Convert texture to and from SRGB +######################################################################################################## + +def srgb_to_rgb(texture): + return Texture2D(list(util.srgb_to_rgb(mip) for mip in texture.getMips())) + +def rgb_to_srgb(texture): + return Texture2D(list(util.rgb_to_srgb(mip) for mip in texture.getMips())) + +######################################################################################################## +# Utility functions for loading / storing a texture +######################################################################################################## + +def _load_mip2D(fn, lambda_fn=None, channels=None): + imgdata = torch.tensor(util.load_image(fn), dtype=torch.float32, device='cuda') + if channels is not None: + imgdata = imgdata[..., 0:channels] + if lambda_fn is not None: + imgdata = lambda_fn(imgdata) + return imgdata.detach().clone() + +def load_texture2D(fn, lambda_fn=None, channels=None): + base, ext = os.path.splitext(fn) + if os.path.exists(base + "_0" + ext): + mips = [] + while os.path.exists(base + ("_%d" % len(mips)) + ext): + mips += [_load_mip2D(base + ("_%d" % len(mips)) + ext, lambda_fn, channels)] + return Texture2D(mips) + else: + return Texture2D(_load_mip2D(fn, lambda_fn, channels)) + +def _save_mip2D(fn, mip, mipidx, lambda_fn): + if lambda_fn is not None: + data = lambda_fn(mip).detach().cpu().numpy() + else: + data = mip.detach().cpu().numpy() + + if mipidx is None: + util.save_image(fn, data) + else: + base, ext = os.path.splitext(fn) + util.save_image(base + ("_%d" % mipidx) + ext, data) + +def save_texture2D(fn, tex, lambda_fn=None): + if isinstance(tex.data, list): + for i, mip in enumerate(tex.data): + _save_mip2D(fn, mip[0,...], i, lambda_fn) + else: + _save_mip2D(fn, tex.data[0,...], None, lambda_fn) diff --git a/render/util.py b/render/util.py new file mode 100644 index 0000000..139a46d --- /dev/null +++ b/render/util.py @@ -0,0 +1,465 @@ +# Copyright (c) 2020-2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# +# NVIDIA CORPORATION, its affiliates and licensors retain all intellectual +# property and proprietary rights in and to this material, related +# documentation and any modifications thereto. Any use, reproduction, +# disclosure or distribution of this material and related documentation +# without an express license agreement from NVIDIA CORPORATION or +# its affiliates is strictly prohibited. + +import os +import numpy as np +import torch +import nvdiffrast.torch as dr +import imageio + +#---------------------------------------------------------------------------- +# Vector operations +#---------------------------------------------------------------------------- + +def dot(x: torch.Tensor, y: torch.Tensor) -> torch.Tensor: + return torch.sum(x*y, -1, keepdim=True) + +def reflect(x: torch.Tensor, n: torch.Tensor) -> torch.Tensor: + return 2*dot(x, n)*n - x + +def length(x: torch.Tensor, eps: float =1e-20) -> torch.Tensor: + return torch.sqrt(torch.clamp(dot(x,x), min=eps)) # Clamp to avoid nan gradients because grad(sqrt(0)) = NaN + +def safe_normalize(x: torch.Tensor, eps: float =1e-20) -> torch.Tensor: + return x / length(x, eps) + +def to_hvec(x: torch.Tensor, w: float) -> torch.Tensor: + return torch.nn.functional.pad(x, pad=(0,1), mode='constant', value=w) + +#---------------------------------------------------------------------------- +# sRGB color transforms +#---------------------------------------------------------------------------- + +def _rgb_to_srgb(f: torch.Tensor) -> torch.Tensor: + return torch.where(f <= 0.0031308, f * 12.92, torch.pow(torch.clamp(f, 0.0031308), 1.0/2.4)*1.055 - 0.055) + +def rgb_to_srgb(f: torch.Tensor) -> torch.Tensor: + assert f.shape[-1] == 3 or f.shape[-1] == 4 + out = torch.cat((_rgb_to_srgb(f[..., 0:3]), f[..., 3:4]), dim=-1) if f.shape[-1] == 4 else _rgb_to_srgb(f) + assert out.shape[0] == f.shape[0] and out.shape[1] == f.shape[1] and out.shape[2] == f.shape[2] + return out + +def _srgb_to_rgb(f: torch.Tensor) -> torch.Tensor: + return torch.where(f <= 0.04045, f / 12.92, torch.pow((torch.clamp(f, 0.04045) + 0.055) / 1.055, 2.4)) + +def srgb_to_rgb(f: torch.Tensor) -> torch.Tensor: + assert f.shape[-1] == 3 or f.shape[-1] == 4 + out = torch.cat((_srgb_to_rgb(f[..., 0:3]), f[..., 3:4]), dim=-1) if f.shape[-1] == 4 else _srgb_to_rgb(f) + assert out.shape[0] == f.shape[0] and out.shape[1] == f.shape[1] and out.shape[2] == f.shape[2] + return out + +def reinhard(f: torch.Tensor) -> torch.Tensor: + return f/(1+f) + +#----------------------------------------------------------------------------------- +# Metrics (taken from jaxNerf source code, in order to replicate their measurements) +# +# https://github.com/google-research/google-research/blob/301451a62102b046bbeebff49a760ebeec9707b8/jaxnerf/nerf/utils.py#L266 +# +#----------------------------------------------------------------------------------- + +def mse_to_psnr(mse): + """Compute PSNR given an MSE (we assume the maximum pixel value is 1).""" + return -10. / np.log(10.) * np.log(mse) + +def psnr_to_mse(psnr): + """Compute MSE given a PSNR (we assume the maximum pixel value is 1).""" + return np.exp(-0.1 * np.log(10.) * psnr) + +#---------------------------------------------------------------------------- +# Displacement texture lookup +#---------------------------------------------------------------------------- + +def get_miplevels(texture: np.ndarray) -> float: + minDim = min(texture.shape[0], texture.shape[1]) + return np.floor(np.log2(minDim)) + +def tex_2d(tex_map : torch.Tensor, coords : torch.Tensor, filter='nearest') -> torch.Tensor: + tex_map = tex_map[None, ...] # Add batch dimension + tex_map = tex_map.permute(0, 3, 1, 2) # NHWC -> NCHW + tex = torch.nn.functional.grid_sample(tex_map, coords[None, None, ...] * 2 - 1, mode=filter, align_corners=False) + tex = tex.permute(0, 2, 3, 1) # NCHW -> NHWC + return tex[0, 0, ...] + +#---------------------------------------------------------------------------- +# Cubemap utility functions +#---------------------------------------------------------------------------- + +def cube_to_dir(s, x, y): + if s == 0: rx, ry, rz = torch.ones_like(x), -y, -x + elif s == 1: rx, ry, rz = -torch.ones_like(x), -y, x + elif s == 2: rx, ry, rz = x, torch.ones_like(x), y + elif s == 3: rx, ry, rz = x, -torch.ones_like(x), -y + elif s == 4: rx, ry, rz = x, -y, torch.ones_like(x) + elif s == 5: rx, ry, rz = -x, -y, -torch.ones_like(x) + return torch.stack((rx, ry, rz), dim=-1) + +def latlong_to_cubemap(latlong_map, res): + cubemap = torch.zeros(6, res[0], res[1], latlong_map.shape[-1], dtype=torch.float32, device='cuda') + for s in range(6): + gy, gx = torch.meshgrid(torch.linspace(-1.0 + 1.0 / res[0], 1.0 - 1.0 / res[0], res[0], device='cuda'), + torch.linspace(-1.0 + 1.0 / res[1], 1.0 - 1.0 / res[1], res[1], device='cuda'), + ) # indexing='ij') + v = safe_normalize(cube_to_dir(s, gx, gy)) + + tu = torch.atan2(v[..., 0:1], -v[..., 2:3]) / (2 * np.pi) + 0.5 + tv = torch.acos(torch.clamp(v[..., 1:2], min=-1, max=1)) / np.pi + texcoord = torch.cat((tu, tv), dim=-1) + + cubemap[s, ...] = dr.texture(latlong_map[None, ...], texcoord[None, ...], filter_mode='linear')[0] + return cubemap + +def cubemap_to_latlong(cubemap, res): + gy, gx = torch.meshgrid(torch.linspace( 0.0 + 1.0 / res[0], 1.0 - 1.0 / res[0], res[0], device='cuda'), + torch.linspace(-1.0 + 1.0 / res[1], 1.0 - 1.0 / res[1], res[1], device='cuda'), + ) # indexing='ij') + + sintheta, costheta = torch.sin(gy*np.pi), torch.cos(gy*np.pi) + sinphi, cosphi = torch.sin(gx*np.pi), torch.cos(gx*np.pi) + + reflvec = torch.stack(( + sintheta*sinphi, + costheta, + -sintheta*cosphi + ), dim=-1) + return dr.texture(cubemap[None, ...], reflvec[None, ...].contiguous(), filter_mode='linear', boundary_mode='cube')[0] + +#---------------------------------------------------------------------------- +# Image scaling +#---------------------------------------------------------------------------- + +def scale_img_hwc(x : torch.Tensor, size, mag='bilinear', min='area') -> torch.Tensor: + return scale_img_nhwc(x[None, ...], size, mag, min)[0] + +def scale_img_nhwc(x : torch.Tensor, size, mag='bilinear', min='area') -> torch.Tensor: + assert (x.shape[1] >= size[0] and x.shape[2] >= size[1]) or (x.shape[1] < size[0] and x.shape[2] < size[1]), "Trying to magnify image in one dimension and minify in the other" + y = x.permute(0, 3, 1, 2) # NHWC -> NCHW + if x.shape[1] > size[0] and x.shape[2] > size[1]: # Minification, previous size was bigger + y = torch.nn.functional.interpolate(y, size, mode=min) + else: # Magnification + if mag == 'bilinear' or mag == 'bicubic': + y = torch.nn.functional.interpolate(y, size, mode=mag, align_corners=True) + else: + y = torch.nn.functional.interpolate(y, size, mode=mag) + return y.permute(0, 2, 3, 1).contiguous() # NCHW -> NHWC + +def avg_pool_nhwc(x : torch.Tensor, size) -> torch.Tensor: + y = x.permute(0, 3, 1, 2) # NHWC -> NCHW + y = torch.nn.functional.avg_pool2d(y, size) + return y.permute(0, 2, 3, 1).contiguous() # NCHW -> NHWC + +#---------------------------------------------------------------------------- +# Behaves similar to tf.segment_sum +#---------------------------------------------------------------------------- + +def segment_sum(data: torch.Tensor, segment_ids: torch.Tensor) -> torch.Tensor: + num_segments = torch.unique_consecutive(segment_ids).shape[0] + + # Repeats ids until same dimension as data + if len(segment_ids.shape) == 1: + s = torch.prod(torch.tensor(data.shape[1:], dtype=torch.int64, device='cuda')).long() + segment_ids = segment_ids.repeat_interleave(s).view(segment_ids.shape[0], *data.shape[1:]) + + assert data.shape == segment_ids.shape, "data.shape and segment_ids.shape should be equal" + + shape = [num_segments] + list(data.shape[1:]) + result = torch.zeros(*shape, dtype=torch.float32, device='cuda') + result = result.scatter_add(0, segment_ids, data) + return result + +#---------------------------------------------------------------------------- +# Matrix helpers. +#---------------------------------------------------------------------------- + +def fovx_to_fovy(fovx, aspect): + return np.arctan(np.tan(fovx / 2) / aspect) * 2.0 + +def focal_length_to_fovy(focal_length, sensor_height): + return 2 * np.arctan(0.5 * sensor_height / focal_length) + +# Reworked so this matches gluPerspective / glm::perspective, using fovy +def perspective(fovy=0.7854, aspect=1.0, n=0.1, f=1000.0, device=None): + y = np.tan(fovy / 2) + return torch.tensor([[1/(y*aspect), 0, 0, 0], + [ 0, 1/-y, 0, 0], + [ 0, 0, -(f+n)/(f-n), -(2*f*n)/(f-n)], + [ 0, 0, -1, 0]], dtype=torch.float32, device=device) + +# Reworked so this matches gluPerspective / glm::perspective, using fovy +def perspective_offcenter(fovy, fraction, rx, ry, aspect=1.0, n=0.1, f=1000.0, device=None): + y = np.tan(fovy / 2) + + # Full frustum + R, L = aspect*y, -aspect*y + T, B = y, -y + + # Create a randomized sub-frustum + width = (R-L)*fraction + height = (T-B)*fraction + xstart = (R-L)*rx + ystart = (T-B)*ry + + l = L + xstart + r = l + width + b = B + ystart + t = b + height + + # https://www.scratchapixel.com/lessons/3d-basic-rendering/perspective-and-orthographic-projection-matrix/opengl-perspective-projection-matrix + return torch.tensor([[2/(r-l), 0, (r+l)/(r-l), 0], + [ 0, -2/(t-b), (t+b)/(t-b), 0], + [ 0, 0, -(f+n)/(f-n), -(2*f*n)/(f-n)], + [ 0, 0, -1, 0]], dtype=torch.float32, device=device) + +def translate(x, y, z, device=None): + return torch.tensor([[1, 0, 0, x], + [0, 1, 0, y], + [0, 0, 1, z], + [0, 0, 0, 1]], dtype=torch.float32, device=device) + +def rotate_x(a, device=None): + s, c = np.sin(a), np.cos(a) + return torch.tensor([[1, 0, 0, 0], + [0, c, s, 0], + [0, -s, c, 0], + [0, 0, 0, 1]], dtype=torch.float32, device=device) + +def rotate_y(a, device=None): + s, c = np.sin(a), np.cos(a) + return torch.tensor([[ c, 0, s, 0], + [ 0, 1, 0, 0], + [-s, 0, c, 0], + [ 0, 0, 0, 1]], dtype=torch.float32, device=device) + +def scale(s, device=None): + return torch.tensor([[ s, 0, 0, 0], + [ 0, s, 0, 0], + [ 0, 0, s, 0], + [ 0, 0, 0, 1]], dtype=torch.float32, device=device) + +def lookAt(eye, at, up): + a = eye - at + w = a / torch.linalg.norm(a) + u = torch.cross(up, w) + u = u / torch.linalg.norm(u) + v = torch.cross(w, u) + translate = torch.tensor([[1, 0, 0, -eye[0]], + [0, 1, 0, -eye[1]], + [0, 0, 1, -eye[2]], + [0, 0, 0, 1]], dtype=eye.dtype, device=eye.device) + rotate = torch.tensor([[u[0], u[1], u[2], 0], + [v[0], v[1], v[2], 0], + [w[0], w[1], w[2], 0], + [0, 0, 0, 1]], dtype=eye.dtype, device=eye.device) + return rotate @ translate + +@torch.no_grad() +def random_rotation_translation(t, device=None): + m = np.random.normal(size=[3, 3]) + m[1] = np.cross(m[0], m[2]) + m[2] = np.cross(m[0], m[1]) + m = m / np.linalg.norm(m, axis=1, keepdims=True) + m = np.pad(m, [[0, 1], [0, 1]], mode='constant') + m[3, 3] = 1.0 + m[:3, 3] = np.random.uniform(-t, t, size=[3]) + return torch.tensor(m, dtype=torch.float32, device=device) + +@torch.no_grad() +def random_rotation(device=None): + m = np.random.normal(size=[3, 3]) + m[1] = np.cross(m[0], m[2]) + m[2] = np.cross(m[0], m[1]) + m = m / np.linalg.norm(m, axis=1, keepdims=True) + m = np.pad(m, [[0, 1], [0, 1]], mode='constant') + m[3, 3] = 1.0 + m[:3, 3] = np.array([0,0,0]).astype(np.float32) + return torch.tensor(m, dtype=torch.float32, device=device) + +#---------------------------------------------------------------------------- +# Compute focal points of a set of lines using least squares. +# handy for poorly centered datasets +#---------------------------------------------------------------------------- + +def lines_focal(o, d): + d = safe_normalize(d) + I = torch.eye(3, dtype=o.dtype, device=o.device) + S = torch.sum(d[..., None] @ torch.transpose(d[..., None], 1, 2) - I[None, ...], dim=0) + C = torch.sum((d[..., None] @ torch.transpose(d[..., None], 1, 2) - I[None, ...]) @ o[..., None], dim=0).squeeze(1) + return torch.linalg.pinv(S) @ C + +#---------------------------------------------------------------------------- +# Cosine sample around a vector N +#---------------------------------------------------------------------------- +@torch.no_grad() +def cosine_sample(N, size=None): + # construct local frame + N = N/torch.linalg.norm(N) + + dx0 = torch.tensor([0, N[2], -N[1]], dtype=N.dtype, device=N.device) + dx1 = torch.tensor([-N[2], 0, N[0]], dtype=N.dtype, device=N.device) + + dx = torch.where(dot(dx0, dx0) > dot(dx1, dx1), dx0, dx1) + #dx = dx0 if np.dot(dx0,dx0) > np.dot(dx1,dx1) else dx1 + dx = dx / torch.linalg.norm(dx) + dy = torch.cross(N,dx) + dy = dy / torch.linalg.norm(dy) + + # cosine sampling in local frame + if size is None: + phi = 2.0 * np.pi * np.random.uniform() + s = np.random.uniform() + else: + phi = 2.0 * np.pi * torch.rand(*size, 1, dtype=N.dtype, device=N.device) + s = torch.rand(*size, 1, dtype=N.dtype, device=N.device) + costheta = np.sqrt(s) + sintheta = np.sqrt(1.0 - s) + + # cartesian vector in local space + x = np.cos(phi)*sintheta + y = np.sin(phi)*sintheta + z = costheta + + # local to world + return dx*x + dy*y + N*z + +#---------------------------------------------------------------------------- +# Bilinear downsample by 2x. +#---------------------------------------------------------------------------- + +def bilinear_downsample(x : torch.tensor) -> torch.Tensor: + w = torch.tensor([[1, 3, 3, 1], [3, 9, 9, 3], [3, 9, 9, 3], [1, 3, 3, 1]], dtype=torch.float32, device=x.device) / 64.0 + w = w.expand(x.shape[-1], 1, 4, 4) + x = torch.nn.functional.conv2d(x.permute(0, 3, 1, 2), w, padding=1, stride=2, groups=x.shape[-1]) + return x.permute(0, 2, 3, 1) + +#---------------------------------------------------------------------------- +# Bilinear downsample log(spp) steps +#---------------------------------------------------------------------------- + +def bilinear_downsample(x : torch.tensor, spp) -> torch.Tensor: + w = torch.tensor([[1, 3, 3, 1], [3, 9, 9, 3], [3, 9, 9, 3], [1, 3, 3, 1]], dtype=torch.float32, device=x.device) / 64.0 + g = x.shape[-1] + w = w.expand(g, 1, 4, 4) + x = x.permute(0, 3, 1, 2) # NHWC -> NCHW + steps = int(np.log2(spp)) + for _ in range(steps): + xp = torch.nn.functional.pad(x, (1,1,1,1), mode='replicate') + x = torch.nn.functional.conv2d(xp, w, padding=0, stride=2, groups=g) + return x.permute(0, 2, 3, 1).contiguous() # NCHW -> NHWC + +#---------------------------------------------------------------------------- +# Singleton initialize GLFW +#---------------------------------------------------------------------------- + +_glfw_initialized = False +def init_glfw(): + global _glfw_initialized + try: + import glfw + glfw.ERROR_REPORTING = 'raise' + glfw.default_window_hints() + glfw.window_hint(glfw.VISIBLE, glfw.FALSE) + test = glfw.create_window(8, 8, "Test", None, None) # Create a window and see if not initialized yet + except glfw.GLFWError as e: + if e.error_code == glfw.NOT_INITIALIZED: + glfw.init() + _glfw_initialized = True + +#---------------------------------------------------------------------------- +# Image display function using OpenGL. +#---------------------------------------------------------------------------- + +_glfw_window = None +def display_image(image, title=None): + # Import OpenGL + import OpenGL.GL as gl + import glfw + + # Zoom image if requested. + image = np.asarray(image[..., 0:3]) if image.shape[-1] == 4 else np.asarray(image) + height, width, channels = image.shape + + # Initialize window. + init_glfw() + if title is None: + title = 'Debug window' + global _glfw_window + if _glfw_window is None: + glfw.default_window_hints() + _glfw_window = glfw.create_window(width, height, title, None, None) + glfw.make_context_current(_glfw_window) + glfw.show_window(_glfw_window) + glfw.swap_interval(0) + else: + glfw.make_context_current(_glfw_window) + glfw.set_window_title(_glfw_window, title) + glfw.set_window_size(_glfw_window, width, height) + + # Update window. + glfw.poll_events() + gl.glClearColor(0, 0, 0, 1) + gl.glClear(gl.GL_COLOR_BUFFER_BIT) + gl.glWindowPos2f(0, 0) + gl.glPixelStorei(gl.GL_UNPACK_ALIGNMENT, 1) + gl_format = {3: gl.GL_RGB, 2: gl.GL_RG, 1: gl.GL_LUMINANCE}[channels] + gl_dtype = {'uint8': gl.GL_UNSIGNED_BYTE, 'float32': gl.GL_FLOAT}[image.dtype.name] + gl.glDrawPixels(width, height, gl_format, gl_dtype, image[::-1]) + glfw.swap_buffers(_glfw_window) + if glfw.window_should_close(_glfw_window): + return False + return True + +#---------------------------------------------------------------------------- +# Image save/load helper. +#---------------------------------------------------------------------------- + +def save_image(fn, x : np.ndarray): + try: + if os.path.splitext(fn)[1] == ".png": + imageio.imwrite(fn, np.clip(np.rint(x * 255.0), 0, 255).astype(np.uint8), compress_level=3) # Low compression for faster saving + else: + imageio.imwrite(fn, np.clip(np.rint(x * 255.0), 0, 255).astype(np.uint8)) + except: + print("WARNING: FAILED to save image %s" % fn) + +def save_image_raw(fn, x : np.ndarray): + try: + imageio.imwrite(fn, x) + except: + print("WARNING: FAILED to save image %s" % fn) + + +def load_image_raw(fn) -> np.ndarray: + return imageio.imread(fn) + +def load_image(fn) -> np.ndarray: + img = load_image_raw(fn) + if img.dtype == np.float32: # HDR image + return img + else: # LDR image + return img.astype(np.float32) / 255 + +#---------------------------------------------------------------------------- + +def time_to_text(x): + if x > 3600: + return "%.2f h" % (x / 3600) + elif x > 60: + return "%.2f m" % (x / 60) + else: + return "%.2f s" % x + +#---------------------------------------------------------------------------- + +def checkerboard(res, checker_size) -> np.ndarray: + tiles_y = (res[0] + (checker_size*2) - 1) // (checker_size*2) + tiles_x = (res[1] + (checker_size*2) - 1) // (checker_size*2) + check = np.kron([[1, 0] * tiles_x, [0, 1] * tiles_x] * tiles_y, np.ones((checker_size, checker_size)))*0.33 + 0.33 + check = check[:res[0], :res[1]] + return np.stack((check, check, check), axis=-1) + diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..3e6bf59 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,79 @@ +tqdm +rich +ninja +numpy +scipy +scikit-learn +matplotlib +opencv-python +imageio +imageio-ffmpeg +pandas + +torch +torchvision +torch-ema +einops +tensorboard +tensorboardX + +# for gui +dearpygui + +# for grid_tcnn +# git+https://github.com/NVlabs/tiny-cuda-nn/#subdirectory=bindings/torch + +# for stable-diffusion +huggingface_hub +diffusers >= 0.9.0 +accelerate # required by textural inversion +transformers + +# for dmtet +xatlas +PyMCubes +git+https://github.com/NVlabs/nvdiffrast/ + + +rembg + +carvekit-colab +omegaconf +pytorch-lightning +taming-transformers-rom1504 +kornia +git+https://github.com/openai/CLIP.git + +# for omnidata +gdown + +# below is not necessary if no visualization or mesh exporting +trimesh +pymeshlab + +# cubvh +git+https://github.com/ashawkey/cubvh + +# for dnnutils +timm==0.6.7 # required by MiDaS +easydict +wandb +termcolor + +# for shap-e +git+https://github.com/openai/shap-e + +# optional +jupyterlab + +# for remote debugging +debugpy-run + +# for deepfloyd if +sentencepiece + +# for gpu memory profiling +psutil + +# for metrics +lpips diff --git a/scripts/install_ext.sh b/scripts/install_ext.sh new file mode 100644 index 0000000..228190e --- /dev/null +++ b/scripts/install_ext.sh @@ -0,0 +1,4 @@ +pip install ./raymarching +pip install ./shencoder +pip install ./freqencoder +pip install ./gridencoder \ No newline at end of file diff --git a/scripts/magic123/preprocess_folder.sh b/scripts/magic123/preprocess_folder.sh new file mode 100755 index 0000000..20863cd --- /dev/null +++ b/scripts/magic123/preprocess_folder.sh @@ -0,0 +1,6 @@ +topdir=$1 +imagename=$2 # rgba.png or image.png +for i in $topdir/*; do + echo preprocessing "$i"/$imagename ... + python scripts/preprocess_image.py "$i"/$imagename +done \ No newline at end of file diff --git a/scripts/magic123/run_2dprior.sh b/scripts/magic123/run_2dprior.sh new file mode 100755 index 0000000..996dc99 --- /dev/null +++ b/scripts/magic123/run_2dprior.sh @@ -0,0 +1,75 @@ +#! /bin/bash +#SBATCH -N 1 +#SBATCH --array=0 +#SBATCH -J magic123 +#SBATCH -o slurm_logs/%x.%3a.%A.out +#SBATCH -e slurm_logs/%x.%3a.%A.err +#SBATCH --time=3:00:00 +#SBATCH --gres=gpu:v100:1 +#SBATCH --cpus-per-gpu=6 +#SBATCH --mem=30G +##SBATCH --gpus=1 + +module load gcc/7.5.0 + + +#source ~/.bashrc +#source activate magic123 +source venv_magic123/bin/activate +which python + +nvidia-smi +nvcc --version + +hostname +NUM_GPU_AVAILABLE=`nvidia-smi --query-gpu=name --format=csv,noheader | wc -l` +echo "number of gpus:" $NUM_GPU_AVAILABLE + +RUN_ID=$2 +RUN_ID2=$3 +DATA_DIR=$4 +IMAGE_NAME=$5 +step1=$6 +step2=$7 +FILENAME=$(basename $DATA_DIR) +dataset=$(basename $(dirname $DATA_DIR)) +echo reconstruct $FILENAME under dataset $dataset from folder $DATA_DIR ... + +if (( ${step1} )); then + CUDA_VISIBLE_DEVICES=$1 python main.py -O \ + --text "A high-resolution DSLR image of " \ + --sd_version 1.5 \ + --image ${DATA_DIR}/${IMAGE_NAME} \ + --learned_embeds_path ${DATA_DIR}/learned_embeds.bin \ + --workspace out/magic123-2d/magic123-2d-${RUN_ID}-coarse/$dataset/magic123_2d_${FILENAME}_${RUN_ID}_coarse \ + --optim adam \ + --iters 5000 \ + --guidance SD \ + --lambda_guidance 1 \ + --guidance_scale 100 \ + --latent_iter_ratio 0 \ + --normal_iter_ratio 0.2 \ + --t_range 0.2 0.6 \ + --bg_radius -1 \ + --save_mesh \ + ${@:8} +fi + +if (( ${step2} )); then + CUDA_VISIBLE_DEVICES=$1 python main.py -O \ + --text "A high-resolution DSLR image of " \ + --sd_version 1.5 \ + --image ${DATA_DIR}/${IMAGE_NAME} \ + --learned_embeds_path ${DATA_DIR}/learned_embeds.bin \ + --workspace out/magic123-2d/magic123-2d-${RUN_ID}-${RUN_ID2}/$dataset/magic123_2d_${FILENAME}_${RUN_ID}_${RUN_ID2} \ + --dmtet --init_ckpt out/magic123-2d/magic123-2d-${RUN_ID}-coarse/$dataset/magic123_2d_${FILENAME}_${RUN_ID}_coarse/checkpoints/magic123_2d_${FILENAME}_${RUN_ID}_coarse.pth \ + --iters 5000 \ + --optim adam \ + --latent_iter_ratio 0 \ + --guidance SD \ + --lambda_guidance 1e-3 \ + --guidance_scale 100 \ + --rm_edge \ + --bg_radius -1 \ + --save_mesh +fi diff --git a/scripts/magic123/run_2dprior_notextinv_ironman.sh b/scripts/magic123/run_2dprior_notextinv_ironman.sh new file mode 100755 index 0000000..b73577a --- /dev/null +++ b/scripts/magic123/run_2dprior_notextinv_ironman.sh @@ -0,0 +1,73 @@ +#! /bin/bash +#SBATCH -N 1 +#SBATCH --array=0 +#SBATCH -J magic123 +#SBATCH -o slurm_logs/%x.%3a.%A.out +#SBATCH -e slurm_logs/%x.%3a.%A.err +#SBATCH --time=3:00:00 +#SBATCH --gres=gpu:v100:1 +#SBATCH --cpus-per-gpu=6 +#SBATCH --mem=30G +##SBATCH --gpus=1 + +module load gcc/7.5.0 + + +#source ~/.bashrc +#source activate magic123 +source venv_magic123/bin/activate +which python + +nvidia-smi +nvcc --version + +hostname +NUM_GPU_AVAILABLE=`nvidia-smi --query-gpu=name --format=csv,noheader | wc -l` +echo "number of gpus:" $NUM_GPU_AVAILABLE + +RUN_ID=$2 +RUN_ID2=$3 +DATA_DIR="data/demo/ironman" +IMAGE_NAME="rgba.png" +step1=$4 +step2=$5 +FILENAME=$(basename $DATA_DIR) +dataset=$(basename $(dirname $DATA_DIR)) +echo reconstruct $FILENAME under dataset $dataset from folder $DATA_DIR ... + +if (( ${step1} )); then + CUDA_VISIBLE_DEVICES=$1 python main.py -O \ + --text "A high-resolution DSLR image of a full body ironman" \ + --sd_version 1.5 \ + --image ${DATA_DIR}/${IMAGE_NAME} \ + --workspace out/magic123-2d-noinv/magic123-2d-noinv-${RUN_ID}-coarse/$dataset/magic123-2d-noinv_${FILENAME}_${RUN_ID}_coarse \ + --optim adam \ + --iters 5000 \ + --guidance SD \ + --lambda_guidance 1 \ + --guidance_scale 100 \ + --latent_iter_ratio 0 \ + --normal_iter_ratio 0.2 \ + --t_range 0.2 0.6 \ + --bg_radius -1 \ + --save_mesh \ + ${@:6} +fi + +if (( ${step2} )); then + CUDA_VISIBLE_DEVICES=$1 python main.py -O \ + --text "A high-resolution DSLR image of a full body ironman" \ + --sd_version 1.5 \ + --image ${DATA_DIR}/${IMAGE_NAME} \ + --workspace out/magic123-2d-noinv/magic123-2d-noinv-${RUN_ID}-${RUN_ID2}/$dataset/magic123-2d-noinv_${FILENAME}_${RUN_ID}_${RUN_ID2} \ + --dmtet --init_ckpt out/magic123-2d-noinv/magic123-2d-noinv-${RUN_ID}-coarse/$dataset/magic123-2d-noinv_${FILENAME}_${RUN_ID}_coarse/checkpoints/magic123-2d-noinv_${FILENAME}_${RUN_ID}_coarse.pth \ + --iters 5000 \ + --optim adam \ + --latent_iter_ratio 0 \ + --guidance SD \ + --lambda_guidance 1e-3 \ + --guidance_scale 100 \ + --rm_edge \ + --bg_radius -1 \ + --save_mesh +fi \ No newline at end of file diff --git a/scripts/magic123/run_3dprior.sh b/scripts/magic123/run_3dprior.sh new file mode 100755 index 0000000..b77a9aa --- /dev/null +++ b/scripts/magic123/run_3dprior.sh @@ -0,0 +1,73 @@ +#! /bin/bash +#SBATCH -N 1 +#SBATCH --array=0 +#SBATCH -J magic123 +#SBATCH -o slurm_logs/%x.%3a.%A.out +#SBATCH -e slurm_logs/%x.%3a.%A.err +#SBATCH --time=3:00:00 +#SBATCH --gres=gpu:v100:1 +#SBATCH --cpus-per-gpu=6 +#SBATCH --mem=30G +##SBATCH --gpus=1 + +module load gcc/7.5.0 + + +#source ~/.bashrc +#source activate magic123 +source venv_magic123/bin/activate +which python + +nvidia-smi +nvcc --version + +hostname +NUM_GPU_AVAILABLE=`nvidia-smi --query-gpu=name --format=csv,noheader | wc -l` +echo "number of gpus:" $NUM_GPU_AVAILABLE + +RUN_ID=$2 +RUN_ID2=$3 +DATA_DIR=$4 +IMAGE_NAME=$5 +step1=$6 +step2=$7 +FILENAME=$(basename $DATA_DIR) +dataset=$(basename $(dirname $DATA_DIR)) +echo reconstruct $FILENAME under dataset $dataset from folder $DATA_DIR ... + +if (( ${step1} )); then + CUDA_VISIBLE_DEVICES=$1 python main.py -O \ + --text "A high-resolution DSLR image" \ + --sd_version 1.5 \ + --image ${DATA_DIR}/${IMAGE_NAME} \ + --workspace out/magic123-3d/magic123-3d-${RUN_ID}/$dataset/magic123-3d_${FILENAME}_${RUN_ID}_5k \ + --optim adam \ + --iters 5000 \ + --guidance zero123 \ + --lambda_guidance 40 \ + --guidance_scale 5 \ + --latent_iter_ratio 0 \ + --normal_iter_ratio 0.2 \ + --t_range 0.2 0.6 \ + --bg_radius -1 \ + --save_mesh \ + ${@:8} +fi + +if (( ${step2} )); then + CUDA_VISIBLE_DEVICES=$1 python main.py -O \ + --text "A high-resolution DSLR image" \ + --sd_version 1.5 \ + --image ${DATA_DIR}/${IMAGE_NAME} \ + --workspace out/magic123-3d/magic123-3d-${RUN_ID}-${RUN_ID2}/$dataset/magic123-3d_${FILENAME}_${RUN_ID}_${RUN_ID2} \ + --dmtet --init_ckpt out/magic123-3d/magic123-3d-${RUN_ID}/$dataset/magic123-3d_${FILENAME}_${RUN_ID}_5k/checkpoints/magic123-3d_${FILENAME}_${RUN_ID}_5k.pth \ + --iters 5000 \ + --optim adam \ + --latent_iter_ratio 0 \ + --guidance zero123 \ + --lambda_guidance 0.01 \ + --guidance_scale 5 \ + --bg_radius -1 \ + --rm_edge \ + --save_mesh +fi diff --git a/scripts/magic123/run_both_priors.sh b/scripts/magic123/run_both_priors.sh new file mode 100755 index 0000000..e39a1ca --- /dev/null +++ b/scripts/magic123/run_both_priors.sh @@ -0,0 +1,76 @@ +#! /bin/bash +#SBATCH -N 1 +#SBATCH --array=0 +#SBATCH -J magic123 +#SBATCH -o slurm_logs/%x.%3a.%A.out +#SBATCH -e slurm_logs/%x.%3a.%A.err +#SBATCH --time=3:00:00 +#SBATCH --gres=gpu:v100:1 +#SBATCH --cpus-per-gpu=6 +#SBATCH --mem=30G +##SBATCH --gpus=1 + +module load gcc/7.5.0 + + +#source ~/.bashrc +#source activate magic123 +source venv_magic123/bin/activate +which python + +nvidia-smi +nvcc --version + +hostname +NUM_GPU_AVAILABLE=`nvidia-smi --query-gpu=name --format=csv,noheader | wc -l` +echo "number of gpus:" $NUM_GPU_AVAILABLE + +RUN_ID=$2 # jobname for the first stage +RUN_ID2=$3 # jobname for the second stage +DATA_DIR=$4 # path to the directory containing the images, e.g. data/nerf4/chair +IMAGE_NAME=$5 # name of the image file, e.g. rgba.png +step1=$6 # whether to use the first stage +step2=$7 # whether to use the second stage + +FILENAME=$(basename $DATA_DIR) +dataset=$(basename $(dirname $DATA_DIR)) +echo reconstruct $FILENAME under dataset $dataset from folder $DATA_DIR ... + +if (( ${step1} )); then + CUDA_VISIBLE_DEVICES=$1 python main.py -O \ + --text "A high-resolution DSLR image of " \ + --sd_version 1.5 \ + --image ${DATA_DIR}/${IMAGE_NAME} \ + --learned_embeds_path ${DATA_DIR}/learned_embeds.bin \ + --workspace out/magic123-${RUN_ID}-coarse/$dataset/magic123_${FILENAME}_${RUN_ID}_coarse \ + --optim adam \ + --iters 5000 \ + --guidance SD zero123 \ + --lambda_guidance 1.0 40 \ + --guidance_scale 100 5 \ + --latent_iter_ratio 0 \ + --normal_iter_ratio 0.2 \ + --t_range 0.2 0.6 \ + --bg_radius -1 \ + --save_mesh \ + ${@:8} +fi + +if (( ${step2} )); then + CUDA_VISIBLE_DEVICES=$1 python main.py -O \ + --text "A high-resolution DSLR image of " \ + --sd_version 1.5 \ + --image ${DATA_DIR}/${IMAGE_NAME} \ + --learned_embeds_path ${DATA_DIR}/learned_embeds.bin \ + --workspace out/magic123-${RUN_ID}-${RUN_ID2}/$dataset/magic123_${FILENAME}_${RUN_ID}_${RUN_ID2} \ + --dmtet --init_ckpt out/magic123-${RUN_ID}-coarse/$dataset/magic123_${FILENAME}_${RUN_ID}_coarse/checkpoints/magic123_${FILENAME}_${RUN_ID}_coarse.pth \ + --iters 5000 \ + --optim adam \ + --latent_iter_ratio 0 \ + --guidance SD zero123 \ + --lambda_guidance 1e-3 0.01 \ + --guidance_scale 100 5 \ + --rm_edge \ + --bg_radius -1 \ + --save_mesh +fi \ No newline at end of file diff --git a/scripts/magic123/run_folder_both_priors.sh b/scripts/magic123/run_folder_both_priors.sh new file mode 100755 index 0000000..f7f3bcf --- /dev/null +++ b/scripts/magic123/run_folder_both_priors.sh @@ -0,0 +1,13 @@ +device=$1 +runid=$2 # jobname for the first stage +runid2=$3 # jobname for the second stage +topdir=$4 # path to the directory containing the images, e.g. data/nerf4 +imagename=$5 +step1=$6 +step2=$7 + +for i in $topdir/*; do + echo "$i" + [ -d "$i" ] && echo "$i exists." + bash scripts/magic123/run_both_priors.sh $device $runid "$i" $imagename $step1 $step2 ${@:8} +done diff --git a/scripts/magic123/run_list_both_priors.sh b/scripts/magic123/run_list_both_priors.sh new file mode 100755 index 0000000..c4e4e64 --- /dev/null +++ b/scripts/magic123/run_list_both_priors.sh @@ -0,0 +1,25 @@ +device=$1 +runid=$2 # jobname for the first stage +runid2=$3 # jobname for the second stage +imagename=$4 +step1=$5 +step2=$6 + +examples=( + 'data/realfusion15/teddy_bear/' + 'data/realfusion15/mental_dragon_statue/' + 'data/realfusion15/colorful_teapot/' + 'data/realfusion15/fish_real_nemo/' + 'data/realfusion15/two_cherries' + 'data/realfusion15/watercolor_horse/' + 'data/nerf4/chair' + 'data/nerf4/drums' + 'data/nerf4/ficus' + 'data/nerf4/mic' +) + +for i in "${examples[@]}"; do + echo "$i" + [ -d "$i" ] && echo "$i exists." + bash scripts/magic123/run_both_priors.sh $device $runid "$i" $imagename $step1 $step2 ${@:7} +done diff --git a/scripts/snap/aws_folder.sh b/scripts/snap/aws_folder.sh new file mode 100755 index 0000000..ea15af6 --- /dev/null +++ b/scripts/snap/aws_folder.sh @@ -0,0 +1,21 @@ +script_name=$1 +runid=$2 +runid2=$3 +topdir=$4 +imagename=$5 +run1=$6 +run2=$7 +arguments="${@:8}" + +timestamp=$(date +'%Y%m%d') +for i in $topdir/*; do + echo "$i" + [ -d "$i" ] && echo "$i exists." + example=$(basename $i) + echo ${@:8} + python scripts/snap/submit_cluster_job.py --yaml_folder scripts/snap/yamls \ + --gpu_memory 40 --gpu_num 1 --force_node --cpu_num_per_gpu 6 --memory_per_gpu 30.0 --replicas 1 \ + --project_name magic123 --project_support_alias img2mesh \ + --job_name gqian-$timestamp-$runid-$runid2-$example \ + --command "bash $script_name 0 $runid $runid2 $i $imagename $run1 $run2 $arguments " +done diff --git a/scripts/snap/aws_list.sh b/scripts/snap/aws_list.sh new file mode 100755 index 0000000..5ff711b --- /dev/null +++ b/scripts/snap/aws_list.sh @@ -0,0 +1,27 @@ +script_name=$1 +runid=$2 +runid2=$3 +imagename=$4 +run1=$5 +run2=$6 +arguments="${@:7}" + + +examples=( + 'data/realfusion15/two_donuts/' + 'data/realfusion15/watercolor_horse/' +) + + +timestamp=$(date +'%Y%m%d') +for i in "${examples[@]}"; do + echo "$i" + [ -d "$i" ] && echo "$i exists." + example=$(basename $i) + echo ${@:8} + python scripts/snap/submit_cluster_job.py --yaml_folder scripts/snap/yamls \ + --gpu_memory 40 --gpu_num 1 --force_node --cpu_num_per_gpu 6 --memory_per_gpu 30.0 --replicas 1 \ + --project_name magic123 --project_support_alias img2mesh \ + --job_name gqian-$timestamp-$runid-$runid2-$example \ + --command "bash $script_name 0 $runid $runid2 $i $imagename $run1 $run2 $arguments " +done diff --git a/scripts/snap/submit_cluster_debug.sh b/scripts/snap/submit_cluster_debug.sh new file mode 100755 index 0000000..295a1ad --- /dev/null +++ b/scripts/snap/submit_cluster_debug.sh @@ -0,0 +1,8 @@ +jobname=$1 +timestamp=$(date +'%Y%m%d') +[ -d "$i" ] && echo "$i exists." +python scripts/snap/submit_cluster_job.py --yaml_folder scripts/snap/yamls \ + --gpu_memory 40 --gpu_num 1 --force_node --cpu_num_per_gpu 6 --memory_per_gpu 30.0 --replicas 1 \ + --project_name magic123 --project_support_alias img2mesh \ + --job_name gqian-$timestamp-$1 \ + --command "while :; do sleep 1000; done" diff --git a/scripts/snap/submit_cluster_job.py b/scripts/snap/submit_cluster_job.py new file mode 100644 index 0000000..cdeb82b --- /dev/null +++ b/scripts/snap/submit_cluster_job.py @@ -0,0 +1,99 @@ + +import yaml +import os +import argparse + + +def generate_yaml( + gpu_memory=40, # 40G or 80G? + gpu_num=1, + cpu_num_per_gpu=6, + memory_per_gpu=30, + replicas=1, + project_name='magic123', + project_support_alias='img2mesh', + pre_run_event='mkdir -p /fsx/code && ln -s /nfs/code/gqian /fsx/code/ && cd /fsx/code/gqian/img2mesh', + command="while :; do sleep 1000; done", + job_name='debug', + force_node=False, + **kwargs + ): + data = { + 'docker_image': '440036398022.dkr.ecr.us-west-2.amazonaws.com/facecraft-ml:efa', + 'project_name': project_name, + 'project_support_alias': project_support_alias, + 'team': 'creative_vision', + #'fsx': 'fs-0b933bba2f17fe699', # 100T genai filesystem + 'fsx': 'fs-056caaa56fa5cc5f3', # 2T personal filesystem of gqian + 'gpu_type': 'nvidia-tesla-a100', + 'gpu_num': gpu_num, + 'cpu_num': str(int(cpu_num_per_gpu * gpu_num)), + 'memory': str(int(memory_per_gpu * gpu_num)), + 'gpu_memory': str(int(gpu_memory)), + 'pytorchjob': { + 'replicas': replicas + }, + 'efa': True, + 'script': { + 'pre_run_event': str(pre_run_event), + 'command': str(command), + 'jobs': [ + {'name': job_name} + ] + } + } + if gpu_num == 1 and not force_node: + gpu_yaml = { + 'custom_node_labels': { + 'use_case': 'p4d_debug', + }, + } + else: + gpu_yaml = { + 'custom_node_labels': { + 'snap.com/spine': 'unknown', + 'snap.com/region': 'us-west-2c', + }, + } + data.update(gpu_yaml) + return data + + +if __name__ == "__main__": + parser = argparse.ArgumentParser(description="Script to generate yaml file for AWS Pytorch Job") + parser.add_argument('--yaml_folder', type=str, default='./', help='path to save the yaml folder') + parser.add_argument('--gpu_memory', type=int, default=40, help='GPU memory (in GB)') + parser.add_argument('--gpu_num', type=int, default=1, help='Number of GPUs') + parser.add_argument('--cpu_num_per_gpu', type=int, default=6, help='Number of CPUs per GPU') + parser.add_argument('--memory_per_gpu', type=float, default=30.0, help='Memory per GPU') + parser.add_argument('--replicas', type=int, default=1, help='Number of replicas') + parser.add_argument('--project_name', type=str, default='magic123', help='Project name') + parser.add_argument('--project_support_alias', type=str, default='img2mesh', help='Project support alias') + #parser.add_argument('--pre_run_event', type=str, default='export PATH=/nfs/code/gqian/miniconda3/bin:$PATH && conda init bash && source ~/.bashrc && cd /nfs/code/gqian/img2mesh ', help='Pre-run event command') + parser.add_argument('--pre_run_event', type=str, default='cd /nfs/code/gqian/img2mesh', help='Pre-run event command') + parser.add_argument('--command', type=str, default='while :; do sleep 1000; done', help='Command') + parser.add_argument('--job_name', type=str, default='debug', help='Job name') + parser.add_argument('--force_node', action='store_true', + help="use normal cluster not debug cluster") + args, unknown = parser.parse_known_args() + args.job_name = args.job_name.replace('_', '-').replace('.', '-')[:51] # do not support _ and . in job name, and max length is limited (around 70) + + # "bash scripts/magic123/run_single_bothpriors.sh 0 r256 data/nerf4/drums rgba.png --h 300 --w 300" + data = generate_yaml(**vars(args)) + yaml_str = yaml.safe_dump(data) + + # Write the YAML content to a file + os.makedirs(args.yaml_folder, exist_ok=True) + yaml_path = os.path.join(args.yaml_folder, f'{args.job_name}.yaml') + with open(yaml_path, 'w') as file: + file.write(yaml_str) + print(f'YAML file saved to {yaml_path}') + + # launch the job using snap_rutls + os.system(f'yes yes | snap_rutils cluster run {yaml_path} -s') + + # show the job status + os.system(f'kubectl get pods | grep {args.job_name} ') + + # show the job logs + os.system(f'kubectl logs {args.job_name}-worker-0') diff --git a/scripts/snap/submit_cluster_job.sh b/scripts/snap/submit_cluster_job.sh new file mode 100755 index 0000000..94a454d --- /dev/null +++ b/scripts/snap/submit_cluster_job.sh @@ -0,0 +1,18 @@ +script_name=$1 +runid=$2 +runid2=$3 +i=$4 +imagename=$5 +run1=$6 +run2=$7 +arguments="${@:8}" + +timestamp=$(date +'%Y%m%d') +[ -d "$i" ] && echo "$i exists." +example=$(basename $i) +echo ${@:8} +python scripts/snap/submit_cluster_job.py --yaml_folder scripts/snap/yamls \ + --gpu_memory 40 --gpu_num 1 --force_node --cpu_num_per_gpu 6 --memory_per_gpu 30.0 --replicas 1 \ + --project_name magic123 --project_support_alias img2mesh \ + --job_name gqian-$timestamp-$runid-$runid2-$example \ + --command "bash $script_name 0 $runid $runid2 $i $imagename $run1 $run2 $arguments " diff --git a/scripts/texural_inversion/textural_inversion.sh b/scripts/texural_inversion/textural_inversion.sh new file mode 100644 index 0000000..3c4c0e9 --- /dev/null +++ b/scripts/texural_inversion/textural_inversion.sh @@ -0,0 +1,52 @@ +#! /bin/bash +#SBATCH -N 1 +#SBATCH --array=0 +#SBATCH -J dreamfusion +#SBATCH -o slurm_logs/%x.%3a.%A.out +#SBATCH -e slurm_logs/%x.%3a.%A.err +#SBATCH --time=9:00:00 +#SBATCH --gres=gpu:v100:1 +#SBATCH --cpus-per-gpu=6 +#SBATCH --mem=30G +##SBATCH --gpus=1 + +module load gcc/7.5.0 + +echo "===> Anaconda env loaded" +#source ~/.bashrc +#source activate magic123 +source venv_magic123/bin/activate + +nvidia-smi +nvcc --version + +hostname +NUM_GPU_AVAILABLE=`nvidia-smi --query-gpu=name --format=csv,noheader | wc -l` +echo "number of gpus:" $NUM_GPU_AVAILABLE + + +MODEL_NAME=$2 # "path-to-pretrained-model" runwayml/stable-diffusion-v1-5 +DATA_DIR=$3 # "path-to-dir-containing-your-image" +OUTPUT_DIR=$4 # "path-to-desired-output-dir" +placeholder_token=$5 # _ironman_ +init_token=$6 # ironman + +# run texturaal inversion +CUDA_VISIBLE_DEVICES=$1 python textual-inversion/textual_inversion.py \ + --pretrained_model_name_or_path=$MODEL_NAME \ + --train_data_dir=$DATA_DIR \ + --learnable_property="object" \ + --placeholder_token=$placeholder_token \ + --initializer_token=$init_token \ + --resolution=512 \ + --train_batch_size=16 \ + --gradient_accumulation_steps=1 \ + --max_train_steps=3000 \ + --lr_scheduler="constant" \ + --lr_warmup_steps=0 \ + --output_dir=$OUTPUT_DIR \ + --use_augmentations \ + ${@:7} + +# test textural inversion +CUDA_VISIBLE_DEVICES=$1 python guidance/sd_utils.py --text "A high-resolution DSLR image of " --learned_embeds_path $OUTPUT_DIR --workspace $OUTPUT_DIR \ No newline at end of file diff --git a/scripts/texural_inversion/textural_inversion_list.sh b/scripts/texural_inversion/textural_inversion_list.sh new file mode 100644 index 0000000..da287a9 --- /dev/null +++ b/scripts/texural_inversion/textural_inversion_list.sh @@ -0,0 +1,13 @@ + + +examples=( + 'data/nerf4/chair' + 'data/nerf4/drums' + 'data/nerf4/ficus' + 'data/nerf4/mic' +) + +for i in "${examples[@]}"; do + filename=$(basename "$i") + bash scripts/texural_inversion/textural_inversion.sh 0 runwayml/stable-diffusion-v1-5 "$i"/rgba.png out/texural_inversion/${filename} _nerf_${filename}_ ${filename} --max_train_steps 3000 +done \ No newline at end of file diff --git a/shencoder/__init__.py b/shencoder/__init__.py new file mode 100644 index 0000000..2b55c96 --- /dev/null +++ b/shencoder/__init__.py @@ -0,0 +1 @@ +from .sphere_harmonics import SHEncoder \ No newline at end of file diff --git a/shencoder/backend.py b/shencoder/backend.py new file mode 100644 index 0000000..4971d5e --- /dev/null +++ b/shencoder/backend.py @@ -0,0 +1,41 @@ +import os +from torch.utils.cpp_extension import load + +_src_path = os.path.dirname(os.path.abspath(__file__)) + +nvcc_flags = [ + '-O3', '-std=c++14', + '-U__CUDA_NO_HALF_OPERATORS__', '-U__CUDA_NO_HALF_CONVERSIONS__', '-U__CUDA_NO_HALF2_OPERATORS__', +] + +if os.name == "posix": + c_flags = ['-O3', '-std=c++14'] +elif os.name == "nt": + c_flags = ['/O2', '/std:c++17'] + + # find cl.exe + def find_cl_path(): + import glob + for program_files in [r"C:\\Program Files (x86)", r"C:\\Program Files"]: + for edition in ["Enterprise", "Professional", "BuildTools", "Community"]: + paths = sorted(glob.glob(r"%s\\Microsoft Visual Studio\\*\\%s\\VC\\Tools\\MSVC\\*\\bin\\Hostx64\\x64" % (program_files, edition)), reverse=True) + if paths: + return paths[0] + + # If cl.exe is not on path, try to find it. + if os.system("where cl.exe >nul 2>nul") != 0: + cl_path = find_cl_path() + if cl_path is None: + raise RuntimeError("Could not locate a supported Microsoft Visual C++ installation") + os.environ["PATH"] += ";" + cl_path + +_backend = load(name='_sh_encoder', + extra_cflags=c_flags, + extra_cuda_cflags=nvcc_flags, + sources=[os.path.join(_src_path, 'src', f) for f in [ + 'shencoder.cu', + 'bindings.cpp', + ]], + ) + +__all__ = ['_backend'] \ No newline at end of file diff --git a/shencoder/setup.py b/shencoder/setup.py new file mode 100644 index 0000000..4633ebd --- /dev/null +++ b/shencoder/setup.py @@ -0,0 +1,51 @@ +import os +from setuptools import setup +from torch.utils.cpp_extension import BuildExtension, CUDAExtension + +_src_path = os.path.dirname(os.path.abspath(__file__)) + +nvcc_flags = [ + '-O3', '-std=c++14', + '-U__CUDA_NO_HALF_OPERATORS__', '-U__CUDA_NO_HALF_CONVERSIONS__', '-U__CUDA_NO_HALF2_OPERATORS__', +] + +if os.name == "posix": + c_flags = ['-O3', '-std=c++14'] +elif os.name == "nt": + c_flags = ['/O2', '/std:c++17'] + + # find cl.exe + def find_cl_path(): + import glob + for program_files in [r"C:\\Program Files (x86)", r"C:\\Program Files"]: + for edition in ["Enterprise", "Professional", "BuildTools", "Community"]: + paths = sorted(glob.glob(r"%s\\Microsoft Visual Studio\\*\\%s\\VC\\Tools\\MSVC\\*\\bin\\Hostx64\\x64" % (program_files, edition)), reverse=True) + if paths: + return paths[0] + + # If cl.exe is not on path, try to find it. + if os.system("where cl.exe >nul 2>nul") != 0: + cl_path = find_cl_path() + if cl_path is None: + raise RuntimeError("Could not locate a supported Microsoft Visual C++ installation") + os.environ["PATH"] += ";" + cl_path + +setup( + name='shencoder', # package name, import this to use python API + ext_modules=[ + CUDAExtension( + name='_shencoder', # extension name, import this to use CUDA API + sources=[os.path.join(_src_path, 'src', f) for f in [ + 'shencoder.cu', + 'bindings.cpp', + ]], + extra_compile_args={ + 'cxx': c_flags, + 'nvcc': nvcc_flags, + } + ), + ], + cmdclass={ + 'build_ext': BuildExtension, + } +) \ No newline at end of file diff --git a/shencoder/sphere_harmonics.py b/shencoder/sphere_harmonics.py new file mode 100644 index 0000000..7bab24e --- /dev/null +++ b/shencoder/sphere_harmonics.py @@ -0,0 +1,87 @@ +import numpy as np + +import torch +import torch.nn as nn +from torch.autograd import Function +from torch.autograd.function import once_differentiable +from torch.cuda.amp import custom_bwd, custom_fwd + +try: + import _shencoder as _backend +except ImportError: + from .backend import _backend + +class _sh_encoder(Function): + @staticmethod + @custom_fwd(cast_inputs=torch.float32) # force float32 for better precision + def forward(ctx, inputs, degree, calc_grad_inputs=False): + # inputs: [B, input_dim], float in [-1, 1] + # RETURN: [B, F], float + + inputs = inputs.contiguous() + B, input_dim = inputs.shape # batch size, coord dim + output_dim = degree ** 2 + + outputs = torch.empty(B, output_dim, dtype=inputs.dtype, device=inputs.device) + + if calc_grad_inputs: + dy_dx = torch.empty(B, input_dim * output_dim, dtype=inputs.dtype, device=inputs.device) + else: + dy_dx = None + + _backend.sh_encode_forward(inputs, outputs, B, input_dim, degree, dy_dx) + + ctx.save_for_backward(inputs, dy_dx) + ctx.dims = [B, input_dim, degree] + + return outputs + + @staticmethod + #@once_differentiable + @custom_bwd + def backward(ctx, grad): + # grad: [B, C * C] + + inputs, dy_dx = ctx.saved_tensors + + if dy_dx is not None: + grad = grad.contiguous() + B, input_dim, degree = ctx.dims + grad_inputs = torch.zeros_like(inputs) + _backend.sh_encode_backward(grad, inputs, B, input_dim, degree, dy_dx, grad_inputs) + return grad_inputs, None, None + else: + return None, None, None + + + +sh_encode = _sh_encoder.apply + + +class SHEncoder(nn.Module): + def __init__(self, input_dim=3, degree=4): + super().__init__() + + self.input_dim = input_dim # coord dims, must be 3 + self.degree = degree # 0 ~ 4 + self.output_dim = degree ** 2 + + assert self.input_dim == 3, "SH encoder only support input dim == 3" + assert self.degree > 0 and self.degree <= 8, "SH encoder only supports degree in [1, 8]" + + def __repr__(self): + return f"SHEncoder: input_dim={self.input_dim} degree={self.degree}" + + def forward(self, inputs, size=1): + # inputs: [..., input_dim], normalized real world positions in [-size, size] + # return: [..., degree^2] + + inputs = inputs / size # [-1, 1] + + prefix_shape = list(inputs.shape[:-1]) + inputs = inputs.reshape(-1, self.input_dim) + + outputs = sh_encode(inputs, self.degree, inputs.requires_grad) + outputs = outputs.reshape(prefix_shape + [self.output_dim]) + + return outputs \ No newline at end of file diff --git a/shencoder/src/bindings.cpp b/shencoder/src/bindings.cpp new file mode 100644 index 0000000..595b5b3 --- /dev/null +++ b/shencoder/src/bindings.cpp @@ -0,0 +1,8 @@ +#include + +#include "shencoder.h" + +PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) { + m.def("sh_encode_forward", &sh_encode_forward, "SH encode forward (CUDA)"); + m.def("sh_encode_backward", &sh_encode_backward, "SH encode backward (CUDA)"); +} \ No newline at end of file diff --git a/shencoder/src/shencoder.cu b/shencoder/src/shencoder.cu new file mode 100644 index 0000000..a92e4ab --- /dev/null +++ b/shencoder/src/shencoder.cu @@ -0,0 +1,439 @@ +#include + +#include +#include +#include + +#include +#include + +#include +#include + +#include + + +#define CHECK_CUDA(x) TORCH_CHECK(x.device().is_cuda(), #x " must be a CUDA tensor") +#define CHECK_CONTIGUOUS(x) TORCH_CHECK(x.is_contiguous(), #x " must be a contiguous tensor") +#define CHECK_IS_INT(x) TORCH_CHECK(x.scalar_type() == at::ScalarType::Int, #x " must be an int tensor") +#define CHECK_IS_FLOATING(x) TORCH_CHECK(x.scalar_type() == at::ScalarType::Float || x.scalar_type() == at::ScalarType::Half || x.scalar_type() == at::ScalarType::Double, #x " must be a floating tensor") + + +template +__host__ __device__ T div_round_up(T val, T divisor) { + return (val + divisor - 1) / divisor; +} + +template +__global__ void kernel_sh( + const scalar_t * __restrict__ inputs, + scalar_t * outputs, + uint32_t B, uint32_t D, uint32_t C, + scalar_t * dy_dx +) { + const uint32_t b = threadIdx.x + blockIdx.x * blockDim.x; + if (b >= B) return; + + const uint32_t C2 = C * C; + + // locate + inputs += b * D; + outputs += b * C2; + + scalar_t x = inputs[0], y = inputs[1], z = inputs[2]; + + scalar_t xy=x*y, xz=x*z, yz=y*z, x2=x*x, y2=y*y, z2=z*z, xyz=xy*z; + scalar_t x4=x2*x2, y4=y2*y2, z4=z2*z2; + scalar_t x6=x4*x2, y6=y4*y2, z6=z4*z2; + + auto write_sh = [&]() { + outputs[0] = 0.28209479177387814f ; // 1/(2*sqrt(pi)) + if (C <= 1) { return; } + outputs[1] = -0.48860251190291987f*y ; // -sqrt(3)*y/(2*sqrt(pi)) + outputs[2] = 0.48860251190291987f*z ; // sqrt(3)*z/(2*sqrt(pi)) + outputs[3] = -0.48860251190291987f*x ; // -sqrt(3)*x/(2*sqrt(pi)) + if (C <= 2) { return; } + outputs[4] = 1.0925484305920792f*xy ; // sqrt(15)*xy/(2*sqrt(pi)) + outputs[5] = -1.0925484305920792f*yz ; // -sqrt(15)*yz/(2*sqrt(pi)) + outputs[6] = 0.94617469575755997f*z2 - 0.31539156525251999f ; // sqrt(5)*(3*z2 - 1)/(4*sqrt(pi)) + outputs[7] = -1.0925484305920792f*xz ; // -sqrt(15)*xz/(2*sqrt(pi)) + outputs[8] = 0.54627421529603959f*x2 - 0.54627421529603959f*y2 ; // sqrt(15)*(x2 - y2)/(4*sqrt(pi)) + if (C <= 3) { return; } + outputs[9] = 0.59004358992664352f*y*(-3.0f*x2 + y2) ; // sqrt(70)*y*(-3*x2 + y2)/(8*sqrt(pi)) + outputs[10] = 2.8906114426405538f*xy*z ; // sqrt(105)*xy*z/(2*sqrt(pi)) + outputs[11] = 0.45704579946446572f*y*(1.0f - 5.0f*z2) ; // sqrt(42)*y*(1 - 5*z2)/(8*sqrt(pi)) + outputs[12] = 0.3731763325901154f*z*(5.0f*z2 - 3.0f) ; // sqrt(7)*z*(5*z2 - 3)/(4*sqrt(pi)) + outputs[13] = 0.45704579946446572f*x*(1.0f - 5.0f*z2) ; // sqrt(42)*x*(1 - 5*z2)/(8*sqrt(pi)) + outputs[14] = 1.4453057213202769f*z*(x2 - y2) ; // sqrt(105)*z*(x2 - y2)/(4*sqrt(pi)) + outputs[15] = 0.59004358992664352f*x*(-x2 + 3.0f*y2) ; // sqrt(70)*x*(-x2 + 3*y2)/(8*sqrt(pi)) + if (C <= 4) { return; } + outputs[16] = 2.5033429417967046f*xy*(x2 - y2) ; // 3*sqrt(35)*xy*(x2 - y2)/(4*sqrt(pi)) + outputs[17] = 1.7701307697799304f*yz*(-3.0f*x2 + y2) ; // 3*sqrt(70)*yz*(-3*x2 + y2)/(8*sqrt(pi)) + outputs[18] = 0.94617469575756008f*xy*(7.0f*z2 - 1.0f) ; // 3*sqrt(5)*xy*(7*z2 - 1)/(4*sqrt(pi)) + outputs[19] = 0.66904654355728921f*yz*(3.0f - 7.0f*z2) ; // 3*sqrt(10)*yz*(3 - 7*z2)/(8*sqrt(pi)) + outputs[20] = -3.1735664074561294f*z2 + 3.7024941420321507f*z4 + 0.31735664074561293f ; // 3*(-30*z2 + 35*z4 + 3)/(16*sqrt(pi)) + outputs[21] = 0.66904654355728921f*xz*(3.0f - 7.0f*z2) ; // 3*sqrt(10)*xz*(3 - 7*z2)/(8*sqrt(pi)) + outputs[22] = 0.47308734787878004f*(x2 - y2)*(7.0f*z2 - 1.0f) ; // 3*sqrt(5)*(x2 - y2)*(7*z2 - 1)/(8*sqrt(pi)) + outputs[23] = 1.7701307697799304f*xz*(-x2 + 3.0f*y2) ; // 3*sqrt(70)*xz*(-x2 + 3*y2)/(8*sqrt(pi)) + outputs[24] = -3.7550144126950569f*x2*y2 + 0.62583573544917614f*x4 + 0.62583573544917614f*y4 ; // 3*sqrt(35)*(-6*x2*y2 + x4 + y4)/(16*sqrt(pi)) + if (C <= 5) { return; } + outputs[25] = 0.65638205684017015f*y*(10.0f*x2*y2 - 5.0f*x4 - y4) ; // 3*sqrt(154)*y*(10*x2*y2 - 5*x4 - y4)/(32*sqrt(pi)) + outputs[26] = 8.3026492595241645f*xy*z*(x2 - y2) ; // 3*sqrt(385)*xy*z*(x2 - y2)/(4*sqrt(pi)) + outputs[27] = -0.48923829943525038f*y*(3.0f*x2 - y2)*(9.0f*z2 - 1.0f) ; // -sqrt(770)*y*(3*x2 - y2)*(9*z2 - 1)/(32*sqrt(pi)) + outputs[28] = 4.7935367849733241f*xy*z*(3.0f*z2 - 1.0f) ; // sqrt(1155)*xy*z*(3*z2 - 1)/(4*sqrt(pi)) + outputs[29] = 0.45294665119569694f*y*(14.0f*z2 - 21.0f*z4 - 1.0f) ; // sqrt(165)*y*(14*z2 - 21*z4 - 1)/(16*sqrt(pi)) + outputs[30] = 0.1169503224534236f*z*(-70.0f*z2 + 63.0f*z4 + 15.0f) ; // sqrt(11)*z*(-70*z2 + 63*z4 + 15)/(16*sqrt(pi)) + outputs[31] = 0.45294665119569694f*x*(14.0f*z2 - 21.0f*z4 - 1.0f) ; // sqrt(165)*x*(14*z2 - 21*z4 - 1)/(16*sqrt(pi)) + outputs[32] = 2.3967683924866621f*z*(x2 - y2)*(3.0f*z2 - 1.0f) ; // sqrt(1155)*z*(x2 - y2)*(3*z2 - 1)/(8*sqrt(pi)) + outputs[33] = -0.48923829943525038f*x*(x2 - 3.0f*y2)*(9.0f*z2 - 1.0f) ; // -sqrt(770)*x*(x2 - 3*y2)*(9*z2 - 1)/(32*sqrt(pi)) + outputs[34] = 2.0756623148810411f*z*(-6.0f*x2*y2 + x4 + y4) ; // 3*sqrt(385)*z*(-6*x2*y2 + x4 + y4)/(16*sqrt(pi)) + outputs[35] = 0.65638205684017015f*x*(10.0f*x2*y2 - x4 - 5.0f*y4) ; // 3*sqrt(154)*x*(10*x2*y2 - x4 - 5*y4)/(32*sqrt(pi)) + if (C <= 6) { return; } + outputs[36] = 1.3663682103838286f*xy*(-10.0f*x2*y2 + 3.0f*x4 + 3.0f*y4) ; // sqrt(6006)*xy*(-10*x2*y2 + 3*x4 + 3*y4)/(32*sqrt(pi)) + outputs[37] = 2.3666191622317521f*yz*(10.0f*x2*y2 - 5.0f*x4 - y4) ; // 3*sqrt(2002)*yz*(10*x2*y2 - 5*x4 - y4)/(32*sqrt(pi)) + outputs[38] = 2.0182596029148963f*xy*(x2 - y2)*(11.0f*z2 - 1.0f) ; // 3*sqrt(91)*xy*(x2 - y2)*(11*z2 - 1)/(8*sqrt(pi)) + outputs[39] = -0.92120525951492349f*yz*(3.0f*x2 - y2)*(11.0f*z2 - 3.0f) ; // -sqrt(2730)*yz*(3*x2 - y2)*(11*z2 - 3)/(32*sqrt(pi)) + outputs[40] = 0.92120525951492349f*xy*(-18.0f*z2 + 33.0f*z4 + 1.0f) ; // sqrt(2730)*xy*(-18*z2 + 33*z4 + 1)/(32*sqrt(pi)) + outputs[41] = 0.58262136251873131f*yz*(30.0f*z2 - 33.0f*z4 - 5.0f) ; // sqrt(273)*yz*(30*z2 - 33*z4 - 5)/(16*sqrt(pi)) + outputs[42] = 6.6747662381009842f*z2 - 20.024298714302954f*z4 + 14.684485723822165f*z6 - 0.31784601133814211f ; // sqrt(13)*(105*z2 - 315*z4 + 231*z6 - 5)/(32*sqrt(pi)) + outputs[43] = 0.58262136251873131f*xz*(30.0f*z2 - 33.0f*z4 - 5.0f) ; // sqrt(273)*xz*(30*z2 - 33*z4 - 5)/(16*sqrt(pi)) + outputs[44] = 0.46060262975746175f*(x2 - y2)*(11.0f*z2*(3.0f*z2 - 1.0f) - 7.0f*z2 + 1.0f) ; // sqrt(2730)*(x2 - y2)*(11*z2*(3*z2 - 1) - 7*z2 + 1)/(64*sqrt(pi)) + outputs[45] = -0.92120525951492349f*xz*(x2 - 3.0f*y2)*(11.0f*z2 - 3.0f) ; // -sqrt(2730)*xz*(x2 - 3*y2)*(11*z2 - 3)/(32*sqrt(pi)) + outputs[46] = 0.50456490072872406f*(11.0f*z2 - 1.0f)*(-6.0f*x2*y2 + x4 + y4) ; // 3*sqrt(91)*(11*z2 - 1)*(-6*x2*y2 + x4 + y4)/(32*sqrt(pi)) + outputs[47] = 2.3666191622317521f*xz*(10.0f*x2*y2 - x4 - 5.0f*y4) ; // 3*sqrt(2002)*xz*(10*x2*y2 - x4 - 5*y4)/(32*sqrt(pi)) + outputs[48] = 10.247761577878714f*x2*y4 - 10.247761577878714f*x4*y2 + 0.6831841051919143f*x6 - 0.6831841051919143f*y6 ; // sqrt(6006)*(15*x2*y4 - 15*x4*y2 + x6 - y6)/(64*sqrt(pi)) + if (C <= 7) { return; } + outputs[49] = 0.70716273252459627f*y*(-21.0f*x2*y4 + 35.0f*x4*y2 - 7.0f*x6 + y6) ; // 3*sqrt(715)*y*(-21*x2*y4 + 35*x4*y2 - 7*x6 + y6)/(64*sqrt(pi)) + outputs[50] = 5.2919213236038001f*xy*z*(-10.0f*x2*y2 + 3.0f*x4 + 3.0f*y4) ; // 3*sqrt(10010)*xy*z*(-10*x2*y2 + 3*x4 + 3*y4)/(32*sqrt(pi)) + outputs[51] = -0.51891557872026028f*y*(13.0f*z2 - 1.0f)*(-10.0f*x2*y2 + 5.0f*x4 + y4) ; // -3*sqrt(385)*y*(13*z2 - 1)*(-10*x2*y2 + 5*x4 + y4)/(64*sqrt(pi)) + outputs[52] = 4.1513246297620823f*xy*z*(x2 - y2)*(13.0f*z2 - 3.0f) ; // 3*sqrt(385)*xy*z*(x2 - y2)*(13*z2 - 3)/(8*sqrt(pi)) + outputs[53] = -0.15645893386229404f*y*(3.0f*x2 - y2)*(13.0f*z2*(11.0f*z2 - 3.0f) - 27.0f*z2 + 3.0f) ; // -3*sqrt(35)*y*(3*x2 - y2)*(13*z2*(11*z2 - 3) - 27*z2 + 3)/(64*sqrt(pi)) + outputs[54] = 0.44253269244498261f*xy*z*(-110.0f*z2 + 143.0f*z4 + 15.0f) ; // 3*sqrt(70)*xy*z*(-110*z2 + 143*z4 + 15)/(32*sqrt(pi)) + outputs[55] = 0.090331607582517306f*y*(-135.0f*z2 + 495.0f*z4 - 429.0f*z6 + 5.0f) ; // sqrt(105)*y*(-135*z2 + 495*z4 - 429*z6 + 5)/(64*sqrt(pi)) + outputs[56] = 0.068284276912004949f*z*(315.0f*z2 - 693.0f*z4 + 429.0f*z6 - 35.0f) ; // sqrt(15)*z*(315*z2 - 693*z4 + 429*z6 - 35)/(32*sqrt(pi)) + outputs[57] = 0.090331607582517306f*x*(-135.0f*z2 + 495.0f*z4 - 429.0f*z6 + 5.0f) ; // sqrt(105)*x*(-135*z2 + 495*z4 - 429*z6 + 5)/(64*sqrt(pi)) + outputs[58] = 0.07375544874083044f*z*(x2 - y2)*(143.0f*z2*(3.0f*z2 - 1.0f) - 187.0f*z2 + 45.0f) ; // sqrt(70)*z*(x2 - y2)*(143*z2*(3*z2 - 1) - 187*z2 + 45)/(64*sqrt(pi)) + outputs[59] = -0.15645893386229404f*x*(x2 - 3.0f*y2)*(13.0f*z2*(11.0f*z2 - 3.0f) - 27.0f*z2 + 3.0f) ; // -3*sqrt(35)*x*(x2 - 3*y2)*(13*z2*(11*z2 - 3) - 27*z2 + 3)/(64*sqrt(pi)) + outputs[60] = 1.0378311574405206f*z*(13.0f*z2 - 3.0f)*(-6.0f*x2*y2 + x4 + y4) ; // 3*sqrt(385)*z*(13*z2 - 3)*(-6*x2*y2 + x4 + y4)/(32*sqrt(pi)) + outputs[61] = -0.51891557872026028f*x*(13.0f*z2 - 1.0f)*(-10.0f*x2*y2 + x4 + 5.0f*y4) ; // -3*sqrt(385)*x*(13*z2 - 1)*(-10*x2*y2 + x4 + 5*y4)/(64*sqrt(pi)) + outputs[62] = 2.6459606618019f*z*(15.0f*x2*y4 - 15.0f*x4*y2 + x6 - y6) ; // 3*sqrt(10010)*z*(15*x2*y4 - 15*x4*y2 + x6 - y6)/(64*sqrt(pi)) + outputs[63] = 0.70716273252459627f*x*(-35.0f*x2*y4 + 21.0f*x4*y2 - x6 + 7.0f*y6) ; // 3*sqrt(715)*x*(-35*x2*y4 + 21*x4*y2 - x6 + 7*y6)/(64*sqrt(pi)) + }; + + write_sh(); + + if (dy_dx) { + scalar_t *dx = dy_dx + b * D * C2; + scalar_t *dy = dx + C2; + scalar_t *dz = dy + C2; + + auto write_sh_dx = [&]() { + dx[0] = 0.0f ; // 0 + if (C <= 1) { return; } + dx[1] = 0.0f ; // 0 + dx[2] = 0.0f ; // 0 + dx[3] = -0.48860251190291992f ; // -sqrt(3)/(2*sqrt(pi)) + if (C <= 2) { return; } + dx[4] = 1.0925484305920792f*y ; // sqrt(15)*y/(2*sqrt(pi)) + dx[5] = 0.0f ; // 0 + dx[6] = 0.0f ; // 0 + dx[7] = -1.0925484305920792f*z ; // -sqrt(15)*z/(2*sqrt(pi)) + dx[8] = 1.0925484305920792f*x ; // sqrt(15)*x/(2*sqrt(pi)) + if (C <= 3) { return; } + dx[9] = -3.5402615395598609f*xy ; // -3*sqrt(70)*xy/(4*sqrt(pi)) + dx[10] = 2.8906114426405538f*yz ; // sqrt(105)*yz/(2*sqrt(pi)) + dx[11] = 0.0f ; // 0 + dx[12] = 0.0f ; // 0 + dx[13] = 0.45704579946446572f - 2.2852289973223288f*z2 ; // sqrt(42)*(1 - 5*z2)/(8*sqrt(pi)) + dx[14] = 2.8906114426405538f*xz ; // sqrt(105)*xz/(2*sqrt(pi)) + dx[15] = -1.7701307697799304f*x2 + 1.7701307697799304f*y2 ; // 3*sqrt(70)*(-x2 + y2)/(8*sqrt(pi)) + if (C <= 4) { return; } + dx[16] = 2.5033429417967046f*y*(3.0f*x2 - y2) ; // 3*sqrt(35)*y*(3*x2 - y2)/(4*sqrt(pi)) + dx[17] = -10.620784618679583f*xy*z ; // -9*sqrt(70)*xy*z/(4*sqrt(pi)) + dx[18] = 0.94617469575756008f*y*(7.0f*z2 - 1.0f) ; // 3*sqrt(5)*y*(7*z2 - 1)/(4*sqrt(pi)) + dx[19] = 0.0f ; // 0 + dx[20] = 0.0f ; // 0 + dx[21] = 0.66904654355728921f*z*(3.0f - 7.0f*z2) ; // 3*sqrt(10)*z*(3 - 7*z2)/(8*sqrt(pi)) + dx[22] = 0.94617469575756008f*x*(7.0f*z2 - 1.0f) ; // 3*sqrt(5)*x*(7*z2 - 1)/(4*sqrt(pi)) + dx[23] = 5.3103923093397913f*z*(-x2 + y2) ; // 9*sqrt(70)*z*(-x2 + y2)/(8*sqrt(pi)) + dx[24] = 2.5033429417967046f*x*(x2 - 3.0f*y2) ; // 3*sqrt(35)*x*(x2 - 3*y2)/(4*sqrt(pi)) + if (C <= 5) { return; } + dx[25] = 13.127641136803401f*xy*(-x2 + y2) ; // 15*sqrt(154)*xy*(-x2 + y2)/(8*sqrt(pi)) + dx[26] = 8.3026492595241645f*yz*(3.0f*x2 - y2) ; // 3*sqrt(385)*yz*(3*x2 - y2)/(4*sqrt(pi)) + dx[27] = 2.9354297966115022f*xy*(1.0f - 9.0f*z2) ; // 3*sqrt(770)*xy*(1 - 9*z2)/(16*sqrt(pi)) + dx[28] = 4.7935367849733241f*yz*(3.0f*z2 - 1.0f) ; // sqrt(1155)*yz*(3*z2 - 1)/(4*sqrt(pi)) + dx[29] = 0.0f ; // 0 + dx[30] = 0.0f ; // 0 + dx[31] = 6.3412531167397574f*z2 - 9.5118796751096362f*z4 - 0.45294665119569694f ; // sqrt(165)*(14*z2 - 21*z4 - 1)/(16*sqrt(pi)) + dx[32] = 4.7935367849733241f*xz*(3.0f*z2 - 1.0f) ; // sqrt(1155)*xz*(3*z2 - 1)/(4*sqrt(pi)) + dx[33] = -13.209434084751759f*x2*z2 + 1.4677148983057511f*x2 + 13.209434084751759f*y2*z2 - 1.4677148983057511f*y2 ; // 3*sqrt(770)*(-9*x2*z2 + x2 + 9*y2*z2 - y2)/(32*sqrt(pi)) + dx[34] = 8.3026492595241645f*xz*(x2 - 3.0f*y2) ; // 3*sqrt(385)*xz*(x2 - 3*y2)/(4*sqrt(pi)) + dx[35] = 19.6914617052051f*x2*y2 - 3.2819102842008503f*x4 - 3.2819102842008503f*y4 ; // 15*sqrt(154)*(6*x2*y2 - x4 - y4)/(32*sqrt(pi)) + if (C <= 6) { return; } + dx[36] = 4.0991046311514854f*y*(-10.0f*x2*y2 + 5.0f*x4 + y4) ; // 3*sqrt(6006)*y*(-10*x2*y2 + 5*x4 + y4)/(32*sqrt(pi)) + dx[37] = 47.332383244635047f*xy*z*(-x2 + y2) ; // 15*sqrt(2002)*xy*z*(-x2 + y2)/(8*sqrt(pi)) + dx[38] = 2.0182596029148963f*y*(3.0f*x2 - y2)*(11.0f*z2 - 1.0f) ; // 3*sqrt(91)*y*(3*x2 - y2)*(11*z2 - 1)/(8*sqrt(pi)) + dx[39] = 5.5272315570895412f*xy*z*(3.0f - 11.0f*z2) ; // 3*sqrt(2730)*xy*z*(3 - 11*z2)/(16*sqrt(pi)) + dx[40] = 0.92120525951492349f*y*(-18.0f*z2 + 33.0f*z4 + 1.0f) ; // sqrt(2730)*y*(-18*z2 + 33*z4 + 1)/(32*sqrt(pi)) + dx[41] = 0.0f ; // 0 + dx[42] = 0.0f ; // 0 + dx[43] = 0.58262136251873131f*z*(30.0f*z2 - 33.0f*z4 - 5.0f) ; // sqrt(273)*z*(30*z2 - 33*z4 - 5)/(16*sqrt(pi)) + dx[44] = 0.92120525951492349f*x*(-18.0f*z2 + 33.0f*z4 + 1.0f) ; // sqrt(2730)*x*(-18*z2 + 33*z4 + 1)/(32*sqrt(pi)) + dx[45] = -2.7636157785447706f*z*(x2 - y2)*(11.0f*z2 - 3.0f) ; // -3*sqrt(2730)*z*(x2 - y2)*(11*z2 - 3)/(32*sqrt(pi)) + dx[46] = 2.0182596029148963f*x*(x2 - 3.0f*y2)*(11.0f*z2 - 1.0f) ; // 3*sqrt(91)*x*(x2 - 3*y2)*(11*z2 - 1)/(8*sqrt(pi)) + dx[47] = 11.833095811158762f*z*(6.0f*x2*y2 - x4 - y4) ; // 15*sqrt(2002)*z*(6*x2*y2 - x4 - y4)/(32*sqrt(pi)) + dx[48] = 4.0991046311514854f*x*(-10.0f*x2*y2 + x4 + 5.0f*y4) ; // 3*sqrt(6006)*x*(-10*x2*y2 + x4 + 5*y4)/(32*sqrt(pi)) + if (C <= 7) { return; } + dx[49] = 9.9002782553443485f*xy*(10.0f*x2*y2 - 3.0f*x4 - 3.0f*y4) ; // 21*sqrt(715)*xy*(10*x2*y2 - 3*x4 - 3*y4)/(32*sqrt(pi)) + dx[50] = 15.875763970811402f*yz*(-10.0f*x2*y2 + 5.0f*x4 + y4) ; // 9*sqrt(10010)*yz*(-10*x2*y2 + 5*x4 + y4)/(32*sqrt(pi)) + dx[51] = -10.378311574405206f*xy*(x2 - y2)*(13.0f*z2 - 1.0f) ; // -15*sqrt(385)*xy*(x2 - y2)*(13*z2 - 1)/(16*sqrt(pi)) + dx[52] = 4.1513246297620823f*yz*(3.0f*x2 - y2)*(13.0f*z2 - 3.0f) ; // 3*sqrt(385)*yz*(3*x2 - y2)*(13*z2 - 3)/(8*sqrt(pi)) + dx[53] = 0.93875360317376422f*xy*(66.0f*z2 - 143.0f*z4 - 3.0f) ; // 9*sqrt(35)*xy*(66*z2 - 143*z4 - 3)/(32*sqrt(pi)) + dx[54] = 0.44253269244498261f*yz*(-110.0f*z2 + 143.0f*z4 + 15.0f) ; // 3*sqrt(70)*yz*(-110*z2 + 143*z4 + 15)/(32*sqrt(pi)) + dx[55] = 0.0f ; // 0 + dx[56] = 0.0f ; // 0 + dx[57] = -12.194767023639836f*z2 + 44.714145753346067f*z4 - 38.752259652899923f*z6 + 0.45165803791258652f ; // sqrt(105)*(-135*z2 + 495*z4 - 429*z6 + 5)/(64*sqrt(pi)) + dx[58] = 0.44253269244498261f*xz*(-110.0f*z2 + 143.0f*z4 + 15.0f) ; // 3*sqrt(70)*xz*(-110*z2 + 143*z4 + 15)/(32*sqrt(pi)) + dx[59] = 30.97886890473422f*x2*z2 - 67.120882626924143f*x2*z4 - 1.4081304047606462f*x2 - 30.97886890473422f*y2*z2 + 67.120882626924143f*y2*z4 + 1.4081304047606462f*y2 ; // 9*sqrt(35)*(66*x2*z2 - 143*x2*z4 - 3*x2 - 66*y2*z2 + 143*y2*z4 + 3*y2)/(64*sqrt(pi)) + dx[60] = 4.1513246297620823f*xz*(x2 - 3.0f*y2)*(13.0f*z2 - 3.0f) ; // 3*sqrt(385)*xz*(x2 - 3*y2)*(13*z2 - 3)/(8*sqrt(pi)) + dx[61] = -0.51891557872026028f*(13.0f*z2 - 1.0f)*(-10.0f*x2*y2 + 4.0f*x2*(x2 - 5.0f*y2) + x4 + 5.0f*y4) ; // -3*sqrt(385)*(13*z2 - 1)*(-10*x2*y2 + 4*x2*(x2 - 5*y2) + x4 + 5*y4)/(64*sqrt(pi)) + dx[62] = 15.875763970811402f*xz*(-10.0f*x2*y2 + x4 + 5.0f*y4) ; // 9*sqrt(10010)*xz*(-10*x2*y2 + x4 + 5*y4)/(32*sqrt(pi)) + dx[63] = -74.252086915082614f*x2*y4 + 74.252086915082614f*x4*y2 - 4.9501391276721742f*x6 + 4.9501391276721742f*y6 ; // 21*sqrt(715)*(-15*x2*y4 + 15*x4*y2 - x6 + y6)/(64*sqrt(pi)) + }; + + auto write_sh_dy = [&]() { + dy[0] = 0.0f ; // 0 + if (C <= 1) { return; } + dy[1] = -0.48860251190291992f ; // -sqrt(3)/(2*sqrt(pi)) + dy[2] = 0.0f ; // 0 + dy[3] = 0.0f ; // 0 + if (C <= 2) { return; } + dy[4] = 1.0925484305920792f*x ; // sqrt(15)*x/(2*sqrt(pi)) + dy[5] = -1.0925484305920792f*z ; // -sqrt(15)*z/(2*sqrt(pi)) + dy[6] = 0.0f ; // 0 + dy[7] = 0.0f ; // 0 + dy[8] = -1.0925484305920792f*y ; // -sqrt(15)*y/(2*sqrt(pi)) + if (C <= 3) { return; } + dy[9] = -1.7701307697799304f*x2 + 1.7701307697799304f*y2 ; // 3*sqrt(70)*(-x2 + y2)/(8*sqrt(pi)) + dy[10] = 2.8906114426405538f*xz ; // sqrt(105)*xz/(2*sqrt(pi)) + dy[11] = 0.45704579946446572f - 2.2852289973223288f*z2 ; // sqrt(42)*(1 - 5*z2)/(8*sqrt(pi)) + dy[12] = 0.0f ; // 0 + dy[13] = 0.0f ; // 0 + dy[14] = -2.8906114426405538f*yz ; // -sqrt(105)*yz/(2*sqrt(pi)) + dy[15] = 3.5402615395598609f*xy ; // 3*sqrt(70)*xy/(4*sqrt(pi)) + if (C <= 4) { return; } + dy[16] = 2.5033429417967046f*x*(x2 - 3.0f*y2) ; // 3*sqrt(35)*x*(x2 - 3*y2)/(4*sqrt(pi)) + dy[17] = 5.3103923093397913f*z*(-x2 + y2) ; // 9*sqrt(70)*z*(-x2 + y2)/(8*sqrt(pi)) + dy[18] = 0.94617469575756008f*x*(7.0f*z2 - 1.0f) ; // 3*sqrt(5)*x*(7*z2 - 1)/(4*sqrt(pi)) + dy[19] = 0.66904654355728921f*z*(3.0f - 7.0f*z2) ; // 3*sqrt(10)*z*(3 - 7*z2)/(8*sqrt(pi)) + dy[20] = 0.0f ; // 0 + dy[21] = 0.0f ; // 0 + dy[22] = 0.94617469575756008f*y*(1.0f - 7.0f*z2) ; // 3*sqrt(5)*y*(1 - 7*z2)/(4*sqrt(pi)) + dy[23] = 10.620784618679583f*xy*z ; // 9*sqrt(70)*xy*z/(4*sqrt(pi)) + dy[24] = 2.5033429417967046f*y*(-3.0f*x2 + y2) ; // 3*sqrt(35)*y*(-3*x2 + y2)/(4*sqrt(pi)) + if (C <= 5) { return; } + dy[25] = 19.6914617052051f*x2*y2 - 3.2819102842008503f*x4 - 3.2819102842008503f*y4 ; // 15*sqrt(154)*(6*x2*y2 - x4 - y4)/(32*sqrt(pi)) + dy[26] = 8.3026492595241645f*xz*(x2 - 3.0f*y2) ; // 3*sqrt(385)*xz*(x2 - 3*y2)/(4*sqrt(pi)) + dy[27] = -1.4677148983057511f*(x2 - y2)*(9.0f*z2 - 1.0f) ; // -3*sqrt(770)*(x2 - y2)*(9*z2 - 1)/(32*sqrt(pi)) + dy[28] = 4.7935367849733241f*xz*(3.0f*z2 - 1.0f) ; // sqrt(1155)*xz*(3*z2 - 1)/(4*sqrt(pi)) + dy[29] = 6.3412531167397574f*z2 - 9.5118796751096362f*z4 - 0.45294665119569694f ; // sqrt(165)*(14*z2 - 21*z4 - 1)/(16*sqrt(pi)) + dy[30] = 0.0f ; // 0 + dy[31] = 0.0f ; // 0 + dy[32] = 4.7935367849733241f*yz*(1.0f - 3.0f*z2) ; // sqrt(1155)*yz*(1 - 3*z2)/(4*sqrt(pi)) + dy[33] = 2.9354297966115022f*xy*(9.0f*z2 - 1.0f) ; // 3*sqrt(770)*xy*(9*z2 - 1)/(16*sqrt(pi)) + dy[34] = 8.3026492595241645f*yz*(-3.0f*x2 + y2) ; // 3*sqrt(385)*yz*(-3*x2 + y2)/(4*sqrt(pi)) + dy[35] = 13.127641136803401f*xy*(x2 - y2) ; // 15*sqrt(154)*xy*(x2 - y2)/(8*sqrt(pi)) + if (C <= 6) { return; } + dy[36] = 4.0991046311514854f*x*(-10.0f*x2*y2 + x4 + 5.0f*y4) ; // 3*sqrt(6006)*x*(-10*x2*y2 + x4 + 5*y4)/(32*sqrt(pi)) + dy[37] = 11.833095811158762f*z*(6.0f*x2*y2 - x4 - y4) ; // 15*sqrt(2002)*z*(6*x2*y2 - x4 - y4)/(32*sqrt(pi)) + dy[38] = 2.0182596029148963f*x*(x2 - 3.0f*y2)*(11.0f*z2 - 1.0f) ; // 3*sqrt(91)*x*(x2 - 3*y2)*(11*z2 - 1)/(8*sqrt(pi)) + dy[39] = -2.7636157785447706f*z*(x2 - y2)*(11.0f*z2 - 3.0f) ; // -3*sqrt(2730)*z*(x2 - y2)*(11*z2 - 3)/(32*sqrt(pi)) + dy[40] = 0.92120525951492349f*x*(-18.0f*z2 + 33.0f*z4 + 1.0f) ; // sqrt(2730)*x*(-18*z2 + 33*z4 + 1)/(32*sqrt(pi)) + dy[41] = 0.58262136251873131f*z*(30.0f*z2 - 33.0f*z4 - 5.0f) ; // sqrt(273)*z*(30*z2 - 33*z4 - 5)/(16*sqrt(pi)) + dy[42] = 0.0f ; // 0 + dy[43] = 0.0f ; // 0 + dy[44] = 0.92120525951492349f*y*(18.0f*z2 - 33.0f*z4 - 1.0f) ; // sqrt(2730)*y*(18*z2 - 33*z4 - 1)/(32*sqrt(pi)) + dy[45] = 5.5272315570895412f*xy*z*(11.0f*z2 - 3.0f) ; // 3*sqrt(2730)*xy*z*(11*z2 - 3)/(16*sqrt(pi)) + dy[46] = -2.0182596029148963f*y*(3.0f*x2 - y2)*(11.0f*z2 - 1.0f) ; // -3*sqrt(91)*y*(3*x2 - y2)*(11*z2 - 1)/(8*sqrt(pi)) + dy[47] = 47.332383244635047f*xy*z*(x2 - y2) ; // 15*sqrt(2002)*xy*z*(x2 - y2)/(8*sqrt(pi)) + dy[48] = 4.0991046311514854f*y*(10.0f*x2*y2 - 5.0f*x4 - y4) ; // 3*sqrt(6006)*y*(10*x2*y2 - 5*x4 - y4)/(32*sqrt(pi)) + if (C <= 7) { return; } + dy[49] = -74.252086915082614f*x2*y4 + 74.252086915082614f*x4*y2 - 4.9501391276721742f*x6 + 4.9501391276721742f*y6 ; // 21*sqrt(715)*(-15*x2*y4 + 15*x4*y2 - x6 + y6)/(64*sqrt(pi)) + dy[50] = 15.875763970811402f*xz*(-10.0f*x2*y2 + x4 + 5.0f*y4) ; // 9*sqrt(10010)*xz*(-10*x2*y2 + x4 + 5*y4)/(32*sqrt(pi)) + dy[51] = 0.51891557872026028f*(13.0f*z2 - 1.0f)*(10.0f*x2*y2 - 5.0f*x4 + 4.0f*y2*(5.0f*x2 - y2) - y4) ; // 3*sqrt(385)*(13*z2 - 1)*(10*x2*y2 - 5*x4 + 4*y2*(5*x2 - y2) - y4)/(64*sqrt(pi)) + dy[52] = 4.1513246297620823f*xz*(x2 - 3.0f*y2)*(13.0f*z2 - 3.0f) ; // 3*sqrt(385)*xz*(x2 - 3*y2)*(13*z2 - 3)/(8*sqrt(pi)) + dy[53] = -0.46937680158688211f*(x2 - y2)*(13.0f*z2*(11.0f*z2 - 3.0f) - 27.0f*z2 + 3.0f) ; // -9*sqrt(35)*(x2 - y2)*(13*z2*(11*z2 - 3) - 27*z2 + 3)/(64*sqrt(pi)) + dy[54] = 0.44253269244498261f*xz*(-110.0f*z2 + 143.0f*z4 + 15.0f) ; // 3*sqrt(70)*xz*(-110*z2 + 143*z4 + 15)/(32*sqrt(pi)) + dy[55] = -12.194767023639836f*z2 + 44.714145753346067f*z4 - 38.752259652899923f*z6 + 0.45165803791258652f ; // sqrt(105)*(-135*z2 + 495*z4 - 429*z6 + 5)/(64*sqrt(pi)) + dy[56] = 0.0f ; // 0 + dy[57] = 0.0f ; // 0 + dy[58] = 0.44253269244498261f*yz*(110.0f*z2 - 143.0f*z4 - 15.0f) ; // 3*sqrt(70)*yz*(110*z2 - 143*z4 - 15)/(32*sqrt(pi)) + dy[59] = 0.93875360317376422f*xy*(-66.0f*z2 + 143.0f*z4 + 3.0f) ; // 9*sqrt(35)*xy*(-66*z2 + 143*z4 + 3)/(32*sqrt(pi)) + dy[60] = -4.1513246297620823f*yz*(3.0f*x2 - y2)*(13.0f*z2 - 3.0f) ; // -3*sqrt(385)*yz*(3*x2 - y2)*(13*z2 - 3)/(8*sqrt(pi)) + dy[61] = 10.378311574405206f*xy*(x2 - y2)*(13.0f*z2 - 1.0f) ; // 15*sqrt(385)*xy*(x2 - y2)*(13*z2 - 1)/(16*sqrt(pi)) + dy[62] = 15.875763970811402f*yz*(10.0f*x2*y2 - 5.0f*x4 - y4) ; // 9*sqrt(10010)*yz*(10*x2*y2 - 5*x4 - y4)/(32*sqrt(pi)) + dy[63] = 9.9002782553443485f*xy*(-10.0f*x2*y2 + 3.0f*x4 + 3.0f*y4) ; // 21*sqrt(715)*xy*(-10*x2*y2 + 3*x4 + 3*y4)/(32*sqrt(pi)) + }; + + auto write_sh_dz = [&]() { + dz[0] = 0.0f ; // 0 + if (C <= 1) { return; } + dz[1] = 0.0f ; // 0 + dz[2] = 0.48860251190291992f ; // sqrt(3)/(2*sqrt(pi)) + dz[3] = 0.0f ; // 0 + if (C <= 2) { return; } + dz[4] = 0.0f ; // 0 + dz[5] = -1.0925484305920792f*y ; // -sqrt(15)*y/(2*sqrt(pi)) + dz[6] = 1.8923493915151202f*z ; // 3*sqrt(5)*z/(2*sqrt(pi)) + dz[7] = -1.0925484305920792f*x ; // -sqrt(15)*x/(2*sqrt(pi)) + dz[8] = 0.0f ; // 0 + if (C <= 3) { return; } + dz[9] = 0.0f ; // 0 + dz[10] = 2.8906114426405538f*xy ; // sqrt(105)*xy/(2*sqrt(pi)) + dz[11] = -4.5704579946446566f*yz ; // -5*sqrt(42)*yz/(4*sqrt(pi)) + dz[12] = 5.597644988851731f*z2 - 1.1195289977703462f ; // 3*sqrt(7)*(5*z2 - 1)/(4*sqrt(pi)) + dz[13] = -4.5704579946446566f*xz ; // -5*sqrt(42)*xz/(4*sqrt(pi)) + dz[14] = 1.4453057213202769f*x2 - 1.4453057213202769f*y2 ; // sqrt(105)*(x2 - y2)/(4*sqrt(pi)) + dz[15] = 0.0f ; // 0 + if (C <= 4) { return; } + dz[16] = 0.0f ; // 0 + dz[17] = 1.7701307697799304f*y*(-3.0f*x2 + y2) ; // 3*sqrt(70)*y*(-3*x2 + y2)/(8*sqrt(pi)) + dz[18] = 13.246445740605839f*xy*z ; // 21*sqrt(5)*xy*z/(2*sqrt(pi)) + dz[19] = 2.0071396306718676f*y*(1.0f - 7.0f*z2) ; // 9*sqrt(10)*y*(1 - 7*z2)/(8*sqrt(pi)) + dz[20] = 14.809976568128603f*pow(z, 3) - 6.3471328149122579f*z ; // (105*z**3 - 45*z)/(4*sqrt(pi)) + dz[21] = 2.0071396306718676f*x*(1.0f - 7.0f*z2) ; // 9*sqrt(10)*x*(1 - 7*z2)/(8*sqrt(pi)) + dz[22] = 6.6232228703029197f*z*(x2 - y2) ; // 21*sqrt(5)*z*(x2 - y2)/(4*sqrt(pi)) + dz[23] = 1.7701307697799304f*x*(-x2 + 3.0f*y2) ; // 3*sqrt(70)*x*(-x2 + 3*y2)/(8*sqrt(pi)) + dz[24] = 0.0f ; // 0 + if (C <= 5) { return; } + dz[25] = 0.0f ; // 0 + dz[26] = 8.3026492595241645f*xy*(x2 - y2) ; // 3*sqrt(385)*xy*(x2 - y2)/(4*sqrt(pi)) + dz[27] = 8.8062893898345074f*yz*(-3.0f*x2 + y2) ; // 9*sqrt(770)*yz*(-3*x2 + y2)/(16*sqrt(pi)) + dz[28] = 4.7935367849733241f*xy*(9.0f*z2 - 1.0f) ; // sqrt(1155)*xy*(9*z2 - 1)/(4*sqrt(pi)) + dz[29] = 12.682506233479513f*yz*(1.0f - 3.0f*z2) ; // 7*sqrt(165)*yz*(1 - 3*z2)/(4*sqrt(pi)) + dz[30] = -24.559567715218954f*z2 + 36.839351572828434f*z4 + 1.754254836801354f ; // 15*sqrt(11)*(-14*z2 + 21*z4 + 1)/(16*sqrt(pi)) + dz[31] = 12.682506233479513f*xz*(1.0f - 3.0f*z2) ; // 7*sqrt(165)*xz*(1 - 3*z2)/(4*sqrt(pi)) + dz[32] = 2.3967683924866621f*(x2 - y2)*(9.0f*z2 - 1.0f) ; // sqrt(1155)*(x2 - y2)*(9*z2 - 1)/(8*sqrt(pi)) + dz[33] = 8.8062893898345074f*xz*(-x2 + 3.0f*y2) ; // 9*sqrt(770)*xz*(-x2 + 3*y2)/(16*sqrt(pi)) + dz[34] = -12.453973889286246f*x2*y2 + 2.0756623148810411f*x4 + 2.0756623148810411f*y4 ; // 3*sqrt(385)*(-6*x2*y2 + x4 + y4)/(16*sqrt(pi)) + dz[35] = 0.0f ; // 0 + if (C <= 6) { return; } + dz[36] = 0.0f ; // 0 + dz[37] = 2.3666191622317521f*y*(10.0f*x2*y2 - 5.0f*x4 - y4) ; // 3*sqrt(2002)*y*(10*x2*y2 - 5*x4 - y4)/(32*sqrt(pi)) + dz[38] = 44.401711264127719f*xy*z*(x2 - y2) ; // 33*sqrt(91)*xy*z*(x2 - y2)/(4*sqrt(pi)) + dz[39] = -2.7636157785447706f*y*(3.0f*x2 - y2)*(11.0f*z2 - 1.0f) ; // -3*sqrt(2730)*y*(3*x2 - y2)*(11*z2 - 1)/(32*sqrt(pi)) + dz[40] = 11.054463114179082f*xy*z*(11.0f*z2 - 3.0f) ; // 3*sqrt(2730)*xy*z*(11*z2 - 3)/(8*sqrt(pi)) + dz[41] = 2.9131068125936568f*y*(18.0f*z2 - 33.0f*z4 - 1.0f) ; // 5*sqrt(273)*y*(18*z2 - 33*z4 - 1)/(16*sqrt(pi)) + dz[42] = 2.6699064952403937f*z*(-30.0f*z2 + 33.0f*z4 + 5.0f) ; // 21*sqrt(13)*z*(-30*z2 + 33*z4 + 5)/(16*sqrt(pi)) + dz[43] = 2.9131068125936568f*x*(18.0f*z2 - 33.0f*z4 - 1.0f) ; // 5*sqrt(273)*x*(18*z2 - 33*z4 - 1)/(16*sqrt(pi)) + dz[44] = 5.5272315570895412f*z*(x2 - y2)*(11.0f*z2 - 3.0f) ; // 3*sqrt(2730)*z*(x2 - y2)*(11*z2 - 3)/(16*sqrt(pi)) + dz[45] = -2.7636157785447706f*x*(x2 - 3.0f*y2)*(11.0f*z2 - 1.0f) ; // -3*sqrt(2730)*x*(x2 - 3*y2)*(11*z2 - 1)/(32*sqrt(pi)) + dz[46] = 11.10042781603193f*z*(-6.0f*x2*y2 + x4 + y4) ; // 33*sqrt(91)*z*(-6*x2*y2 + x4 + y4)/(16*sqrt(pi)) + dz[47] = 2.3666191622317521f*x*(10.0f*x2*y2 - x4 - 5.0f*y4) ; // 3*sqrt(2002)*x*(10*x2*y2 - x4 - 5*y4)/(32*sqrt(pi)) + dz[48] = 0.0f ; // 0 + if (C <= 7) { return; } + dz[49] = 0.0f ; // 0 + dz[50] = 5.2919213236038001f*xy*(-10.0f*x2*y2 + 3.0f*x4 + 3.0f*y4) ; // 3*sqrt(10010)*xy*(-10*x2*y2 + 3*x4 + 3*y4)/(32*sqrt(pi)) + dz[51] = 13.491805046726766f*yz*(10.0f*x2*y2 - 5.0f*x4 - y4) ; // 39*sqrt(385)*yz*(10*x2*y2 - 5*x4 - y4)/(32*sqrt(pi)) + dz[52] = 12.453973889286248f*xy*(x2 - y2)*(13.0f*z2 - 1.0f) ; // 9*sqrt(385)*xy*(x2 - y2)*(13*z2 - 1)/(8*sqrt(pi)) + dz[53] = -6.8841930899409371f*yz*(3.0f*x2 - y2)*(13.0f*z2 - 3.0f) ; // -33*sqrt(35)*yz*(3*x2 - y2)*(13*z2 - 3)/(16*sqrt(pi)) + dz[54] = 2.2126634622249131f*xy*(-66.0f*z2 + 143.0f*z4 + 3.0f) ; // 15*sqrt(70)*xy*(-66*z2 + 143*z4 + 3)/(32*sqrt(pi)) + dz[55] = 1.6259689364853116f*yz*(110.0f*z2 - 143.0f*z4 - 15.0f) ; // 9*sqrt(105)*yz*(110*z2 - 143*z4 - 15)/(32*sqrt(pi)) + dz[56] = 64.528641681844675f*z2 - 236.60501950009714f*z4 + 205.05768356675085f*z6 - 2.3899496919201733f ; // 7*sqrt(15)*(135*z2 - 495*z4 + 429*z6 - 5)/(32*sqrt(pi)) + dz[57] = 1.6259689364853116f*xz*(110.0f*z2 - 143.0f*z4 - 15.0f) ; // 9*sqrt(105)*xz*(110*z2 - 143*z4 - 15)/(32*sqrt(pi)) + dz[58] = 0.07375544874083044f*(x2 - y2)*(143.0f*z2*(3.0f*z2 - 1.0f) + 132.0f*z2*(13.0f*z2 - 5.0f) - 187.0f*z2 + 45.0f) ; // sqrt(70)*(x2 - y2)*(143*z2*(3*z2 - 1) + 132*z2*(13*z2 - 5) - 187*z2 + 45)/(64*sqrt(pi)) + dz[59] = -6.8841930899409371f*xz*(x2 - 3.0f*y2)*(13.0f*z2 - 3.0f) ; // -33*sqrt(35)*xz*(x2 - 3*y2)*(13*z2 - 3)/(16*sqrt(pi)) + dz[60] = 3.1134934723215619f*(13.0f*z2 - 1.0f)*(-6.0f*x2*y2 + x4 + y4) ; // 9*sqrt(385)*(13*z2 - 1)*(-6*x2*y2 + x4 + y4)/(32*sqrt(pi)) + dz[61] = 13.491805046726766f*xz*(10.0f*x2*y2 - x4 - 5.0f*y4) ; // 39*sqrt(385)*xz*(10*x2*y2 - x4 - 5*y4)/(32*sqrt(pi)) + dz[62] = 39.6894099270285f*x2*y4 - 39.6894099270285f*x4*y2 + 2.6459606618019f*x6 - 2.6459606618019f*y6 ; // 3*sqrt(10010)*(15*x2*y4 - 15*x4*y2 + x6 - y6)/(64*sqrt(pi)) + dz[63] = 0.0f ; // 0 + }; + write_sh_dx(); + write_sh_dy(); + write_sh_dz(); + } +} + + +template +__global__ void kernel_sh_backward( + const scalar_t * __restrict__ grad, + const scalar_t * __restrict__ inputs, + uint32_t B, uint32_t D, uint32_t C, + const scalar_t * __restrict__ dy_dx, + scalar_t * grad_inputs +) { + const uint32_t t = threadIdx.x + blockIdx.x * blockDim.x; + const uint32_t b = t / D; + if (b >= B) return; + + const uint32_t d = t - b * D; + const uint32_t C2 = C * C; + + // locate + grad += b * C2; + dy_dx += b * D * C2 + d * C2; + + for (int ch = 0; ch < C2; ch++) { + grad_inputs[t] += grad[ch] * dy_dx[ch]; + //printf("t=%d, b=%d, d=%d, ch=%d, grad=%f (+= %f * %f)\n", t, b, d, ch, grad_inputs[t], grad[ch], dy_dx[ch]); + } + +} + +// inputs: [B, D], float, in [0, 1] +// outputs: [B, L * C], float +template +void sh_encode_forward_cuda(const scalar_t *inputs, scalar_t *outputs, const uint32_t B, const uint32_t D, const uint32_t C, scalar_t *dy_dx) { + static constexpr uint32_t N_THREADS = 256; + kernel_sh<<>>(inputs, outputs, B, D, C, dy_dx); +} + + +template +void sh_encode_backward_cuda(const scalar_t *grad, const scalar_t *inputs, const uint32_t B, const uint32_t D, const uint32_t C, scalar_t *dy_dx, scalar_t *grad_inputs) { + static constexpr uint32_t N_THREADS = 256; + kernel_sh_backward<<>>(grad, inputs, B, D, C, dy_dx, grad_inputs); +} + + +void sh_encode_forward(at::Tensor inputs, at::Tensor outputs, const uint32_t B, const uint32_t D, const uint32_t C, at::optional dy_dx) { + CHECK_CUDA(inputs); + CHECK_CUDA(outputs); + // CHECK_CUDA(dy_dx); + + CHECK_CONTIGUOUS(inputs); + CHECK_CONTIGUOUS(outputs); + // CHECK_CONTIGUOUS(dy_dx); + + CHECK_IS_FLOATING(inputs); + CHECK_IS_FLOATING(outputs); + // CHECK_IS_FLOATING(dy_dx); + + AT_DISPATCH_FLOATING_TYPES_AND_HALF( + inputs.scalar_type(), "sh_encode_forward_cuda", ([&] { + sh_encode_forward_cuda(inputs.data_ptr(), outputs.data_ptr(), B, D, C, dy_dx.has_value() ? dy_dx.value().data_ptr() : nullptr); + })); +} + +void sh_encode_backward(at::Tensor grad, at::Tensor inputs, const uint32_t B, const uint32_t D, const uint32_t C, at::Tensor dy_dx, at::Tensor grad_inputs) { + CHECK_CUDA(grad); + CHECK_CUDA(inputs); + CHECK_CUDA(dy_dx); + CHECK_CUDA(grad_inputs); + + CHECK_CONTIGUOUS(grad); + CHECK_CONTIGUOUS(inputs); + CHECK_CONTIGUOUS(dy_dx); + CHECK_CONTIGUOUS(grad_inputs); + + CHECK_IS_FLOATING(grad); + CHECK_IS_FLOATING(inputs); + CHECK_IS_FLOATING(dy_dx); + CHECK_IS_FLOATING(grad_inputs); + + AT_DISPATCH_FLOATING_TYPES_AND_HALF( + grad.scalar_type(), "sh_encode_backward_cuda", ([&] { + sh_encode_backward_cuda(grad.data_ptr(), inputs.data_ptr(), B, D, C, dy_dx.data_ptr(), grad_inputs.data_ptr()); + })); +} \ No newline at end of file diff --git a/shencoder/src/shencoder.h b/shencoder/src/shencoder.h new file mode 100644 index 0000000..f9e89fa --- /dev/null +++ b/shencoder/src/shencoder.h @@ -0,0 +1,10 @@ +# pragma once + +#include +#include + +// inputs: [B, D], float, in [-1, 1] +// outputs: [B, F], float + +void sh_encode_forward(at::Tensor inputs, at::Tensor outputs, const uint32_t B, const uint32_t D, const uint32_t C, at::optional dy_dx); +void sh_encode_backward(at::Tensor grad, at::Tensor inputs, const uint32_t B, const uint32_t D, const uint32_t C, at::Tensor dy_dx, at::Tensor grad_inputs); \ No newline at end of file diff --git a/taichi_modules/__init__.py b/taichi_modules/__init__.py new file mode 100644 index 0000000..3270636 --- /dev/null +++ b/taichi_modules/__init__.py @@ -0,0 +1,5 @@ +from .ray_march import RayMarcherTaichi, raymarching_test +from .volume_train import VolumeRendererTaichi +from .intersection import RayAABBIntersector +from .volume_render_test import composite_test +from .utils import packbits \ No newline at end of file diff --git a/taichi_modules/hash_encoder.py b/taichi_modules/hash_encoder.py new file mode 100644 index 0000000..9a1b7a7 --- /dev/null +++ b/taichi_modules/hash_encoder.py @@ -0,0 +1,305 @@ +import numpy as np +import taichi as ti +import torch +from taichi.math import uvec3 +from torch.cuda.amp import custom_bwd, custom_fwd + +from .utils import (data_type, ti2torch, ti2torch_grad, ti2torch_grad_vec, + ti2torch_vec, torch2ti, torch2ti_grad, torch2ti_grad_vec, + torch2ti_vec, torch_type) + +half2 = ti.types.vector(n=2, dtype=ti.f16) + + +@ti.kernel +def random_initialize(data: ti.types.ndarray()): + for I in ti.grouped(data): + data[I] = (ti.random() * 2.0 - 1.0) * 1e-4 + + +@ti.kernel +def ti_copy(data1: ti.template(), data2: ti.template()): + for I in ti.grouped(data1): + data1[I] = data2[I] + + +@ti.kernel +def ti_copy_array(data1: ti.types.ndarray(), data2: ti.types.ndarray()): + for I in ti.grouped(data1): + data1[I] = data2[I] + + +@ti.kernel +def ti_copy_field_array(data1: ti.template(), data2: ti.types.ndarray()): + for I in ti.grouped(data1): + data1[I] = data2[I] + + +@ti.func +def fast_hash(pos_grid_local): + result = ti.uint32(0) + # primes = uvec3(ti.uint32(1), ti.uint32(1958374283), ti.uint32(2654435761)) + primes = uvec3(ti.uint32(1), ti.uint32(2654435761), ti.uint32(805459861)) + for i in ti.static(range(3)): + result ^= ti.uint32(pos_grid_local[i]) * primes[i] + return result + + +@ti.func +def under_hash(pos_grid_local, resolution): + result = ti.uint32(0) + stride = ti.uint32(1) + for i in ti.static(range(3)): + result += ti.uint32(pos_grid_local[i] * stride) + stride *= resolution + return result + + +@ti.func +def grid_pos2hash_index(indicator, pos_grid_local, resolution, map_size): + hash_result = ti.uint32(0) + if indicator == 1: + hash_result = under_hash(pos_grid_local, resolution) + else: + hash_result = fast_hash(pos_grid_local) + + return hash_result % map_size + + +@ti.kernel +def hash_encode_kernel( + xyzs: ti.template(), table: ti.template(), + xyzs_embedding: ti.template(), hash_map_indicator: ti.template(), + hash_map_sizes_field: ti.template(), offsets: ti.template(), B: ti.i32, + per_level_scale: ti.f32): + + # get hash table embedding + ti.loop_config(block_dim=16) + for i, level in ti.ndrange(B, 16): + xyz = ti.Vector([xyzs[i, 0], xyzs[i, 1], xyzs[i, 2]]) + + scale = 16 * ti.exp(level * ti.log(per_level_scale)) - 1.0 + resolution = ti.cast(ti.ceil(scale), ti.uint32) + 1 + + offset = offsets[level] * 2 + + pos = xyz * scale + 0.5 + pos_grid_uint = ti.cast(ti.floor(pos), ti.uint32) + pos -= pos_grid_uint + + indicator = hash_map_indicator[level] + map_size = hash_map_sizes_field[level] + + local_feature_0 = 0.0 + local_feature_1 = 0.0 + + for idx in ti.static(range(8)): + w = 1. + pos_grid_local = uvec3(0) + + for d in ti.static(range(3)): + if (idx & (1 << d)) == 0: + pos_grid_local[d] = pos_grid_uint[d] + w *= 1 - pos[d] + else: + pos_grid_local[d] = pos_grid_uint[d] + 1 + w *= pos[d] + + index = grid_pos2hash_index(indicator, pos_grid_local, resolution, + map_size) + index_table = offset + index * 2 + index_table_int = ti.cast(index_table, ti.int32) + local_feature_0 += w * table[index_table_int] + local_feature_1 += w * table[index_table_int + 1] + + xyzs_embedding[i, level * 2] = local_feature_0 + xyzs_embedding[i, level * 2 + 1] = local_feature_1 + + +@ti.kernel +def hash_encode_kernel_half2( + xyzs: ti.template(), table: ti.template(), + xyzs_embedding: ti.template(), hash_map_indicator: ti.template(), + hash_map_sizes_field: ti.template(), offsets: ti.template(), B: ti.i32, + per_level_scale: ti.f16): + + # get hash table embedding + ti.loop_config(block_dim=32) + for i, level in ti.ndrange(B, 16): + xyz = ti.Vector([xyzs[i, 0], xyzs[i, 1], xyzs[i, 2]]) + + scale = 16 * ti.exp(level * ti.log(per_level_scale)) - 1.0 + resolution = ti.cast(ti.ceil(scale), ti.uint32) + 1 + + offset = offsets[level] + + pos = xyz * scale + 0.5 + pos_grid_uint = ti.cast(ti.floor(pos), ti.uint32) + pos -= pos_grid_uint + + indicator = hash_map_indicator[level] + map_size = hash_map_sizes_field[level] + + local_feature = half2(0.0) + for idx in ti.static(range(8)): + w = ti.f32(1.0) + pos_grid_local = uvec3(0) + + for d in ti.static(range(3)): + if (idx & (1 << d)) == 0: + pos_grid_local[d] = pos_grid_uint[d] + w *= 1 - pos[d] + else: + pos_grid_local[d] = pos_grid_uint[d] + 1 + w *= pos[d] + + index = grid_pos2hash_index(indicator, pos_grid_local, resolution, + map_size) + + index_table = offset + index + index_table_int = ti.cast(index_table, ti.int32) + + local_feature += w * table[index_table_int] + xyzs_embedding[i, level] = local_feature + + +class HashEncoderTaichi(torch.nn.Module): + + def __init__(self, + b=1.3195079565048218, + batch_size=8192, + data_type=data_type, + half2_opt=False): + super(HashEncoderTaichi, self).__init__() + + self.per_level_scale = b + if batch_size < 2048: + batch_size = 2048 + + # per_level_scale = 1.3195079565048218 + print("per_level_scale: ", b) + self.offsets = ti.field(ti.i32, shape=(16, )) + self.hash_map_sizes_field = ti.field(ti.uint32, shape=(16, )) + self.hash_map_indicator = ti.field(ti.i32, shape=(16, )) + base_res = 16 + max_params = 2**19 + offset_ = 0 + hash_map_sizes = [] + for i in range(16): + resolution = int( + np.ceil(base_res * np.exp(i * np.log(self.per_level_scale)) - + 1.0)) + 1 + params_in_level = resolution**3 + params_in_level = int(resolution** + 3) if params_in_level % 8 == 0 else int( + (params_in_level + 8 - 1) / 8) * 8 + params_in_level = min(max_params, params_in_level) + self.offsets[i] = offset_ + hash_map_sizes.append(params_in_level) + self.hash_map_indicator[ + i] = 1 if resolution**3 <= params_in_level else 0 + offset_ += params_in_level + print("offset_: ", offset_) + size = np.uint32(np.array(hash_map_sizes)) + self.hash_map_sizes_field.from_numpy(size) + + self.total_hash_size = offset_ * 2 + print("total_hash_size: ", self.total_hash_size) + + self.hash_table = torch.nn.Parameter(torch.zeros(self.total_hash_size, + dtype=torch_type), + requires_grad=True) + random_initialize(self.hash_table) + + if half2_opt: + assert self.total_hash_size % 2 == 0 + self.parameter_fields = half2.field(shape=(self.total_hash_size // + 2, ), + needs_grad=True) + self.output_fields = half2.field(shape=(batch_size * 1024, 16), + needs_grad=True) + + self.torch2ti = torch2ti_vec + self.ti2torch = ti2torch_vec + self.ti2torch_grad = ti2torch_grad_vec + self.torch2ti_grad = torch2ti_grad_vec + + self._hash_encode_kernel = hash_encode_kernel_half2 + else: + self.parameter_fields = ti.field(data_type, + shape=(self.total_hash_size, ), + needs_grad=True) + self.output_fields = ti.field(dtype=data_type, + shape=(batch_size * 1024, 32), + needs_grad=True) + self.torch2ti = torch2ti + self.ti2torch = ti2torch + self.ti2torch_grad = ti2torch_grad + self.torch2ti_grad = torch2ti_grad + + self._hash_encode_kernel = hash_encode_kernel + + self.input_fields = ti.field(dtype=data_type, + shape=(batch_size * 1024, 3), + needs_grad=True) + self.output_dim = 32 # the output dim: num levels (16) x level num (2) + self.register_buffer( + 'hash_grad', torch.zeros(self.total_hash_size, dtype=torch_type)) + self.register_buffer( + 'output_embedding', + torch.zeros(batch_size * 1024, 32, dtype=torch_type)) + + class _module_function(torch.autograd.Function): + + @staticmethod + @custom_fwd(cast_inputs=torch_type) + def forward(ctx, input_pos, params): + output_embedding = self.output_embedding[:input_pos. + shape[0]].contiguous( + ) + torch2ti(self.input_fields, input_pos.contiguous()) + self.torch2ti(self.parameter_fields, params.contiguous()) + + self._hash_encode_kernel( + self.input_fields, + self.parameter_fields, + self.output_fields, + self.hash_map_indicator, + self.hash_map_sizes_field, + self.offsets, + input_pos.shape[0], + self.per_level_scale, + ) + self.ti2torch(self.output_fields, output_embedding) + + return output_embedding + + @staticmethod + @custom_bwd + def backward(ctx, doutput): + + self.zero_grad() + + self.torch2ti_grad(self.output_fields, doutput.contiguous()) + self._hash_encode_kernel.grad( + self.input_fields, + self.parameter_fields, + self.output_fields, + self.hash_map_indicator, + self.hash_map_sizes_field, + self.offsets, + doutput.shape[0], + self.per_level_scale, + ) + self.ti2torch_grad(self.parameter_fields, + self.hash_grad.contiguous()) + return None, self.hash_grad + + self._module_function = _module_function + + def zero_grad(self): + self.parameter_fields.grad.fill(0.) + + def forward(self, positions, bound=1): + positions = (positions + bound) / (2 * bound) + return self._module_function.apply(positions, self.hash_table) diff --git a/taichi_modules/intersection.py b/taichi_modules/intersection.py new file mode 100644 index 0000000..3879934 --- /dev/null +++ b/taichi_modules/intersection.py @@ -0,0 +1,68 @@ +import taichi as ti +import torch +from taichi.math import vec3 +from torch.cuda.amp import custom_fwd + +from .utils import NEAR_DISTANCE + + +@ti.kernel +def simple_ray_aabb_intersec_taichi_forward( + hits_t: ti.types.ndarray(ndim=2), + rays_o: ti.types.ndarray(ndim=2), + rays_d: ti.types.ndarray(ndim=2), + centers: ti.types.ndarray(ndim=2), + half_sizes: ti.types.ndarray(ndim=2)): + + for r in ti.ndrange(hits_t.shape[0]): + ray_o = vec3([rays_o[r, 0], rays_o[r, 1], rays_o[r, 2]]) + ray_d = vec3([rays_d[r, 0], rays_d[r, 1], rays_d[r, 2]]) + inv_d = 1.0 / ray_d + + center = vec3([centers[0, 0], centers[0, 1], centers[0, 2]]) + half_size = vec3( + [half_sizes[0, 0], half_sizes[0, 1], half_sizes[0, 1]]) + + t_min = (center - half_size - ray_o) * inv_d + t_max = (center + half_size - ray_o) * inv_d + + _t1 = ti.min(t_min, t_max) + _t2 = ti.max(t_min, t_max) + t1 = _t1.max() + t2 = _t2.min() + + if t2 > 0.0: + hits_t[r, 0, 0] = ti.max(t1, NEAR_DISTANCE) + hits_t[r, 0, 1] = t2 + + +class RayAABBIntersector(torch.autograd.Function): + """ + Computes the intersections of rays and axis-aligned voxels. + + Inputs: + rays_o: (N_rays, 3) ray origins + rays_d: (N_rays, 3) ray directions + centers: (N_voxels, 3) voxel centers + half_sizes: (N_voxels, 3) voxel half sizes + max_hits: maximum number of intersected voxels to keep for one ray + (for a cubic scene, this is at most 3*N_voxels^(1/3)-2) + + Outputs: + hits_cnt: (N_rays) number of hits for each ray + (followings are from near to far) + hits_t: (N_rays, max_hits, 2) hit t's (-1 if no hit) + hits_voxel_idx: (N_rays, max_hits) hit voxel indices (-1 if no hit) + """ + + @staticmethod + @custom_fwd(cast_inputs=torch.float32) + def forward(ctx, rays_o, rays_d, center, half_size, max_hits): + hits_t = (torch.zeros( + rays_o.size(0), 1, 2, device=rays_o.device, dtype=torch.float32) - + 1).contiguous() + + simple_ray_aabb_intersec_taichi_forward(hits_t, rays_o, rays_d, center, + half_size) + + return None, hits_t, None diff --git a/taichi_modules/ray_march.py b/taichi_modules/ray_march.py new file mode 100644 index 0000000..d159d03 --- /dev/null +++ b/taichi_modules/ray_march.py @@ -0,0 +1,340 @@ +import taichi as ti +import torch +from taichi.math import vec3 +from torch.cuda.amp import custom_fwd + +from .utils import __morton3D, calc_dt, mip_from_dt, mip_from_pos + + +@ti.kernel +def raymarching_train(rays_o: ti.types.ndarray(ndim=2), + rays_d: ti.types.ndarray(ndim=2), + hits_t: ti.types.ndarray(ndim=2), + density_bitfield: ti.types.ndarray(ndim=1), + noise: ti.types.ndarray(ndim=1), + counter: ti.types.ndarray(ndim=1), + rays_a: ti.types.ndarray(ndim=2), + xyzs: ti.types.ndarray(ndim=2), + dirs: ti.types.ndarray(ndim=2), + deltas: ti.types.ndarray(ndim=1), + ts: ti.types.ndarray(ndim=1), cascades: int, + grid_size: int, scale: float, exp_step_factor: float, + max_samples: float): + + # ti.loop_config(block_dim=256) + for r in noise: + ray_o = vec3(rays_o[r, 0], rays_o[r, 1], rays_o[r, 2]) + ray_d = vec3(rays_d[r, 0], rays_d[r, 1], rays_d[r, 2]) + d_inv = 1.0 / ray_d + + t1, t2 = hits_t[r, 0], hits_t[r, 1] + + grid_size3 = grid_size**3 + grid_size_inv = 1.0 / grid_size + + if t1 >= 0: + dt = calc_dt(t1, exp_step_factor, grid_size, scale) + t1 += dt * noise[r] + + t = t1 + N_samples = 0 + + while (0 <= t) & (t < t2) & (N_samples < max_samples): + xyz = ray_o + t * ray_d + dt = calc_dt(t, exp_step_factor, grid_size, scale) + mip = ti.max(mip_from_pos(xyz, cascades), + mip_from_dt(dt, grid_size, cascades)) + + # mip_bound = 0.5 + # mip_bound = ti.min(ti.pow(2., mip - 1), scale) + mip_bound = scale + mip_bound_inv = 1 / mip_bound + + nxyz = ti.math.clamp(0.5 * (xyz * mip_bound_inv + 1) * grid_size, + 0.0, grid_size - 1.0) + # nxyz = ti.ceil(nxyz) + + idx = mip * grid_size3 + __morton3D(ti.cast(nxyz, ti.u32)) + occ = density_bitfield[ti.u32(idx // 8)] & (1 << ti.u32(idx % 8)) + # idx = __morton3D(ti.cast(nxyz, ti.uint32)) + # occ = density_bitfield[mip, idx//8] & (1 << ti.cast(idx%8, ti.uint32)) + + if occ: + t += dt + N_samples += 1 + else: + # t += dt + txyz = (((nxyz + 0.5 + 0.5 * ti.math.sign(ray_d)) * + grid_size_inv * 2 - 1) * mip_bound - xyz) * d_inv + + t_target = t + ti.max(0, txyz.min()) + t += calc_dt(t, exp_step_factor, grid_size, scale) + while t < t_target: + t += calc_dt(t, exp_step_factor, grid_size, scale) + + start_idx = ti.atomic_add(counter[0], N_samples) + ray_count = ti.atomic_add(counter[1], 1) + + rays_a[ray_count, 0] = r + rays_a[ray_count, 1] = start_idx + rays_a[ray_count, 2] = N_samples + + t = t1 + samples = 0 + + while (t < t2) & (samples < N_samples): + xyz = ray_o + t * ray_d + dt = calc_dt(t, exp_step_factor, grid_size, scale) + mip = ti.max(mip_from_pos(xyz, cascades), + mip_from_dt(dt, grid_size, cascades)) + + # mip_bound = 0.5 + # mip_bound = ti.min(ti.pow(2., mip - 1), scale) + mip_bound = scale + mip_bound_inv = 1 / mip_bound + + nxyz = ti.math.clamp(0.5 * (xyz * mip_bound_inv + 1) * grid_size, + 0.0, grid_size - 1.0) + # nxyz = ti.ceil(nxyz) + + idx = mip * grid_size3 + __morton3D(ti.cast(nxyz, ti.u32)) + occ = density_bitfield[ti.u32(idx // 8)] & (1 << ti.u32(idx % 8)) + # idx = __morton3D(ti.cast(nxyz, ti.uint32)) + # occ = density_bitfield[mip, idx//8] & (1 << ti.cast(idx%8, ti.uint32)) + + if occ: + s = start_idx + samples + xyzs[s, 0] = xyz[0] + xyzs[s, 1] = xyz[1] + xyzs[s, 2] = xyz[2] + dirs[s, 0] = ray_d[0] + dirs[s, 1] = ray_d[1] + dirs[s, 2] = ray_d[2] + ts[s] = t + deltas[s] = dt + t += dt + samples += 1 + else: + # t += dt + txyz = (((nxyz + 0.5 + 0.5 * ti.math.sign(ray_d)) * + grid_size_inv * 2 - 1) * mip_bound - xyz) * d_inv + + t_target = t + ti.max(0, txyz.min()) + t += calc_dt(t, exp_step_factor, grid_size, scale) + while t < t_target: + t += calc_dt(t, exp_step_factor, grid_size, scale) + + +@ti.kernel +def raymarching_train_backword(segments: ti.types.ndarray(ndim=2), + ts: ti.types.ndarray(ndim=1), + dL_drays_o: ti.types.ndarray(ndim=2), + dL_drays_d: ti.types.ndarray(ndim=2), + dL_dxyzs: ti.types.ndarray(ndim=2), + dL_ddirs: ti.types.ndarray(ndim=2)): + + for s in segments: + index = segments[s] + dxyz = dL_dxyzs[index] + ddir = dL_ddirs[index] + + dL_drays_o[s] = dxyz + dL_drays_d[s] = dxyz * ts[index] + ddir + + +class RayMarcherTaichi(torch.nn.Module): + + def __init__(self, batch_size=8192): + super(RayMarcherTaichi, self).__init__() + + self.register_buffer('rays_a', + torch.zeros(batch_size, 3, dtype=torch.int32)) + self.register_buffer( + 'xyzs', torch.zeros(batch_size * 1024, 3, dtype=torch.float32)) + self.register_buffer( + 'dirs', torch.zeros(batch_size * 1024, 3, dtype=torch.float32)) + self.register_buffer( + 'deltas', torch.zeros(batch_size * 1024, dtype=torch.float32)) + self.register_buffer( + 'ts', torch.zeros(batch_size * 1024, dtype=torch.float32)) + + # self.register_buffer('dL_drays_o', torch.zeros(batch_size, dtype=torch.float32)) + # self.register_buffer('dL_drays_d', torch.zeros(batch_size, dtype=torch.float32)) + + class _module_function(torch.autograd.Function): + + @staticmethod + @custom_fwd(cast_inputs=torch.float32) + def forward(ctx, rays_o, rays_d, hits_t, density_bitfield, + cascades, scale, exp_step_factor, grid_size, + max_samples): + # noise to perturb the first sample of each ray + noise = torch.rand_like(rays_o[:, 0]) + counter = torch.zeros(2, + device=rays_o.device, + dtype=torch.int32) + + raymarching_train(\ + rays_o, rays_d, + hits_t.contiguous(), + density_bitfield, noise, counter, + self.rays_a.contiguous(), + self.xyzs.contiguous(), + self.dirs.contiguous(), + self.deltas.contiguous(), + self.ts.contiguous(), + cascades, grid_size, scale, + exp_step_factor, max_samples) + + # ti.sync() + + total_samples = counter[0] # total samples for all rays + # remove redundant output + xyzs = self.xyzs[:total_samples] + dirs = self.dirs[:total_samples] + deltas = self.deltas[:total_samples] + ts = self.ts[:total_samples] + + return self.rays_a, xyzs, dirs, deltas, ts, total_samples + + # @staticmethod + # @custom_bwd + # def backward(ctx, dL_drays_a, dL_dxyzs, dL_ddirs, dL_ddeltas, dL_dts, + # dL_dtotal_samples): + # rays_a, ts = ctx.saved_tensors + # # rays_a = rays_a.contiguous() + # ts = ts.contiguous() + # segments = torch.cat([rays_a[:, 1], rays_a[-1:, 1] + rays_a[-1:, 2]]) + # dL_drays_o = torch.zeros_like(rays_a[:, 0]) + # dL_drays_d = torch.zeros_like(rays_a[:, 0]) + # raymarching_train_backword(segments.contiguous(), ts, dL_drays_o, + # dL_drays_d, dL_dxyzs, dL_ddirs) + # # ti.sync() + # # dL_drays_o = segment_csr(dL_dxyzs, segments) + # # dL_drays_d = \ + # # segment_csr(dL_dxyzs*rearrange(ts, 'n -> n 1')+dL_ddirs, segments) + + # return dL_drays_o, dL_drays_d, None, None, None, None, None, None, None + + self._module_function = _module_function + + def forward(self, rays_o, rays_d, hits_t, density_bitfield, cascades, + scale, exp_step_factor, grid_size, max_samples): + return self._module_function.apply(rays_o, rays_d, hits_t, + density_bitfield, cascades, scale, + exp_step_factor, grid_size, + max_samples) + + +@ti.kernel +def raymarching_test_kernel( + rays_o: ti.types.ndarray(ndim=2), + rays_d: ti.types.ndarray(ndim=2), + hits_t: ti.types.ndarray(ndim=2), + alive_indices: ti.types.ndarray(ndim=1), + density_bitfield: ti.types.ndarray(ndim=1), + cascades: int, + grid_size: int, + scale: float, + exp_step_factor: float, + N_samples: int, + max_samples: int, + xyzs: ti.types.ndarray(ndim=2), + dirs: ti.types.ndarray(ndim=2), + deltas: ti.types.ndarray(ndim=1), + ts: ti.types.ndarray(ndim=1), + N_eff_samples: ti.types.ndarray(ndim=1), +): + + for n in alive_indices: + r = alive_indices[n] + grid_size3 = grid_size**3 + grid_size_inv = 1.0 / grid_size + + ray_o = vec3(rays_o[r, 0], rays_o[r, 1], rays_o[r, 2]) + ray_d = vec3(rays_d[r, 0], rays_d[r, 1], rays_d[r, 2]) + d_inv = 1.0 / ray_d + + t = hits_t[r, 0] + t2 = hits_t[r, 1] + + s = 0 + + while (0 <= t) & (t < t2) & (s < N_samples): + xyz = ray_o + t * ray_d + dt = calc_dt(t, exp_step_factor, grid_size, scale) + mip = ti.max(mip_from_pos(xyz, cascades), + mip_from_dt(dt, grid_size, cascades)) + + # mip_bound = 0.5 + # mip_bound = ti.min(ti.pow(2., mip - 1), scale) + mip_bound = scale + mip_bound_inv = 1 / mip_bound + + nxyz = ti.math.clamp(0.5 * (xyz * mip_bound_inv + 1) * grid_size, + 0.0, grid_size - 1.0) + # nxyz = ti.ceil(nxyz) + + idx = mip * grid_size3 + __morton3D(ti.cast(nxyz, ti.u32)) + occ = density_bitfield[ti.u32(idx // 8)] & (1 << ti.u32(idx % 8)) + + if occ: + xyzs[n, s, 0] = xyz[0] + xyzs[n, s, 1] = xyz[1] + xyzs[n, s, 2] = xyz[2] + dirs[n, s, 0] = ray_d[0] + dirs[n, s, 1] = ray_d[1] + dirs[n, s, 2] = ray_d[2] + ts[n, s] = t + deltas[n, s] = dt + t += dt + hits_t[r, 0] = t + s += 1 + + else: + txyz = (((nxyz + 0.5 + 0.5 * ti.math.sign(ray_d)) * + grid_size_inv * 2 - 1) * mip_bound - xyz) * d_inv + + t_target = t + ti.max(0, txyz.min()) + t += calc_dt(t, exp_step_factor, grid_size, scale) + while t < t_target: + t += calc_dt(t, exp_step_factor, grid_size, scale) + + N_eff_samples[n] = s + + +def raymarching_test(rays_o, rays_d, hits_t, alive_indices, density_bitfield, + cascades, scale, exp_step_factor, grid_size, max_samples, + N_samples): + + N_rays = alive_indices.size(0) + xyzs = torch.zeros(N_rays, + N_samples, + 3, + device=rays_o.device, + dtype=rays_o.dtype) + dirs = torch.zeros(N_rays, + N_samples, + 3, + device=rays_o.device, + dtype=rays_o.dtype) + deltas = torch.zeros(N_rays, + N_samples, + device=rays_o.device, + dtype=rays_o.dtype) + ts = torch.zeros(N_rays, + N_samples, + device=rays_o.device, + dtype=rays_o.dtype) + N_eff_samples = torch.zeros(N_rays, + device=rays_o.device, + dtype=torch.int32) + + raymarching_test_kernel(rays_o, rays_d, hits_t, alive_indices, + density_bitfield, cascades, grid_size, scale, + exp_step_factor, N_samples, max_samples, xyzs, + dirs, deltas, ts, N_eff_samples) + + # ti.sync() + + return xyzs, dirs, deltas, ts, N_eff_samples diff --git a/taichi_modules/utils.py b/taichi_modules/utils.py new file mode 100644 index 0000000..02c2f2a --- /dev/null +++ b/taichi_modules/utils.py @@ -0,0 +1,224 @@ +import taichi as ti +import torch +from taichi.math import uvec3 + +taichi_block_size = 128 + +data_type = ti.f32 +torch_type = torch.float32 + +MAX_SAMPLES = 1024 +NEAR_DISTANCE = 0.01 +SQRT3 = 1.7320508075688772 +SQRT3_MAX_SAMPLES = SQRT3 / 1024 +SQRT3_2 = 1.7320508075688772 * 2 + + +@ti.func +def scalbn(x, exponent): + return x * ti.math.pow(2, exponent) + + +@ti.func +def calc_dt(t, exp_step_factor, grid_size, scale): + return ti.math.clamp(t * exp_step_factor, SQRT3_MAX_SAMPLES, + SQRT3_2 * scale / grid_size) + + +@ti.func +def frexp_bit(x): + exponent = 0 + if x != 0.0: + # frac = ti.abs(x) + bits = ti.bit_cast(x, ti.u32) + exponent = ti.i32((bits & ti.u32(0x7f800000)) >> 23) - 127 + # exponent = (ti.i32(bits & ti.u32(0x7f800000)) >> 23) - 127 + bits &= ti.u32(0x7fffff) + bits |= ti.u32(0x3f800000) + frac = ti.bit_cast(bits, ti.f32) + if frac < 0.5: + exponent -= 1 + elif frac > 1.0: + exponent += 1 + return exponent + + +@ti.func +def mip_from_pos(xyz, cascades): + mx = ti.abs(xyz).max() + # _, exponent = _frexp(mx) + exponent = frexp_bit(ti.f32(mx)) + 1 + # frac, exponent = ti.frexp(ti.f32(mx)) + return ti.min(cascades - 1, ti.max(0, exponent)) + + +@ti.func +def mip_from_dt(dt, grid_size, cascades): + # _, exponent = _frexp(dt*grid_size) + exponent = frexp_bit(ti.f32(dt * grid_size)) + # frac, exponent = ti.frexp(ti.f32(dt*grid_size)) + return ti.min(cascades - 1, ti.max(0, exponent)) + + +@ti.func +def __expand_bits(v): + v = (v * ti.uint32(0x00010001)) & ti.uint32(0xFF0000FF) + v = (v * ti.uint32(0x00000101)) & ti.uint32(0x0F00F00F) + v = (v * ti.uint32(0x00000011)) & ti.uint32(0xC30C30C3) + v = (v * ti.uint32(0x00000005)) & ti.uint32(0x49249249) + return v + + +@ti.func +def __morton3D(xyz): + xyz = __expand_bits(xyz) + return xyz[0] | (xyz[1] << 1) | (xyz[2] << 2) + + +@ti.func +def __morton3D_invert(x): + x = x & (0x49249249) + x = (x | (x >> 2)) & ti.uint32(0xc30c30c3) + x = (x | (x >> 4)) & ti.uint32(0x0f00f00f) + x = (x | (x >> 8)) & ti.uint32(0xff0000ff) + x = (x | (x >> 16)) & ti.uint32(0x0000ffff) + return ti.int32(x) + + +@ti.kernel +def morton3D_invert_kernel(indices: ti.types.ndarray(ndim=1), + coords: ti.types.ndarray(ndim=2)): + for i in indices: + ind = ti.uint32(indices[i]) + coords[i, 0] = __morton3D_invert(ind >> 0) + coords[i, 1] = __morton3D_invert(ind >> 1) + coords[i, 2] = __morton3D_invert(ind >> 2) + + +def morton3D_invert(indices): + coords = torch.zeros(indices.size(0), + 3, + device=indices.device, + dtype=torch.int32) + morton3D_invert_kernel(indices.contiguous(), coords) + ti.sync() + return coords + + +@ti.kernel +def morton3D_kernel(xyzs: ti.types.ndarray(ndim=2), + indices: ti.types.ndarray(ndim=1)): + for s in indices: + xyz = uvec3([xyzs[s, 0], xyzs[s, 1], xyzs[s, 2]]) + indices[s] = ti.cast(__morton3D(xyz), ti.int32) + + +def morton3D(coords1): + indices = torch.zeros(coords1.size(0), + device=coords1.device, + dtype=torch.int32) + morton3D_kernel(coords1.contiguous(), indices) + ti.sync() + return indices + + +@ti.kernel +def packbits(density_grid: ti.types.ndarray(ndim=1), + density_threshold: float, + density_bitfield: ti.types.ndarray(ndim=1)): + + for n in density_bitfield: + bits = ti.uint8(0) + + for i in ti.static(range(8)): + bits |= (ti.uint8(1) << i) if ( + density_grid[8 * n + i] > density_threshold) else ti.uint8(0) + + density_bitfield[n] = bits + + +@ti.kernel +def torch2ti(field: ti.template(), data: ti.types.ndarray()): + for I in ti.grouped(data): + field[I] = data[I] + + +@ti.kernel +def ti2torch(field: ti.template(), data: ti.types.ndarray()): + for I in ti.grouped(data): + data[I] = field[I] + + +@ti.kernel +def ti2torch_grad(field: ti.template(), grad: ti.types.ndarray()): + for I in ti.grouped(grad): + grad[I] = field.grad[I] + + +@ti.kernel +def torch2ti_grad(field: ti.template(), grad: ti.types.ndarray()): + for I in ti.grouped(grad): + field.grad[I] = grad[I] + + +@ti.kernel +def torch2ti_vec(field: ti.template(), data: ti.types.ndarray()): + for I in range(data.shape[0] // 2): + field[I] = ti.Vector([data[I * 2], data[I * 2 + 1]]) + + +@ti.kernel +def ti2torch_vec(field: ti.template(), data: ti.types.ndarray()): + for i, j in ti.ndrange(data.shape[0], data.shape[1] // 2): + data[i, j * 2] = field[i, j][0] + data[i, j * 2 + 1] = field[i, j][1] + + +@ti.kernel +def ti2torch_grad_vec(field: ti.template(), grad: ti.types.ndarray()): + for I in range(grad.shape[0] // 2): + grad[I * 2] = field.grad[I][0] + grad[I * 2 + 1] = field.grad[I][1] + + +@ti.kernel +def torch2ti_grad_vec(field: ti.template(), grad: ti.types.ndarray()): + for i, j in ti.ndrange(grad.shape[0], grad.shape[1] // 2): + field.grad[i, j][0] = grad[i, j * 2] + field.grad[i, j][1] = grad[i, j * 2 + 1] + + +def extract_model_state_dict(ckpt_path, + model_name='model', + prefixes_to_ignore=[]): + checkpoint = torch.load(ckpt_path, map_location='cpu') + checkpoint_ = {} + if 'state_dict' in checkpoint: # if it's a pytorch-lightning checkpoint + checkpoint = checkpoint['state_dict'] + for k, v in checkpoint.items(): + if not k.startswith(model_name): + continue + k = k[len(model_name) + 1:] + for prefix in prefixes_to_ignore: + if k.startswith(prefix): + break + else: + checkpoint_[k] = v + return checkpoint_ + + +def load_ckpt(model, ckpt_path, model_name='model', prefixes_to_ignore=[]): + if not ckpt_path: + return + model_dict = model.state_dict() + checkpoint_ = extract_model_state_dict(ckpt_path, model_name, + prefixes_to_ignore) + model_dict.update(checkpoint_) + model.load_state_dict(model_dict) + +def depth2img(depth): + depth = (depth - depth.min()) / (depth.max() - depth.min()) + depth_img = cv2.applyColorMap((depth * 255).astype(np.uint8), + cv2.COLORMAP_TURBO) + + return depth_img \ No newline at end of file diff --git a/taichi_modules/volume_render_test.py b/taichi_modules/volume_render_test.py new file mode 100644 index 0000000..1bdefb7 --- /dev/null +++ b/taichi_modules/volume_render_test.py @@ -0,0 +1,48 @@ +import taichi as ti + + +@ti.kernel +def composite_test( + sigmas: ti.types.ndarray(ndim=2), rgbs: ti.types.ndarray(ndim=3), + deltas: ti.types.ndarray(ndim=2), ts: ti.types.ndarray(ndim=2), + hits_t: ti.types.ndarray(ndim=2), + alive_indices: ti.types.ndarray(ndim=1), T_threshold: float, + N_eff_samples: ti.types.ndarray(ndim=1), + opacity: ti.types.ndarray(ndim=1), + depth: ti.types.ndarray(ndim=1), rgb: ti.types.ndarray(ndim=2)): + + for n in alive_indices: + samples = N_eff_samples[n] + if samples == 0: + alive_indices[n] = -1 + else: + r = alive_indices[n] + + T = 1 - opacity[r] + + rgb_temp_0 = 0.0 + rgb_temp_1 = 0.0 + rgb_temp_2 = 0.0 + depth_temp = 0.0 + opacity_temp = 0.0 + + for s in range(samples): + a = 1.0 - ti.exp(-sigmas[n, s] * deltas[n, s]) + w = a * T + + rgb_temp_0 += w * rgbs[n, s, 0] + rgb_temp_1 += w * rgbs[n, s, 1] + rgb_temp_2 += w * rgbs[n, s, 2] + depth[r] += w * ts[n, s] + opacity[r] += w + T *= 1.0 - a + + if T <= T_threshold: + alive_indices[n] = -1 + break + + rgb[r, 0] += rgb_temp_0 + rgb[r, 1] += rgb_temp_1 + rgb[r, 2] += rgb_temp_2 + depth[r] += depth_temp + opacity[r] += opacity_temp diff --git a/taichi_modules/volume_train.py b/taichi_modules/volume_train.py new file mode 100644 index 0000000..7a52bfe --- /dev/null +++ b/taichi_modules/volume_train.py @@ -0,0 +1,239 @@ +import taichi as ti +import torch +from torch.cuda.amp import custom_bwd, custom_fwd + +from .utils import (data_type, ti2torch, ti2torch_grad, torch2ti, + torch2ti_grad, torch_type) + + +@ti.kernel +def composite_train_fw_array( + sigmas: ti.types.ndarray(), + rgbs: ti.types.ndarray(), + deltas: ti.types.ndarray(), + ts: ti.types.ndarray(), + rays_a: ti.types.ndarray(), + T_threshold: float, + total_samples: ti.types.ndarray(), + opacity: ti.types.ndarray(), + depth: ti.types.ndarray(), + rgb: ti.types.ndarray(), + ws: ti.types.ndarray(), +): + + for n in opacity: + ray_idx = rays_a[n, 0] + start_idx = rays_a[n, 1] + N_samples = rays_a[n, 2] + + T = 1.0 + samples = 0 + while samples < N_samples: + s = start_idx + samples + a = 1.0 - ti.exp(-sigmas[s] * deltas[s]) + w = a * T + + rgb[ray_idx, 0] += w * rgbs[s, 0] + rgb[ray_idx, 1] += w * rgbs[s, 1] + rgb[ray_idx, 2] += w * rgbs[s, 2] + depth[ray_idx] += w * ts[s] + opacity[ray_idx] += w + ws[s] = w + T *= 1.0 - a + + # if T T_threshold: + # s = start_idx + sample_ + a = 1.0 - ti.exp(-sigmas[s] * deltas[s]) + w = a * T_ + rgb[ray_idx, 0] += w * rgbs[s, 0] + rgb[ray_idx, 1] += w * rgbs[s, 1] + rgb[ray_idx, 2] += w * rgbs[s, 2] + depth[ray_idx] += w * ts[s] + opacity[ray_idx] += w + ws[s] = w + # T_ *= (1.0-a) + T[s + 1] = T_ * (1.0 - a) + # if T[s+1]>=T_threshold: + # samples += 1 + total_samples[ray_idx] += 1 + else: + T[s + 1] = 0.0 + + # total_samples[ray_idx] = N_samples + + +@ti.kernel +def check_value( + fields: ti.template(), + array: ti.types.ndarray(), + checker: ti.types.ndarray(), +): + for I in ti.grouped(array): + if fields[I] == array[I]: + checker[I] = 1 + + +class VolumeRendererTaichi(torch.nn.Module): + + def __init__(self, batch_size=8192, data_type=data_type): + super(VolumeRendererTaichi, self).__init__() + # samples level + self.sigmas_fields = ti.field(dtype=data_type, + shape=(batch_size * 1024, ), + needs_grad=True) + self.rgbs_fields = ti.field(dtype=data_type, + shape=(batch_size * 1024, 3), + needs_grad=True) + self.deltas_fields = ti.field(dtype=data_type, + shape=(batch_size * 1024, ), + needs_grad=True) + self.ts_fields = ti.field(dtype=data_type, + shape=(batch_size * 1024, ), + needs_grad=True) + self.ws_fields = ti.field(dtype=data_type, + shape=(batch_size * 1024, ), + needs_grad=True) + self.T = ti.field(dtype=data_type, + shape=(batch_size * 1024), + needs_grad=True) + + # rays level + self.rays_a_fields = ti.field(dtype=ti.i64, shape=(batch_size, 3)) + self.total_samples_fields = ti.field(dtype=ti.i64, + shape=(batch_size, )) + self.opacity_fields = ti.field(dtype=data_type, + shape=(batch_size, ), + needs_grad=True) + self.depth_fields = ti.field(dtype=data_type, + shape=(batch_size, ), + needs_grad=True) + self.rgb_fields = ti.field(dtype=data_type, + shape=(batch_size, 3), + needs_grad=True) + + # preallocate tensor + self.register_buffer('total_samples', + torch.zeros(batch_size, dtype=torch.int64)) + self.register_buffer('rgb', torch.zeros(batch_size, + 3, + dtype=torch_type)) + self.register_buffer('opacity', + torch.zeros(batch_size, dtype=torch_type)) + self.register_buffer('depth', torch.zeros(batch_size, + dtype=torch_type)) + self.register_buffer('ws', + torch.zeros(batch_size * 1024, dtype=torch_type)) + + self.register_buffer('sigma_grad', + torch.zeros(batch_size * 1024, dtype=torch_type)) + self.register_buffer( + 'rgb_grad', torch.zeros(batch_size * 1024, 3, dtype=torch_type)) + + class _module_function(torch.autograd.Function): + + @staticmethod + @custom_fwd(cast_inputs=torch_type) + def forward(ctx, sigmas, rgbs, deltas, ts, rays_a, T_threshold): + # If no output gradient is provided, no need to + # automatically materialize it as torch.zeros. + + ctx.T_threshold = T_threshold + ctx.samples_size = sigmas.shape[0] + + ws = self.ws[:sigmas.shape[0]] + + torch2ti(self.sigmas_fields, sigmas.contiguous()) + torch2ti(self.rgbs_fields, rgbs.contiguous()) + torch2ti(self.deltas_fields, deltas.contiguous()) + torch2ti(self.ts_fields, ts.contiguous()) + torch2ti(self.rays_a_fields, rays_a.contiguous()) + composite_train_fw(self.sigmas_fields, self.rgbs_fields, + self.deltas_fields, self.ts_fields, + self.rays_a_fields, T_threshold, self.T, + self.total_samples_fields, + self.opacity_fields, self.depth_fields, + self.rgb_fields, self.ws_fields) + ti2torch(self.total_samples_fields, self.total_samples) + ti2torch(self.opacity_fields, self.opacity) + ti2torch(self.depth_fields, self.depth) + ti2torch(self.rgb_fields, self.rgb) + + + return self.total_samples.sum( + ), self.opacity, self.depth, self.rgb, ws + + @staticmethod + @custom_bwd + def backward(ctx, dL_dtotal_samples, dL_dopacity, dL_ddepth, + dL_drgb, dL_dws): + + T_threshold = ctx.T_threshold + samples_size = ctx.samples_size + + sigma_grad = self.sigma_grad[:samples_size].contiguous() + rgb_grad = self.rgb_grad[:samples_size].contiguous() + + self.zero_grad() + + torch2ti_grad(self.opacity_fields, dL_dopacity.contiguous()) + torch2ti_grad(self.depth_fields, dL_ddepth.contiguous()) + torch2ti_grad(self.rgb_fields, dL_drgb.contiguous()) + torch2ti_grad(self.ws_fields, dL_dws.contiguous()) + composite_train_fw.grad(self.sigmas_fields, self.rgbs_fields, + self.deltas_fields, self.ts_fields, + self.rays_a_fields, T_threshold, + self.T, self.total_samples_fields, + self.opacity_fields, self.depth_fields, + self.rgb_fields, self.ws_fields) + ti2torch_grad(self.sigmas_fields, sigma_grad) + ti2torch_grad(self.rgbs_fields, rgb_grad) + + return sigma_grad, rgb_grad, None, None, None, None + + self._module_function = _module_function + + def zero_grad(self): + self.sigmas_fields.grad.fill(0.) + self.rgbs_fields.grad.fill(0.) + self.T.grad.fill(0.) + + + def forward(self, sigmas, rgbs, deltas, ts, rays_a, T_threshold): + return self._module_function.apply(sigmas, rgbs, deltas, ts, rays_a, + T_threshold) diff --git a/taming/lr_scheduler.py b/taming/lr_scheduler.py new file mode 100644 index 0000000..e598ed1 --- /dev/null +++ b/taming/lr_scheduler.py @@ -0,0 +1,34 @@ +import numpy as np + + +class LambdaWarmUpCosineScheduler: + """ + note: use with a base_lr of 1.0 + """ + def __init__(self, warm_up_steps, lr_min, lr_max, lr_start, max_decay_steps, verbosity_interval=0): + self.lr_warm_up_steps = warm_up_steps + self.lr_start = lr_start + self.lr_min = lr_min + self.lr_max = lr_max + self.lr_max_decay_steps = max_decay_steps + self.last_lr = 0. + self.verbosity_interval = verbosity_interval + + def schedule(self, n): + if self.verbosity_interval > 0: + if n % self.verbosity_interval == 0: print(f"current step: {n}, recent lr-multiplier: {self.last_lr}") + if n < self.lr_warm_up_steps: + lr = (self.lr_max - self.lr_start) / self.lr_warm_up_steps * n + self.lr_start + self.last_lr = lr + return lr + else: + t = (n - self.lr_warm_up_steps) / (self.lr_max_decay_steps - self.lr_warm_up_steps) + t = min(t, 1.0) + lr = self.lr_min + 0.5 * (self.lr_max - self.lr_min) * ( + 1 + np.cos(t * np.pi)) + self.last_lr = lr + return lr + + def __call__(self, n): + return self.schedule(n) + diff --git a/taming/models/cond_transformer.py b/taming/models/cond_transformer.py new file mode 100644 index 0000000..e4c6373 --- /dev/null +++ b/taming/models/cond_transformer.py @@ -0,0 +1,352 @@ +import os, math +import torch +import torch.nn.functional as F +import pytorch_lightning as pl + +from main import instantiate_from_config +from taming.modules.util import SOSProvider + + +def disabled_train(self, mode=True): + """Overwrite model.train with this function to make sure train/eval mode + does not change anymore.""" + return self + + +class Net2NetTransformer(pl.LightningModule): + def __init__(self, + transformer_config, + first_stage_config, + cond_stage_config, + permuter_config=None, + ckpt_path=None, + ignore_keys=[], + first_stage_key="image", + cond_stage_key="depth", + downsample_cond_size=-1, + pkeep=1.0, + sos_token=0, + unconditional=False, + ): + super().__init__() + self.be_unconditional = unconditional + self.sos_token = sos_token + self.first_stage_key = first_stage_key + self.cond_stage_key = cond_stage_key + self.init_first_stage_from_ckpt(first_stage_config) + self.init_cond_stage_from_ckpt(cond_stage_config) + if permuter_config is None: + permuter_config = {"target": "taming.modules.transformer.permuter.Identity"} + self.permuter = instantiate_from_config(config=permuter_config) + self.transformer = instantiate_from_config(config=transformer_config) + + if ckpt_path is not None: + self.init_from_ckpt(ckpt_path, ignore_keys=ignore_keys) + self.downsample_cond_size = downsample_cond_size + self.pkeep = pkeep + + def init_from_ckpt(self, path, ignore_keys=list()): + sd = torch.load(path, map_location="cpu")["state_dict"] + for k in sd.keys(): + for ik in ignore_keys: + if k.startswith(ik): + self.print("Deleting key {} from state_dict.".format(k)) + del sd[k] + self.load_state_dict(sd, strict=False) + print(f"Restored from {path}") + + def init_first_stage_from_ckpt(self, config): + model = instantiate_from_config(config) + model = model.eval() + model.train = disabled_train + self.first_stage_model = model + + def init_cond_stage_from_ckpt(self, config): + if config == "__is_first_stage__": + print("Using first stage also as cond stage.") + self.cond_stage_model = self.first_stage_model + elif config == "__is_unconditional__" or self.be_unconditional: + print(f"Using no cond stage. Assuming the training is intended to be unconditional. " + f"Prepending {self.sos_token} as a sos token.") + self.be_unconditional = True + self.cond_stage_key = self.first_stage_key + self.cond_stage_model = SOSProvider(self.sos_token) + else: + model = instantiate_from_config(config) + model = model.eval() + model.train = disabled_train + self.cond_stage_model = model + + def forward(self, x, c): + # one step to produce the logits + _, z_indices = self.encode_to_z(x) + _, c_indices = self.encode_to_c(c) + + if self.training and self.pkeep < 1.0: + mask = torch.bernoulli(self.pkeep*torch.ones(z_indices.shape, + device=z_indices.device)) + mask = mask.round().to(dtype=torch.int64) + r_indices = torch.randint_like(z_indices, self.transformer.config.vocab_size) + a_indices = mask*z_indices+(1-mask)*r_indices + else: + a_indices = z_indices + + cz_indices = torch.cat((c_indices, a_indices), dim=1) + + # target includes all sequence elements (no need to handle first one + # differently because we are conditioning) + target = z_indices + # make the prediction + logits, _ = self.transformer(cz_indices[:, :-1]) + # cut off conditioning outputs - output i corresponds to p(z_i | z_{ -1: + c = F.interpolate(c, size=(self.downsample_cond_size, self.downsample_cond_size)) + quant_c, _, [_,_,indices] = self.cond_stage_model.encode(c) + if len(indices.shape) > 2: + indices = indices.view(c.shape[0], -1) + return quant_c, indices + + @torch.no_grad() + def decode_to_img(self, index, zshape): + index = self.permuter(index, reverse=True) + bhwc = (zshape[0],zshape[2],zshape[3],zshape[1]) + quant_z = self.first_stage_model.quantize.get_codebook_entry( + index.reshape(-1), shape=bhwc) + x = self.first_stage_model.decode(quant_z) + return x + + @torch.no_grad() + def log_images(self, batch, temperature=None, top_k=None, callback=None, lr_interface=False, **kwargs): + log = dict() + + N = 4 + if lr_interface: + x, c = self.get_xc(batch, N, diffuse=False, upsample_factor=8) + else: + x, c = self.get_xc(batch, N) + x = x.to(device=self.device) + c = c.to(device=self.device) + + quant_z, z_indices = self.encode_to_z(x) + quant_c, c_indices = self.encode_to_c(c) + + # create a "half"" sample + z_start_indices = z_indices[:,:z_indices.shape[1]//2] + index_sample = self.sample(z_start_indices, c_indices, + steps=z_indices.shape[1]-z_start_indices.shape[1], + temperature=temperature if temperature is not None else 1.0, + sample=True, + top_k=top_k if top_k is not None else 100, + callback=callback if callback is not None else lambda k: None) + x_sample = self.decode_to_img(index_sample, quant_z.shape) + + # sample + z_start_indices = z_indices[:, :0] + index_sample = self.sample(z_start_indices, c_indices, + steps=z_indices.shape[1], + temperature=temperature if temperature is not None else 1.0, + sample=True, + top_k=top_k if top_k is not None else 100, + callback=callback if callback is not None else lambda k: None) + x_sample_nopix = self.decode_to_img(index_sample, quant_z.shape) + + # det sample + z_start_indices = z_indices[:, :0] + index_sample = self.sample(z_start_indices, c_indices, + steps=z_indices.shape[1], + sample=False, + callback=callback if callback is not None else lambda k: None) + x_sample_det = self.decode_to_img(index_sample, quant_z.shape) + + # reconstruction + x_rec = self.decode_to_img(z_indices, quant_z.shape) + + log["inputs"] = x + log["reconstructions"] = x_rec + + if self.cond_stage_key in ["objects_bbox", "objects_center_points"]: + figure_size = (x_rec.shape[2], x_rec.shape[3]) + dataset = kwargs["pl_module"].trainer.datamodule.datasets["validation"] + label_for_category_no = dataset.get_textual_label_for_category_no + plotter = dataset.conditional_builders[self.cond_stage_key].plot + log["conditioning"] = torch.zeros_like(log["reconstructions"]) + for i in range(quant_c.shape[0]): + log["conditioning"][i] = plotter(quant_c[i], label_for_category_no, figure_size) + log["conditioning_rec"] = log["conditioning"] + elif self.cond_stage_key != "image": + cond_rec = self.cond_stage_model.decode(quant_c) + if self.cond_stage_key == "segmentation": + # get image from segmentation mask + num_classes = cond_rec.shape[1] + + c = torch.argmax(c, dim=1, keepdim=True) + c = F.one_hot(c, num_classes=num_classes) + c = c.squeeze(1).permute(0, 3, 1, 2).float() + c = self.cond_stage_model.to_rgb(c) + + cond_rec = torch.argmax(cond_rec, dim=1, keepdim=True) + cond_rec = F.one_hot(cond_rec, num_classes=num_classes) + cond_rec = cond_rec.squeeze(1).permute(0, 3, 1, 2).float() + cond_rec = self.cond_stage_model.to_rgb(cond_rec) + log["conditioning_rec"] = cond_rec + log["conditioning"] = c + + log["samples_half"] = x_sample + log["samples_nopix"] = x_sample_nopix + log["samples_det"] = x_sample_det + return log + + def get_input(self, key, batch): + x = batch[key] + if len(x.shape) == 3: + x = x[..., None] + if len(x.shape) == 4: + x = x.permute(0, 3, 1, 2).to(memory_format=torch.contiguous_format) + if x.dtype == torch.double: + x = x.float() + return x + + def get_xc(self, batch, N=None): + x = self.get_input(self.first_stage_key, batch) + c = self.get_input(self.cond_stage_key, batch) + if N is not None: + x = x[:N] + c = c[:N] + return x, c + + def shared_step(self, batch, batch_idx): + x, c = self.get_xc(batch) + logits, target = self(x, c) + loss = F.cross_entropy(logits.reshape(-1, logits.size(-1)), target.reshape(-1)) + return loss + + def training_step(self, batch, batch_idx): + loss = self.shared_step(batch, batch_idx) + self.log("train/loss", loss, prog_bar=True, logger=True, on_step=True, on_epoch=True) + return loss + + def validation_step(self, batch, batch_idx): + loss = self.shared_step(batch, batch_idx) + self.log("val/loss", loss, prog_bar=True, logger=True, on_step=True, on_epoch=True) + return loss + + def configure_optimizers(self): + """ + Following minGPT: + This long function is unfortunately doing something very simple and is being very defensive: + We are separating out all parameters of the model into two buckets: those that will experience + weight decay for regularization and those that won't (biases, and layernorm/embedding weights). + We are then returning the PyTorch optimizer object. + """ + # separate out all parameters to those that will and won't experience regularizing weight decay + decay = set() + no_decay = set() + whitelist_weight_modules = (torch.nn.Linear, ) + blacklist_weight_modules = (torch.nn.LayerNorm, torch.nn.Embedding) + for mn, m in self.transformer.named_modules(): + for pn, p in m.named_parameters(): + fpn = '%s.%s' % (mn, pn) if mn else pn # full param name + + if pn.endswith('bias'): + # all biases will not be decayed + no_decay.add(fpn) + elif pn.endswith('weight') and isinstance(m, whitelist_weight_modules): + # weights of whitelist modules will be weight decayed + decay.add(fpn) + elif pn.endswith('weight') and isinstance(m, blacklist_weight_modules): + # weights of blacklist modules will NOT be weight decayed + no_decay.add(fpn) + + # special case the position embedding parameter in the root GPT module as not decayed + no_decay.add('pos_emb') + + # validate that we considered every parameter + param_dict = {pn: p for pn, p in self.transformer.named_parameters()} + inter_params = decay & no_decay + union_params = decay | no_decay + assert len(inter_params) == 0, "parameters %s made it into both decay/no_decay sets!" % (str(inter_params), ) + assert len(param_dict.keys() - union_params) == 0, "parameters %s were not separated into either decay/no_decay set!" \ + % (str(param_dict.keys() - union_params), ) + + # create the pytorch optimizer object + optim_groups = [ + {"params": [param_dict[pn] for pn in sorted(list(decay))], "weight_decay": 0.01}, + {"params": [param_dict[pn] for pn in sorted(list(no_decay))], "weight_decay": 0.0}, + ] + optimizer = torch.optim.AdamW(optim_groups, lr=self.learning_rate, betas=(0.9, 0.95)) + return optimizer diff --git a/taming/models/dummy_cond_stage.py b/taming/models/dummy_cond_stage.py new file mode 100644 index 0000000..6e19938 --- /dev/null +++ b/taming/models/dummy_cond_stage.py @@ -0,0 +1,22 @@ +from torch import Tensor + + +class DummyCondStage: + def __init__(self, conditional_key): + self.conditional_key = conditional_key + self.train = None + + def eval(self): + return self + + @staticmethod + def encode(c: Tensor): + return c, None, (None, None, c) + + @staticmethod + def decode(c: Tensor): + return c + + @staticmethod + def to_rgb(c: Tensor): + return c diff --git a/taming/models/vqgan.py b/taming/models/vqgan.py new file mode 100644 index 0000000..a6950ba --- /dev/null +++ b/taming/models/vqgan.py @@ -0,0 +1,404 @@ +import torch +import torch.nn.functional as F +import pytorch_lightning as pl + +from main import instantiate_from_config + +from taming.modules.diffusionmodules.model import Encoder, Decoder +from taming.modules.vqvae.quantize import VectorQuantizer2 as VectorQuantizer +from taming.modules.vqvae.quantize import GumbelQuantize +from taming.modules.vqvae.quantize import EMAVectorQuantizer + +class VQModel(pl.LightningModule): + def __init__(self, + ddconfig, + lossconfig, + n_embed, + embed_dim, + ckpt_path=None, + ignore_keys=[], + image_key="image", + colorize_nlabels=None, + monitor=None, + remap=None, + sane_index_shape=False, # tell vector quantizer to return indices as bhw + ): + super().__init__() + self.image_key = image_key + self.encoder = Encoder(**ddconfig) + self.decoder = Decoder(**ddconfig) + self.loss = instantiate_from_config(lossconfig) + self.quantize = VectorQuantizer(n_embed, embed_dim, beta=0.25, + remap=remap, sane_index_shape=sane_index_shape) + self.quant_conv = torch.nn.Conv2d(ddconfig["z_channels"], embed_dim, 1) + self.post_quant_conv = torch.nn.Conv2d(embed_dim, ddconfig["z_channels"], 1) + if ckpt_path is not None: + self.init_from_ckpt(ckpt_path, ignore_keys=ignore_keys) + self.image_key = image_key + if colorize_nlabels is not None: + assert type(colorize_nlabels)==int + self.register_buffer("colorize", torch.randn(3, colorize_nlabels, 1, 1)) + if monitor is not None: + self.monitor = monitor + + def init_from_ckpt(self, path, ignore_keys=list()): + sd = torch.load(path, map_location="cpu")["state_dict"] + keys = list(sd.keys()) + for k in keys: + for ik in ignore_keys: + if k.startswith(ik): + print("Deleting key {} from state_dict.".format(k)) + del sd[k] + self.load_state_dict(sd, strict=False) + print(f"Restored from {path}") + + def encode(self, x): + h = self.encoder(x) + h = self.quant_conv(h) + quant, emb_loss, info = self.quantize(h) + return quant, emb_loss, info + + def decode(self, quant): + quant = self.post_quant_conv(quant) + dec = self.decoder(quant) + return dec + + def decode_code(self, code_b): + quant_b = self.quantize.embed_code(code_b) + dec = self.decode(quant_b) + return dec + + def forward(self, input): + quant, diff, _ = self.encode(input) + dec = self.decode(quant) + return dec, diff + + def get_input(self, batch, k): + x = batch[k] + if len(x.shape) == 3: + x = x[..., None] + x = x.permute(0, 3, 1, 2).to(memory_format=torch.contiguous_format) + return x.float() + + def training_step(self, batch, batch_idx, optimizer_idx): + x = self.get_input(batch, self.image_key) + xrec, qloss = self(x) + + if optimizer_idx == 0: + # autoencode + aeloss, log_dict_ae = self.loss(qloss, x, xrec, optimizer_idx, self.global_step, + last_layer=self.get_last_layer(), split="train") + + self.log("train/aeloss", aeloss, prog_bar=True, logger=True, on_step=True, on_epoch=True) + self.log_dict(log_dict_ae, prog_bar=False, logger=True, on_step=True, on_epoch=True) + return aeloss + + if optimizer_idx == 1: + # discriminator + discloss, log_dict_disc = self.loss(qloss, x, xrec, optimizer_idx, self.global_step, + last_layer=self.get_last_layer(), split="train") + self.log("train/discloss", discloss, prog_bar=True, logger=True, on_step=True, on_epoch=True) + self.log_dict(log_dict_disc, prog_bar=False, logger=True, on_step=True, on_epoch=True) + return discloss + + def validation_step(self, batch, batch_idx): + x = self.get_input(batch, self.image_key) + xrec, qloss = self(x) + aeloss, log_dict_ae = self.loss(qloss, x, xrec, 0, self.global_step, + last_layer=self.get_last_layer(), split="val") + + discloss, log_dict_disc = self.loss(qloss, x, xrec, 1, self.global_step, + last_layer=self.get_last_layer(), split="val") + rec_loss = log_dict_ae["val/rec_loss"] + self.log("val/rec_loss", rec_loss, + prog_bar=True, logger=True, on_step=True, on_epoch=True, sync_dist=True) + self.log("val/aeloss", aeloss, + prog_bar=True, logger=True, on_step=True, on_epoch=True, sync_dist=True) + self.log_dict(log_dict_ae) + self.log_dict(log_dict_disc) + return self.log_dict + + def configure_optimizers(self): + lr = self.learning_rate + opt_ae = torch.optim.Adam(list(self.encoder.parameters())+ + list(self.decoder.parameters())+ + list(self.quantize.parameters())+ + list(self.quant_conv.parameters())+ + list(self.post_quant_conv.parameters()), + lr=lr, betas=(0.5, 0.9)) + opt_disc = torch.optim.Adam(self.loss.discriminator.parameters(), + lr=lr, betas=(0.5, 0.9)) + return [opt_ae, opt_disc], [] + + def get_last_layer(self): + return self.decoder.conv_out.weight + + def log_images(self, batch, **kwargs): + log = dict() + x = self.get_input(batch, self.image_key) + x = x.to(self.device) + xrec, _ = self(x) + if x.shape[1] > 3: + # colorize with random projection + assert xrec.shape[1] > 3 + x = self.to_rgb(x) + xrec = self.to_rgb(xrec) + log["inputs"] = x + log["reconstructions"] = xrec + return log + + def to_rgb(self, x): + assert self.image_key == "segmentation" + if not hasattr(self, "colorize"): + self.register_buffer("colorize", torch.randn(3, x.shape[1], 1, 1).to(x)) + x = F.conv2d(x, weight=self.colorize) + x = 2.*(x-x.min())/(x.max()-x.min()) - 1. + return x + + +class VQSegmentationModel(VQModel): + def __init__(self, n_labels, *args, **kwargs): + super().__init__(*args, **kwargs) + self.register_buffer("colorize", torch.randn(3, n_labels, 1, 1)) + + def configure_optimizers(self): + lr = self.learning_rate + opt_ae = torch.optim.Adam(list(self.encoder.parameters())+ + list(self.decoder.parameters())+ + list(self.quantize.parameters())+ + list(self.quant_conv.parameters())+ + list(self.post_quant_conv.parameters()), + lr=lr, betas=(0.5, 0.9)) + return opt_ae + + def training_step(self, batch, batch_idx): + x = self.get_input(batch, self.image_key) + xrec, qloss = self(x) + aeloss, log_dict_ae = self.loss(qloss, x, xrec, split="train") + self.log_dict(log_dict_ae, prog_bar=False, logger=True, on_step=True, on_epoch=True) + return aeloss + + def validation_step(self, batch, batch_idx): + x = self.get_input(batch, self.image_key) + xrec, qloss = self(x) + aeloss, log_dict_ae = self.loss(qloss, x, xrec, split="val") + self.log_dict(log_dict_ae, prog_bar=False, logger=True, on_step=True, on_epoch=True) + total_loss = log_dict_ae["val/total_loss"] + self.log("val/total_loss", total_loss, + prog_bar=True, logger=True, on_step=True, on_epoch=True, sync_dist=True) + return aeloss + + @torch.no_grad() + def log_images(self, batch, **kwargs): + log = dict() + x = self.get_input(batch, self.image_key) + x = x.to(self.device) + xrec, _ = self(x) + if x.shape[1] > 3: + # colorize with random projection + assert xrec.shape[1] > 3 + # convert logits to indices + xrec = torch.argmax(xrec, dim=1, keepdim=True) + xrec = F.one_hot(xrec, num_classes=x.shape[1]) + xrec = xrec.squeeze(1).permute(0, 3, 1, 2).float() + x = self.to_rgb(x) + xrec = self.to_rgb(xrec) + log["inputs"] = x + log["reconstructions"] = xrec + return log + + +class VQNoDiscModel(VQModel): + def __init__(self, + ddconfig, + lossconfig, + n_embed, + embed_dim, + ckpt_path=None, + ignore_keys=[], + image_key="image", + colorize_nlabels=None + ): + super().__init__(ddconfig=ddconfig, lossconfig=lossconfig, n_embed=n_embed, embed_dim=embed_dim, + ckpt_path=ckpt_path, ignore_keys=ignore_keys, image_key=image_key, + colorize_nlabels=colorize_nlabels) + + def training_step(self, batch, batch_idx): + x = self.get_input(batch, self.image_key) + xrec, qloss = self(x) + # autoencode + aeloss, log_dict_ae = self.loss(qloss, x, xrec, self.global_step, split="train") + output = pl.TrainResult(minimize=aeloss) + output.log("train/aeloss", aeloss, + prog_bar=True, logger=True, on_step=True, on_epoch=True) + output.log_dict(log_dict_ae, prog_bar=False, logger=True, on_step=True, on_epoch=True) + return output + + def validation_step(self, batch, batch_idx): + x = self.get_input(batch, self.image_key) + xrec, qloss = self(x) + aeloss, log_dict_ae = self.loss(qloss, x, xrec, self.global_step, split="val") + rec_loss = log_dict_ae["val/rec_loss"] + output = pl.EvalResult(checkpoint_on=rec_loss) + output.log("val/rec_loss", rec_loss, + prog_bar=True, logger=True, on_step=True, on_epoch=True) + output.log("val/aeloss", aeloss, + prog_bar=True, logger=True, on_step=True, on_epoch=True) + output.log_dict(log_dict_ae) + + return output + + def configure_optimizers(self): + optimizer = torch.optim.Adam(list(self.encoder.parameters())+ + list(self.decoder.parameters())+ + list(self.quantize.parameters())+ + list(self.quant_conv.parameters())+ + list(self.post_quant_conv.parameters()), + lr=self.learning_rate, betas=(0.5, 0.9)) + return optimizer + + +class GumbelVQ(VQModel): + def __init__(self, + ddconfig, + lossconfig, + n_embed, + embed_dim, + temperature_scheduler_config, + ckpt_path=None, + ignore_keys=[], + image_key="image", + colorize_nlabels=None, + monitor=None, + kl_weight=1e-8, + remap=None, + ): + + z_channels = ddconfig["z_channels"] + super().__init__(ddconfig, + lossconfig, + n_embed, + embed_dim, + ckpt_path=None, + ignore_keys=ignore_keys, + image_key=image_key, + colorize_nlabels=colorize_nlabels, + monitor=monitor, + ) + + self.loss.n_classes = n_embed + self.vocab_size = n_embed + + self.quantize = GumbelQuantize(z_channels, embed_dim, + n_embed=n_embed, + kl_weight=kl_weight, temp_init=1.0, + remap=remap) + + self.temperature_scheduler = instantiate_from_config(temperature_scheduler_config) # annealing of temp + + if ckpt_path is not None: + self.init_from_ckpt(ckpt_path, ignore_keys=ignore_keys) + + def temperature_scheduling(self): + self.quantize.temperature = self.temperature_scheduler(self.global_step) + + def encode_to_prequant(self, x): + h = self.encoder(x) + h = self.quant_conv(h) + return h + + def decode_code(self, code_b): + raise NotImplementedError + + def training_step(self, batch, batch_idx, optimizer_idx): + self.temperature_scheduling() + x = self.get_input(batch, self.image_key) + xrec, qloss = self(x) + + if optimizer_idx == 0: + # autoencode + aeloss, log_dict_ae = self.loss(qloss, x, xrec, optimizer_idx, self.global_step, + last_layer=self.get_last_layer(), split="train") + + self.log_dict(log_dict_ae, prog_bar=False, logger=True, on_step=True, on_epoch=True) + self.log("temperature", self.quantize.temperature, prog_bar=False, logger=True, on_step=True, on_epoch=True) + return aeloss + + if optimizer_idx == 1: + # discriminator + discloss, log_dict_disc = self.loss(qloss, x, xrec, optimizer_idx, self.global_step, + last_layer=self.get_last_layer(), split="train") + self.log_dict(log_dict_disc, prog_bar=False, logger=True, on_step=True, on_epoch=True) + return discloss + + def validation_step(self, batch, batch_idx): + x = self.get_input(batch, self.image_key) + xrec, qloss = self(x, return_pred_indices=True) + aeloss, log_dict_ae = self.loss(qloss, x, xrec, 0, self.global_step, + last_layer=self.get_last_layer(), split="val") + + discloss, log_dict_disc = self.loss(qloss, x, xrec, 1, self.global_step, + last_layer=self.get_last_layer(), split="val") + rec_loss = log_dict_ae["val/rec_loss"] + self.log("val/rec_loss", rec_loss, + prog_bar=True, logger=True, on_step=False, on_epoch=True, sync_dist=True) + self.log("val/aeloss", aeloss, + prog_bar=True, logger=True, on_step=False, on_epoch=True, sync_dist=True) + self.log_dict(log_dict_ae) + self.log_dict(log_dict_disc) + return self.log_dict + + def log_images(self, batch, **kwargs): + log = dict() + x = self.get_input(batch, self.image_key) + x = x.to(self.device) + # encode + h = self.encoder(x) + h = self.quant_conv(h) + quant, _, _ = self.quantize(h) + # decode + x_rec = self.decode(quant) + log["inputs"] = x + log["reconstructions"] = x_rec + return log + + +class EMAVQ(VQModel): + def __init__(self, + ddconfig, + lossconfig, + n_embed, + embed_dim, + ckpt_path=None, + ignore_keys=[], + image_key="image", + colorize_nlabels=None, + monitor=None, + remap=None, + sane_index_shape=False, # tell vector quantizer to return indices as bhw + ): + super().__init__(ddconfig, + lossconfig, + n_embed, + embed_dim, + ckpt_path=None, + ignore_keys=ignore_keys, + image_key=image_key, + colorize_nlabels=colorize_nlabels, + monitor=monitor, + ) + self.quantize = EMAVectorQuantizer(n_embed=n_embed, + embedding_dim=embed_dim, + beta=0.25, + remap=remap) + def configure_optimizers(self): + lr = self.learning_rate + #Remove self.quantize from parameter list since it is updated via EMA + opt_ae = torch.optim.Adam(list(self.encoder.parameters())+ + list(self.decoder.parameters())+ + list(self.quant_conv.parameters())+ + list(self.post_quant_conv.parameters()), + lr=lr, betas=(0.5, 0.9)) + opt_disc = torch.optim.Adam(self.loss.discriminator.parameters(), + lr=lr, betas=(0.5, 0.9)) + return [opt_ae, opt_disc], [] \ No newline at end of file diff --git a/taming/modules/diffusionmodules/model.py b/taming/modules/diffusionmodules/model.py new file mode 100644 index 0000000..d3a5db6 --- /dev/null +++ b/taming/modules/diffusionmodules/model.py @@ -0,0 +1,776 @@ +# pytorch_diffusion + derived encoder decoder +import math +import torch +import torch.nn as nn +import numpy as np + + +def get_timestep_embedding(timesteps, embedding_dim): + """ + This matches the implementation in Denoising Diffusion Probabilistic Models: + From Fairseq. + Build sinusoidal embeddings. + This matches the implementation in tensor2tensor, but differs slightly + from the description in Section 3.5 of "Attention Is All You Need". + """ + assert len(timesteps.shape) == 1 + + half_dim = embedding_dim // 2 + emb = math.log(10000) / (half_dim - 1) + emb = torch.exp(torch.arange(half_dim, dtype=torch.float32) * -emb) + emb = emb.to(device=timesteps.device) + emb = timesteps.float()[:, None] * emb[None, :] + emb = torch.cat([torch.sin(emb), torch.cos(emb)], dim=1) + if embedding_dim % 2 == 1: # zero pad + emb = torch.nn.functional.pad(emb, (0,1,0,0)) + return emb + + +def nonlinearity(x): + # swish + return x*torch.sigmoid(x) + + +def Normalize(in_channels): + return torch.nn.GroupNorm(num_groups=32, num_channels=in_channels, eps=1e-6, affine=True) + + +class Upsample(nn.Module): + def __init__(self, in_channels, with_conv): + super().__init__() + self.with_conv = with_conv + if self.with_conv: + self.conv = torch.nn.Conv2d(in_channels, + in_channels, + kernel_size=3, + stride=1, + padding=1) + + def forward(self, x): + x = torch.nn.functional.interpolate(x, scale_factor=2.0, mode="nearest") + if self.with_conv: + x = self.conv(x) + return x + + +class Downsample(nn.Module): + def __init__(self, in_channels, with_conv): + super().__init__() + self.with_conv = with_conv + if self.with_conv: + # no asymmetric padding in torch conv, must do it ourselves + self.conv = torch.nn.Conv2d(in_channels, + in_channels, + kernel_size=3, + stride=2, + padding=0) + + def forward(self, x): + if self.with_conv: + pad = (0,1,0,1) + x = torch.nn.functional.pad(x, pad, mode="constant", value=0) + x = self.conv(x) + else: + x = torch.nn.functional.avg_pool2d(x, kernel_size=2, stride=2) + return x + + +class ResnetBlock(nn.Module): + def __init__(self, *, in_channels, out_channels=None, conv_shortcut=False, + dropout, temb_channels=512): + super().__init__() + self.in_channels = in_channels + out_channels = in_channels if out_channels is None else out_channels + self.out_channels = out_channels + self.use_conv_shortcut = conv_shortcut + + self.norm1 = Normalize(in_channels) + self.conv1 = torch.nn.Conv2d(in_channels, + out_channels, + kernel_size=3, + stride=1, + padding=1) + if temb_channels > 0: + self.temb_proj = torch.nn.Linear(temb_channels, + out_channels) + self.norm2 = Normalize(out_channels) + self.dropout = torch.nn.Dropout(dropout) + self.conv2 = torch.nn.Conv2d(out_channels, + out_channels, + kernel_size=3, + stride=1, + padding=1) + if self.in_channels != self.out_channels: + if self.use_conv_shortcut: + self.conv_shortcut = torch.nn.Conv2d(in_channels, + out_channels, + kernel_size=3, + stride=1, + padding=1) + else: + self.nin_shortcut = torch.nn.Conv2d(in_channels, + out_channels, + kernel_size=1, + stride=1, + padding=0) + + def forward(self, x, temb): + h = x + h = self.norm1(h) + h = nonlinearity(h) + h = self.conv1(h) + + if temb is not None: + h = h + self.temb_proj(nonlinearity(temb))[:,:,None,None] + + h = self.norm2(h) + h = nonlinearity(h) + h = self.dropout(h) + h = self.conv2(h) + + if self.in_channels != self.out_channels: + if self.use_conv_shortcut: + x = self.conv_shortcut(x) + else: + x = self.nin_shortcut(x) + + return x+h + + +class AttnBlock(nn.Module): + def __init__(self, in_channels): + super().__init__() + self.in_channels = in_channels + + self.norm = Normalize(in_channels) + self.q = torch.nn.Conv2d(in_channels, + in_channels, + kernel_size=1, + stride=1, + padding=0) + self.k = torch.nn.Conv2d(in_channels, + in_channels, + kernel_size=1, + stride=1, + padding=0) + self.v = torch.nn.Conv2d(in_channels, + in_channels, + kernel_size=1, + stride=1, + padding=0) + self.proj_out = torch.nn.Conv2d(in_channels, + in_channels, + kernel_size=1, + stride=1, + padding=0) + + + def forward(self, x): + h_ = x + h_ = self.norm(h_) + q = self.q(h_) + k = self.k(h_) + v = self.v(h_) + + # compute attention + b,c,h,w = q.shape + q = q.reshape(b,c,h*w) + q = q.permute(0,2,1) # b,hw,c + k = k.reshape(b,c,h*w) # b,c,hw + w_ = torch.bmm(q,k) # b,hw,hw w[b,i,j]=sum_c q[b,i,c]k[b,c,j] + w_ = w_ * (int(c)**(-0.5)) + w_ = torch.nn.functional.softmax(w_, dim=2) + + # attend to values + v = v.reshape(b,c,h*w) + w_ = w_.permute(0,2,1) # b,hw,hw (first hw of k, second of q) + h_ = torch.bmm(v,w_) # b, c,hw (hw of q) h_[b,c,j] = sum_i v[b,c,i] w_[b,i,j] + h_ = h_.reshape(b,c,h,w) + + h_ = self.proj_out(h_) + + return x+h_ + + +class Model(nn.Module): + def __init__(self, *, ch, out_ch, ch_mult=(1,2,4,8), num_res_blocks, + attn_resolutions, dropout=0.0, resamp_with_conv=True, in_channels, + resolution, use_timestep=True): + super().__init__() + self.ch = ch + self.temb_ch = self.ch*4 + self.num_resolutions = len(ch_mult) + self.num_res_blocks = num_res_blocks + self.resolution = resolution + self.in_channels = in_channels + + self.use_timestep = use_timestep + if self.use_timestep: + # timestep embedding + self.temb = nn.Module() + self.temb.dense = nn.ModuleList([ + torch.nn.Linear(self.ch, + self.temb_ch), + torch.nn.Linear(self.temb_ch, + self.temb_ch), + ]) + + # downsampling + self.conv_in = torch.nn.Conv2d(in_channels, + self.ch, + kernel_size=3, + stride=1, + padding=1) + + curr_res = resolution + in_ch_mult = (1,)+tuple(ch_mult) + self.down = nn.ModuleList() + for i_level in range(self.num_resolutions): + block = nn.ModuleList() + attn = nn.ModuleList() + block_in = ch*in_ch_mult[i_level] + block_out = ch*ch_mult[i_level] + for i_block in range(self.num_res_blocks): + block.append(ResnetBlock(in_channels=block_in, + out_channels=block_out, + temb_channels=self.temb_ch, + dropout=dropout)) + block_in = block_out + if curr_res in attn_resolutions: + attn.append(AttnBlock(block_in)) + down = nn.Module() + down.block = block + down.attn = attn + if i_level != self.num_resolutions-1: + down.downsample = Downsample(block_in, resamp_with_conv) + curr_res = curr_res // 2 + self.down.append(down) + + # middle + self.mid = nn.Module() + self.mid.block_1 = ResnetBlock(in_channels=block_in, + out_channels=block_in, + temb_channels=self.temb_ch, + dropout=dropout) + self.mid.attn_1 = AttnBlock(block_in) + self.mid.block_2 = ResnetBlock(in_channels=block_in, + out_channels=block_in, + temb_channels=self.temb_ch, + dropout=dropout) + + # upsampling + self.up = nn.ModuleList() + for i_level in reversed(range(self.num_resolutions)): + block = nn.ModuleList() + attn = nn.ModuleList() + block_out = ch*ch_mult[i_level] + skip_in = ch*ch_mult[i_level] + for i_block in range(self.num_res_blocks+1): + if i_block == self.num_res_blocks: + skip_in = ch*in_ch_mult[i_level] + block.append(ResnetBlock(in_channels=block_in+skip_in, + out_channels=block_out, + temb_channels=self.temb_ch, + dropout=dropout)) + block_in = block_out + if curr_res in attn_resolutions: + attn.append(AttnBlock(block_in)) + up = nn.Module() + up.block = block + up.attn = attn + if i_level != 0: + up.upsample = Upsample(block_in, resamp_with_conv) + curr_res = curr_res * 2 + self.up.insert(0, up) # prepend to get consistent order + + # end + self.norm_out = Normalize(block_in) + self.conv_out = torch.nn.Conv2d(block_in, + out_ch, + kernel_size=3, + stride=1, + padding=1) + + + def forward(self, x, t=None): + #assert x.shape[2] == x.shape[3] == self.resolution + + if self.use_timestep: + # timestep embedding + assert t is not None + temb = get_timestep_embedding(t, self.ch) + temb = self.temb.dense[0](temb) + temb = nonlinearity(temb) + temb = self.temb.dense[1](temb) + else: + temb = None + + # downsampling + hs = [self.conv_in(x)] + for i_level in range(self.num_resolutions): + for i_block in range(self.num_res_blocks): + h = self.down[i_level].block[i_block](hs[-1], temb) + if len(self.down[i_level].attn) > 0: + h = self.down[i_level].attn[i_block](h) + hs.append(h) + if i_level != self.num_resolutions-1: + hs.append(self.down[i_level].downsample(hs[-1])) + + # middle + h = hs[-1] + h = self.mid.block_1(h, temb) + h = self.mid.attn_1(h) + h = self.mid.block_2(h, temb) + + # upsampling + for i_level in reversed(range(self.num_resolutions)): + for i_block in range(self.num_res_blocks+1): + h = self.up[i_level].block[i_block]( + torch.cat([h, hs.pop()], dim=1), temb) + if len(self.up[i_level].attn) > 0: + h = self.up[i_level].attn[i_block](h) + if i_level != 0: + h = self.up[i_level].upsample(h) + + # end + h = self.norm_out(h) + h = nonlinearity(h) + h = self.conv_out(h) + return h + + +class Encoder(nn.Module): + def __init__(self, *, ch, out_ch, ch_mult=(1,2,4,8), num_res_blocks, + attn_resolutions, dropout=0.0, resamp_with_conv=True, in_channels, + resolution, z_channels, double_z=True, **ignore_kwargs): + super().__init__() + self.ch = ch + self.temb_ch = 0 + self.num_resolutions = len(ch_mult) + self.num_res_blocks = num_res_blocks + self.resolution = resolution + self.in_channels = in_channels + + # downsampling + self.conv_in = torch.nn.Conv2d(in_channels, + self.ch, + kernel_size=3, + stride=1, + padding=1) + + curr_res = resolution + in_ch_mult = (1,)+tuple(ch_mult) + self.down = nn.ModuleList() + for i_level in range(self.num_resolutions): + block = nn.ModuleList() + attn = nn.ModuleList() + block_in = ch*in_ch_mult[i_level] + block_out = ch*ch_mult[i_level] + for i_block in range(self.num_res_blocks): + block.append(ResnetBlock(in_channels=block_in, + out_channels=block_out, + temb_channels=self.temb_ch, + dropout=dropout)) + block_in = block_out + if curr_res in attn_resolutions: + attn.append(AttnBlock(block_in)) + down = nn.Module() + down.block = block + down.attn = attn + if i_level != self.num_resolutions-1: + down.downsample = Downsample(block_in, resamp_with_conv) + curr_res = curr_res // 2 + self.down.append(down) + + # middle + self.mid = nn.Module() + self.mid.block_1 = ResnetBlock(in_channels=block_in, + out_channels=block_in, + temb_channels=self.temb_ch, + dropout=dropout) + self.mid.attn_1 = AttnBlock(block_in) + self.mid.block_2 = ResnetBlock(in_channels=block_in, + out_channels=block_in, + temb_channels=self.temb_ch, + dropout=dropout) + + # end + self.norm_out = Normalize(block_in) + self.conv_out = torch.nn.Conv2d(block_in, + 2*z_channels if double_z else z_channels, + kernel_size=3, + stride=1, + padding=1) + + + def forward(self, x): + #assert x.shape[2] == x.shape[3] == self.resolution, "{}, {}, {}".format(x.shape[2], x.shape[3], self.resolution) + + # timestep embedding + temb = None + + # downsampling + hs = [self.conv_in(x)] + for i_level in range(self.num_resolutions): + for i_block in range(self.num_res_blocks): + h = self.down[i_level].block[i_block](hs[-1], temb) + if len(self.down[i_level].attn) > 0: + h = self.down[i_level].attn[i_block](h) + hs.append(h) + if i_level != self.num_resolutions-1: + hs.append(self.down[i_level].downsample(hs[-1])) + + # middle + h = hs[-1] + h = self.mid.block_1(h, temb) + h = self.mid.attn_1(h) + h = self.mid.block_2(h, temb) + + # end + h = self.norm_out(h) + h = nonlinearity(h) + h = self.conv_out(h) + return h + + +class Decoder(nn.Module): + def __init__(self, *, ch, out_ch, ch_mult=(1,2,4,8), num_res_blocks, + attn_resolutions, dropout=0.0, resamp_with_conv=True, in_channels, + resolution, z_channels, give_pre_end=False, **ignorekwargs): + super().__init__() + self.ch = ch + self.temb_ch = 0 + self.num_resolutions = len(ch_mult) + self.num_res_blocks = num_res_blocks + self.resolution = resolution + self.in_channels = in_channels + self.give_pre_end = give_pre_end + + # compute in_ch_mult, block_in and curr_res at lowest res + in_ch_mult = (1,)+tuple(ch_mult) + block_in = ch*ch_mult[self.num_resolutions-1] + curr_res = resolution // 2**(self.num_resolutions-1) + self.z_shape = (1,z_channels,curr_res,curr_res) + print("Working with z of shape {} = {} dimensions.".format( + self.z_shape, np.prod(self.z_shape))) + + # z to block_in + self.conv_in = torch.nn.Conv2d(z_channels, + block_in, + kernel_size=3, + stride=1, + padding=1) + + # middle + self.mid = nn.Module() + self.mid.block_1 = ResnetBlock(in_channels=block_in, + out_channels=block_in, + temb_channels=self.temb_ch, + dropout=dropout) + self.mid.attn_1 = AttnBlock(block_in) + self.mid.block_2 = ResnetBlock(in_channels=block_in, + out_channels=block_in, + temb_channels=self.temb_ch, + dropout=dropout) + + # upsampling + self.up = nn.ModuleList() + for i_level in reversed(range(self.num_resolutions)): + block = nn.ModuleList() + attn = nn.ModuleList() + block_out = ch*ch_mult[i_level] + for i_block in range(self.num_res_blocks+1): + block.append(ResnetBlock(in_channels=block_in, + out_channels=block_out, + temb_channels=self.temb_ch, + dropout=dropout)) + block_in = block_out + if curr_res in attn_resolutions: + attn.append(AttnBlock(block_in)) + up = nn.Module() + up.block = block + up.attn = attn + if i_level != 0: + up.upsample = Upsample(block_in, resamp_with_conv) + curr_res = curr_res * 2 + self.up.insert(0, up) # prepend to get consistent order + + # end + self.norm_out = Normalize(block_in) + self.conv_out = torch.nn.Conv2d(block_in, + out_ch, + kernel_size=3, + stride=1, + padding=1) + + def forward(self, z): + #assert z.shape[1:] == self.z_shape[1:] + self.last_z_shape = z.shape + + # timestep embedding + temb = None + + # z to block_in + h = self.conv_in(z) + + # middle + h = self.mid.block_1(h, temb) + h = self.mid.attn_1(h) + h = self.mid.block_2(h, temb) + + # upsampling + for i_level in reversed(range(self.num_resolutions)): + for i_block in range(self.num_res_blocks+1): + h = self.up[i_level].block[i_block](h, temb) + if len(self.up[i_level].attn) > 0: + h = self.up[i_level].attn[i_block](h) + if i_level != 0: + h = self.up[i_level].upsample(h) + + # end + if self.give_pre_end: + return h + + h = self.norm_out(h) + h = nonlinearity(h) + h = self.conv_out(h) + return h + + +class VUNet(nn.Module): + def __init__(self, *, ch, out_ch, ch_mult=(1,2,4,8), num_res_blocks, + attn_resolutions, dropout=0.0, resamp_with_conv=True, + in_channels, c_channels, + resolution, z_channels, use_timestep=False, **ignore_kwargs): + super().__init__() + self.ch = ch + self.temb_ch = self.ch*4 + self.num_resolutions = len(ch_mult) + self.num_res_blocks = num_res_blocks + self.resolution = resolution + + self.use_timestep = use_timestep + if self.use_timestep: + # timestep embedding + self.temb = nn.Module() + self.temb.dense = nn.ModuleList([ + torch.nn.Linear(self.ch, + self.temb_ch), + torch.nn.Linear(self.temb_ch, + self.temb_ch), + ]) + + # downsampling + self.conv_in = torch.nn.Conv2d(c_channels, + self.ch, + kernel_size=3, + stride=1, + padding=1) + + curr_res = resolution + in_ch_mult = (1,)+tuple(ch_mult) + self.down = nn.ModuleList() + for i_level in range(self.num_resolutions): + block = nn.ModuleList() + attn = nn.ModuleList() + block_in = ch*in_ch_mult[i_level] + block_out = ch*ch_mult[i_level] + for i_block in range(self.num_res_blocks): + block.append(ResnetBlock(in_channels=block_in, + out_channels=block_out, + temb_channels=self.temb_ch, + dropout=dropout)) + block_in = block_out + if curr_res in attn_resolutions: + attn.append(AttnBlock(block_in)) + down = nn.Module() + down.block = block + down.attn = attn + if i_level != self.num_resolutions-1: + down.downsample = Downsample(block_in, resamp_with_conv) + curr_res = curr_res // 2 + self.down.append(down) + + self.z_in = torch.nn.Conv2d(z_channels, + block_in, + kernel_size=1, + stride=1, + padding=0) + # middle + self.mid = nn.Module() + self.mid.block_1 = ResnetBlock(in_channels=2*block_in, + out_channels=block_in, + temb_channels=self.temb_ch, + dropout=dropout) + self.mid.attn_1 = AttnBlock(block_in) + self.mid.block_2 = ResnetBlock(in_channels=block_in, + out_channels=block_in, + temb_channels=self.temb_ch, + dropout=dropout) + + # upsampling + self.up = nn.ModuleList() + for i_level in reversed(range(self.num_resolutions)): + block = nn.ModuleList() + attn = nn.ModuleList() + block_out = ch*ch_mult[i_level] + skip_in = ch*ch_mult[i_level] + for i_block in range(self.num_res_blocks+1): + if i_block == self.num_res_blocks: + skip_in = ch*in_ch_mult[i_level] + block.append(ResnetBlock(in_channels=block_in+skip_in, + out_channels=block_out, + temb_channels=self.temb_ch, + dropout=dropout)) + block_in = block_out + if curr_res in attn_resolutions: + attn.append(AttnBlock(block_in)) + up = nn.Module() + up.block = block + up.attn = attn + if i_level != 0: + up.upsample = Upsample(block_in, resamp_with_conv) + curr_res = curr_res * 2 + self.up.insert(0, up) # prepend to get consistent order + + # end + self.norm_out = Normalize(block_in) + self.conv_out = torch.nn.Conv2d(block_in, + out_ch, + kernel_size=3, + stride=1, + padding=1) + + + def forward(self, x, z): + #assert x.shape[2] == x.shape[3] == self.resolution + + if self.use_timestep: + # timestep embedding + assert t is not None + temb = get_timestep_embedding(t, self.ch) + temb = self.temb.dense[0](temb) + temb = nonlinearity(temb) + temb = self.temb.dense[1](temb) + else: + temb = None + + # downsampling + hs = [self.conv_in(x)] + for i_level in range(self.num_resolutions): + for i_block in range(self.num_res_blocks): + h = self.down[i_level].block[i_block](hs[-1], temb) + if len(self.down[i_level].attn) > 0: + h = self.down[i_level].attn[i_block](h) + hs.append(h) + if i_level != self.num_resolutions-1: + hs.append(self.down[i_level].downsample(hs[-1])) + + # middle + h = hs[-1] + z = self.z_in(z) + h = torch.cat((h,z),dim=1) + h = self.mid.block_1(h, temb) + h = self.mid.attn_1(h) + h = self.mid.block_2(h, temb) + + # upsampling + for i_level in reversed(range(self.num_resolutions)): + for i_block in range(self.num_res_blocks+1): + h = self.up[i_level].block[i_block]( + torch.cat([h, hs.pop()], dim=1), temb) + if len(self.up[i_level].attn) > 0: + h = self.up[i_level].attn[i_block](h) + if i_level != 0: + h = self.up[i_level].upsample(h) + + # end + h = self.norm_out(h) + h = nonlinearity(h) + h = self.conv_out(h) + return h + + +class SimpleDecoder(nn.Module): + def __init__(self, in_channels, out_channels, *args, **kwargs): + super().__init__() + self.model = nn.ModuleList([nn.Conv2d(in_channels, in_channels, 1), + ResnetBlock(in_channels=in_channels, + out_channels=2 * in_channels, + temb_channels=0, dropout=0.0), + ResnetBlock(in_channels=2 * in_channels, + out_channels=4 * in_channels, + temb_channels=0, dropout=0.0), + ResnetBlock(in_channels=4 * in_channels, + out_channels=2 * in_channels, + temb_channels=0, dropout=0.0), + nn.Conv2d(2*in_channels, in_channels, 1), + Upsample(in_channels, with_conv=True)]) + # end + self.norm_out = Normalize(in_channels) + self.conv_out = torch.nn.Conv2d(in_channels, + out_channels, + kernel_size=3, + stride=1, + padding=1) + + def forward(self, x): + for i, layer in enumerate(self.model): + if i in [1,2,3]: + x = layer(x, None) + else: + x = layer(x) + + h = self.norm_out(x) + h = nonlinearity(h) + x = self.conv_out(h) + return x + + +class UpsampleDecoder(nn.Module): + def __init__(self, in_channels, out_channels, ch, num_res_blocks, resolution, + ch_mult=(2,2), dropout=0.0): + super().__init__() + # upsampling + self.temb_ch = 0 + self.num_resolutions = len(ch_mult) + self.num_res_blocks = num_res_blocks + block_in = in_channels + curr_res = resolution // 2 ** (self.num_resolutions - 1) + self.res_blocks = nn.ModuleList() + self.upsample_blocks = nn.ModuleList() + for i_level in range(self.num_resolutions): + res_block = [] + block_out = ch * ch_mult[i_level] + for i_block in range(self.num_res_blocks + 1): + res_block.append(ResnetBlock(in_channels=block_in, + out_channels=block_out, + temb_channels=self.temb_ch, + dropout=dropout)) + block_in = block_out + self.res_blocks.append(nn.ModuleList(res_block)) + if i_level != self.num_resolutions - 1: + self.upsample_blocks.append(Upsample(block_in, True)) + curr_res = curr_res * 2 + + # end + self.norm_out = Normalize(block_in) + self.conv_out = torch.nn.Conv2d(block_in, + out_channels, + kernel_size=3, + stride=1, + padding=1) + + def forward(self, x): + # upsampling + h = x + for k, i_level in enumerate(range(self.num_resolutions)): + for i_block in range(self.num_res_blocks + 1): + h = self.res_blocks[i_level][i_block](h, None) + if i_level != self.num_resolutions - 1: + h = self.upsample_blocks[k](h) + h = self.norm_out(h) + h = nonlinearity(h) + h = self.conv_out(h) + return h + diff --git a/taming/modules/discriminator/model.py b/taming/modules/discriminator/model.py new file mode 100644 index 0000000..2aaa311 --- /dev/null +++ b/taming/modules/discriminator/model.py @@ -0,0 +1,67 @@ +import functools +import torch.nn as nn + + +from taming.modules.util import ActNorm + + +def weights_init(m): + classname = m.__class__.__name__ + if classname.find('Conv') != -1: + nn.init.normal_(m.weight.data, 0.0, 0.02) + elif classname.find('BatchNorm') != -1: + nn.init.normal_(m.weight.data, 1.0, 0.02) + nn.init.constant_(m.bias.data, 0) + + +class NLayerDiscriminator(nn.Module): + """Defines a PatchGAN discriminator as in Pix2Pix + --> see https://github.com/junyanz/pytorch-CycleGAN-and-pix2pix/blob/master/models/networks.py + """ + def __init__(self, input_nc=3, ndf=64, n_layers=3, use_actnorm=False): + """Construct a PatchGAN discriminator + Parameters: + input_nc (int) -- the number of channels in input images + ndf (int) -- the number of filters in the last conv layer + n_layers (int) -- the number of conv layers in the discriminator + norm_layer -- normalization layer + """ + super(NLayerDiscriminator, self).__init__() + if not use_actnorm: + norm_layer = nn.BatchNorm2d + else: + norm_layer = ActNorm + if type(norm_layer) == functools.partial: # no need to use bias as BatchNorm2d has affine parameters + use_bias = norm_layer.func != nn.BatchNorm2d + else: + use_bias = norm_layer != nn.BatchNorm2d + + kw = 4 + padw = 1 + sequence = [nn.Conv2d(input_nc, ndf, kernel_size=kw, stride=2, padding=padw), nn.LeakyReLU(0.2, True)] + nf_mult = 1 + nf_mult_prev = 1 + for n in range(1, n_layers): # gradually increase the number of filters + nf_mult_prev = nf_mult + nf_mult = min(2 ** n, 8) + sequence += [ + nn.Conv2d(ndf * nf_mult_prev, ndf * nf_mult, kernel_size=kw, stride=2, padding=padw, bias=use_bias), + norm_layer(ndf * nf_mult), + nn.LeakyReLU(0.2, True) + ] + + nf_mult_prev = nf_mult + nf_mult = min(2 ** n_layers, 8) + sequence += [ + nn.Conv2d(ndf * nf_mult_prev, ndf * nf_mult, kernel_size=kw, stride=1, padding=padw, bias=use_bias), + norm_layer(ndf * nf_mult), + nn.LeakyReLU(0.2, True) + ] + + sequence += [ + nn.Conv2d(ndf * nf_mult, 1, kernel_size=kw, stride=1, padding=padw)] # output 1 channel prediction map + self.main = nn.Sequential(*sequence) + + def forward(self, input): + """Standard forward.""" + return self.main(input) diff --git a/taming/modules/losses/__init__.py b/taming/modules/losses/__init__.py new file mode 100644 index 0000000..d09caf9 --- /dev/null +++ b/taming/modules/losses/__init__.py @@ -0,0 +1,2 @@ +from taming.modules.losses.vqperceptual import DummyLoss + diff --git a/taming/modules/losses/lpips.py b/taming/modules/losses/lpips.py new file mode 100644 index 0000000..a728044 --- /dev/null +++ b/taming/modules/losses/lpips.py @@ -0,0 +1,123 @@ +"""Stripped version of https://github.com/richzhang/PerceptualSimilarity/tree/master/models""" + +import torch +import torch.nn as nn +from torchvision import models +from collections import namedtuple + +from taming.util import get_ckpt_path + + +class LPIPS(nn.Module): + # Learned perceptual metric + def __init__(self, use_dropout=True): + super().__init__() + self.scaling_layer = ScalingLayer() + self.chns = [64, 128, 256, 512, 512] # vg16 features + self.net = vgg16(pretrained=True, requires_grad=False) + self.lin0 = NetLinLayer(self.chns[0], use_dropout=use_dropout) + self.lin1 = NetLinLayer(self.chns[1], use_dropout=use_dropout) + self.lin2 = NetLinLayer(self.chns[2], use_dropout=use_dropout) + self.lin3 = NetLinLayer(self.chns[3], use_dropout=use_dropout) + self.lin4 = NetLinLayer(self.chns[4], use_dropout=use_dropout) + self.load_from_pretrained() + for param in self.parameters(): + param.requires_grad = False + + def load_from_pretrained(self, name="vgg_lpips"): + ckpt = get_ckpt_path(name, "taming/modules/autoencoder/lpips") + self.load_state_dict(torch.load(ckpt, map_location=torch.device("cpu")), strict=False) + print("loaded pretrained LPIPS loss from {}".format(ckpt)) + + @classmethod + def from_pretrained(cls, name="vgg_lpips"): + if name != "vgg_lpips": + raise NotImplementedError + model = cls() + ckpt = get_ckpt_path(name) + model.load_state_dict(torch.load(ckpt, map_location=torch.device("cpu")), strict=False) + return model + + def forward(self, input, target): + in0_input, in1_input = (self.scaling_layer(input), self.scaling_layer(target)) + outs0, outs1 = self.net(in0_input), self.net(in1_input) + feats0, feats1, diffs = {}, {}, {} + lins = [self.lin0, self.lin1, self.lin2, self.lin3, self.lin4] + for kk in range(len(self.chns)): + feats0[kk], feats1[kk] = normalize_tensor(outs0[kk]), normalize_tensor(outs1[kk]) + diffs[kk] = (feats0[kk] - feats1[kk]) ** 2 + + res = [spatial_average(lins[kk].model(diffs[kk]), keepdim=True) for kk in range(len(self.chns))] + val = res[0] + for l in range(1, len(self.chns)): + val += res[l] + return val + + +class ScalingLayer(nn.Module): + def __init__(self): + super(ScalingLayer, self).__init__() + self.register_buffer('shift', torch.Tensor([-.030, -.088, -.188])[None, :, None, None]) + self.register_buffer('scale', torch.Tensor([.458, .448, .450])[None, :, None, None]) + + def forward(self, inp): + return (inp - self.shift) / self.scale + + +class NetLinLayer(nn.Module): + """ A single linear layer which does a 1x1 conv """ + def __init__(self, chn_in, chn_out=1, use_dropout=False): + super(NetLinLayer, self).__init__() + layers = [nn.Dropout(), ] if (use_dropout) else [] + layers += [nn.Conv2d(chn_in, chn_out, 1, stride=1, padding=0, bias=False), ] + self.model = nn.Sequential(*layers) + + +class vgg16(torch.nn.Module): + def __init__(self, requires_grad=False, pretrained=True): + super(vgg16, self).__init__() + vgg_pretrained_features = models.vgg16(pretrained=pretrained).features + self.slice1 = torch.nn.Sequential() + self.slice2 = torch.nn.Sequential() + self.slice3 = torch.nn.Sequential() + self.slice4 = torch.nn.Sequential() + self.slice5 = torch.nn.Sequential() + self.N_slices = 5 + for x in range(4): + self.slice1.add_module(str(x), vgg_pretrained_features[x]) + for x in range(4, 9): + self.slice2.add_module(str(x), vgg_pretrained_features[x]) + for x in range(9, 16): + self.slice3.add_module(str(x), vgg_pretrained_features[x]) + for x in range(16, 23): + self.slice4.add_module(str(x), vgg_pretrained_features[x]) + for x in range(23, 30): + self.slice5.add_module(str(x), vgg_pretrained_features[x]) + if not requires_grad: + for param in self.parameters(): + param.requires_grad = False + + def forward(self, X): + h = self.slice1(X) + h_relu1_2 = h + h = self.slice2(h) + h_relu2_2 = h + h = self.slice3(h) + h_relu3_3 = h + h = self.slice4(h) + h_relu4_3 = h + h = self.slice5(h) + h_relu5_3 = h + vgg_outputs = namedtuple("VggOutputs", ['relu1_2', 'relu2_2', 'relu3_3', 'relu4_3', 'relu5_3']) + out = vgg_outputs(h_relu1_2, h_relu2_2, h_relu3_3, h_relu4_3, h_relu5_3) + return out + + +def normalize_tensor(x,eps=1e-10): + norm_factor = torch.sqrt(torch.sum(x**2,dim=1,keepdim=True)) + return x/(norm_factor+eps) + + +def spatial_average(x, keepdim=True): + return x.mean([2,3],keepdim=keepdim) + diff --git a/taming/modules/losses/segmentation.py b/taming/modules/losses/segmentation.py new file mode 100644 index 0000000..4ba77de --- /dev/null +++ b/taming/modules/losses/segmentation.py @@ -0,0 +1,22 @@ +import torch.nn as nn +import torch.nn.functional as F + + +class BCELoss(nn.Module): + def forward(self, prediction, target): + loss = F.binary_cross_entropy_with_logits(prediction,target) + return loss, {} + + +class BCELossWithQuant(nn.Module): + def __init__(self, codebook_weight=1.): + super().__init__() + self.codebook_weight = codebook_weight + + def forward(self, qloss, target, prediction, split): + bce_loss = F.binary_cross_entropy_with_logits(prediction,target) + loss = bce_loss + self.codebook_weight*qloss + return loss, {"{}/total_loss".format(split): loss.clone().detach().mean(), + "{}/bce_loss".format(split): bce_loss.detach().mean(), + "{}/quant_loss".format(split): qloss.detach().mean() + } diff --git a/taming/modules/losses/vqperceptual.py b/taming/modules/losses/vqperceptual.py new file mode 100644 index 0000000..c2febd4 --- /dev/null +++ b/taming/modules/losses/vqperceptual.py @@ -0,0 +1,136 @@ +import torch +import torch.nn as nn +import torch.nn.functional as F + +from taming.modules.losses.lpips import LPIPS +from taming.modules.discriminator.model import NLayerDiscriminator, weights_init + + +class DummyLoss(nn.Module): + def __init__(self): + super().__init__() + + +def adopt_weight(weight, global_step, threshold=0, value=0.): + if global_step < threshold: + weight = value + return weight + + +def hinge_d_loss(logits_real, logits_fake): + loss_real = torch.mean(F.relu(1. - logits_real)) + loss_fake = torch.mean(F.relu(1. + logits_fake)) + d_loss = 0.5 * (loss_real + loss_fake) + return d_loss + + +def vanilla_d_loss(logits_real, logits_fake): + d_loss = 0.5 * ( + torch.mean(torch.nn.functional.softplus(-logits_real)) + + torch.mean(torch.nn.functional.softplus(logits_fake))) + return d_loss + + +class VQLPIPSWithDiscriminator(nn.Module): + def __init__(self, disc_start, codebook_weight=1.0, pixelloss_weight=1.0, + disc_num_layers=3, disc_in_channels=3, disc_factor=1.0, disc_weight=1.0, + perceptual_weight=1.0, use_actnorm=False, disc_conditional=False, + disc_ndf=64, disc_loss="hinge"): + super().__init__() + assert disc_loss in ["hinge", "vanilla"] + self.codebook_weight = codebook_weight + self.pixel_weight = pixelloss_weight + self.perceptual_loss = LPIPS().eval() + self.perceptual_weight = perceptual_weight + + self.discriminator = NLayerDiscriminator(input_nc=disc_in_channels, + n_layers=disc_num_layers, + use_actnorm=use_actnorm, + ndf=disc_ndf + ).apply(weights_init) + self.discriminator_iter_start = disc_start + if disc_loss == "hinge": + self.disc_loss = hinge_d_loss + elif disc_loss == "vanilla": + self.disc_loss = vanilla_d_loss + else: + raise ValueError(f"Unknown GAN loss '{disc_loss}'.") + print(f"VQLPIPSWithDiscriminator running with {disc_loss} loss.") + self.disc_factor = disc_factor + self.discriminator_weight = disc_weight + self.disc_conditional = disc_conditional + + def calculate_adaptive_weight(self, nll_loss, g_loss, last_layer=None): + if last_layer is not None: + nll_grads = torch.autograd.grad(nll_loss, last_layer, retain_graph=True)[0] + g_grads = torch.autograd.grad(g_loss, last_layer, retain_graph=True)[0] + else: + nll_grads = torch.autograd.grad(nll_loss, self.last_layer[0], retain_graph=True)[0] + g_grads = torch.autograd.grad(g_loss, self.last_layer[0], retain_graph=True)[0] + + d_weight = torch.norm(nll_grads) / (torch.norm(g_grads) + 1e-4) + d_weight = torch.clamp(d_weight, 0.0, 1e4).detach() + d_weight = d_weight * self.discriminator_weight + return d_weight + + def forward(self, codebook_loss, inputs, reconstructions, optimizer_idx, + global_step, last_layer=None, cond=None, split="train"): + rec_loss = torch.abs(inputs.contiguous() - reconstructions.contiguous()) + if self.perceptual_weight > 0: + p_loss = self.perceptual_loss(inputs.contiguous(), reconstructions.contiguous()) + rec_loss = rec_loss + self.perceptual_weight * p_loss + else: + p_loss = torch.tensor([0.0]) + + nll_loss = rec_loss + #nll_loss = torch.sum(nll_loss) / nll_loss.shape[0] + nll_loss = torch.mean(nll_loss) + + # now the GAN part + if optimizer_idx == 0: + # generator update + if cond is None: + assert not self.disc_conditional + logits_fake = self.discriminator(reconstructions.contiguous()) + else: + assert self.disc_conditional + logits_fake = self.discriminator(torch.cat((reconstructions.contiguous(), cond), dim=1)) + g_loss = -torch.mean(logits_fake) + + try: + d_weight = self.calculate_adaptive_weight(nll_loss, g_loss, last_layer=last_layer) + except RuntimeError: + assert not self.training + d_weight = torch.tensor(0.0) + + disc_factor = adopt_weight(self.disc_factor, global_step, threshold=self.discriminator_iter_start) + loss = nll_loss + d_weight * disc_factor * g_loss + self.codebook_weight * codebook_loss.mean() + + log = {"{}/total_loss".format(split): loss.clone().detach().mean(), + "{}/quant_loss".format(split): codebook_loss.detach().mean(), + "{}/nll_loss".format(split): nll_loss.detach().mean(), + "{}/rec_loss".format(split): rec_loss.detach().mean(), + "{}/p_loss".format(split): p_loss.detach().mean(), + "{}/d_weight".format(split): d_weight.detach(), + "{}/disc_factor".format(split): torch.tensor(disc_factor), + "{}/g_loss".format(split): g_loss.detach().mean(), + } + return loss, log + + if optimizer_idx == 1: + # second pass for discriminator update + if cond is None: + logits_real = self.discriminator(inputs.contiguous().detach()) + logits_fake = self.discriminator(reconstructions.contiguous().detach()) + else: + logits_real = self.discriminator(torch.cat((inputs.contiguous().detach(), cond), dim=1)) + logits_fake = self.discriminator(torch.cat((reconstructions.contiguous().detach(), cond), dim=1)) + + disc_factor = adopt_weight(self.disc_factor, global_step, threshold=self.discriminator_iter_start) + d_loss = disc_factor * self.disc_loss(logits_real, logits_fake) + + log = {"{}/disc_loss".format(split): d_loss.clone().detach().mean(), + "{}/logits_real".format(split): logits_real.detach().mean(), + "{}/logits_fake".format(split): logits_fake.detach().mean() + } + return d_loss, log diff --git a/taming/modules/misc/coord.py b/taming/modules/misc/coord.py new file mode 100644 index 0000000..ee69b0c --- /dev/null +++ b/taming/modules/misc/coord.py @@ -0,0 +1,31 @@ +import torch + +class CoordStage(object): + def __init__(self, n_embed, down_factor): + self.n_embed = n_embed + self.down_factor = down_factor + + def eval(self): + return self + + def encode(self, c): + """fake vqmodel interface""" + assert 0.0 <= c.min() and c.max() <= 1.0 + b,ch,h,w = c.shape + assert ch == 1 + + c = torch.nn.functional.interpolate(c, scale_factor=1/self.down_factor, + mode="area") + c = c.clamp(0.0, 1.0) + c = self.n_embed*c + c_quant = c.round() + c_ind = c_quant.to(dtype=torch.long) + + info = None, None, c_ind + return c_quant, None, info + + def decode(self, c): + c = c/self.n_embed + c = torch.nn.functional.interpolate(c, scale_factor=self.down_factor, + mode="nearest") + return c diff --git a/taming/modules/transformer/mingpt.py b/taming/modules/transformer/mingpt.py new file mode 100644 index 0000000..d14b7b6 --- /dev/null +++ b/taming/modules/transformer/mingpt.py @@ -0,0 +1,415 @@ +""" +taken from: https://github.com/karpathy/minGPT/ +GPT model: +- the initial stem consists of a combination of token encoding and a positional encoding +- the meat of it is a uniform sequence of Transformer blocks + - each Transformer is a sequential combination of a 1-hidden-layer MLP block and a self-attention block + - all blocks feed into a central residual pathway similar to resnets +- the final decoder is a linear projection into a vanilla Softmax classifier +""" + +import math +import logging + +import torch +import torch.nn as nn +from torch.nn import functional as F +from transformers import top_k_top_p_filtering + +logger = logging.getLogger(__name__) + + +class GPTConfig: + """ base GPT config, params common to all GPT versions """ + embd_pdrop = 0.1 + resid_pdrop = 0.1 + attn_pdrop = 0.1 + + def __init__(self, vocab_size, block_size, **kwargs): + self.vocab_size = vocab_size + self.block_size = block_size + for k,v in kwargs.items(): + setattr(self, k, v) + + +class GPT1Config(GPTConfig): + """ GPT-1 like network roughly 125M params """ + n_layer = 12 + n_head = 12 + n_embd = 768 + + +class CausalSelfAttention(nn.Module): + """ + A vanilla multi-head masked self-attention layer with a projection at the end. + It is possible to use torch.nn.MultiheadAttention here but I am including an + explicit implementation here to show that there is nothing too scary here. + """ + + def __init__(self, config): + super().__init__() + assert config.n_embd % config.n_head == 0 + # key, query, value projections for all heads + self.key = nn.Linear(config.n_embd, config.n_embd) + self.query = nn.Linear(config.n_embd, config.n_embd) + self.value = nn.Linear(config.n_embd, config.n_embd) + # regularization + self.attn_drop = nn.Dropout(config.attn_pdrop) + self.resid_drop = nn.Dropout(config.resid_pdrop) + # output projection + self.proj = nn.Linear(config.n_embd, config.n_embd) + # causal mask to ensure that attention is only applied to the left in the input sequence + mask = torch.tril(torch.ones(config.block_size, + config.block_size)) + if hasattr(config, "n_unmasked"): + mask[:config.n_unmasked, :config.n_unmasked] = 1 + self.register_buffer("mask", mask.view(1, 1, config.block_size, config.block_size)) + self.n_head = config.n_head + + def forward(self, x, layer_past=None): + B, T, C = x.size() + + # calculate query, key, values for all heads in batch and move head forward to be the batch dim + k = self.key(x).view(B, T, self.n_head, C // self.n_head).transpose(1, 2) # (B, nh, T, hs) + q = self.query(x).view(B, T, self.n_head, C // self.n_head).transpose(1, 2) # (B, nh, T, hs) + v = self.value(x).view(B, T, self.n_head, C // self.n_head).transpose(1, 2) # (B, nh, T, hs) + + present = torch.stack((k, v)) + if layer_past is not None: + past_key, past_value = layer_past + k = torch.cat((past_key, k), dim=-2) + v = torch.cat((past_value, v), dim=-2) + + # causal self-attention; Self-attend: (B, nh, T, hs) x (B, nh, hs, T) -> (B, nh, T, T) + att = (q @ k.transpose(-2, -1)) * (1.0 / math.sqrt(k.size(-1))) + if layer_past is None: + att = att.masked_fill(self.mask[:,:,:T,:T] == 0, float('-inf')) + + att = F.softmax(att, dim=-1) + att = self.attn_drop(att) + y = att @ v # (B, nh, T, T) x (B, nh, T, hs) -> (B, nh, T, hs) + y = y.transpose(1, 2).contiguous().view(B, T, C) # re-assemble all head outputs side by side + + # output projection + y = self.resid_drop(self.proj(y)) + return y, present # TODO: check that this does not break anything + + +class Block(nn.Module): + """ an unassuming Transformer block """ + def __init__(self, config): + super().__init__() + self.ln1 = nn.LayerNorm(config.n_embd) + self.ln2 = nn.LayerNorm(config.n_embd) + self.attn = CausalSelfAttention(config) + self.mlp = nn.Sequential( + nn.Linear(config.n_embd, 4 * config.n_embd), + nn.GELU(), # nice + nn.Linear(4 * config.n_embd, config.n_embd), + nn.Dropout(config.resid_pdrop), + ) + + def forward(self, x, layer_past=None, return_present=False): + # TODO: check that training still works + if return_present: assert not self.training + # layer past: tuple of length two with B, nh, T, hs + attn, present = self.attn(self.ln1(x), layer_past=layer_past) + + x = x + attn + x = x + self.mlp(self.ln2(x)) + if layer_past is not None or return_present: + return x, present + return x + + +class GPT(nn.Module): + """ the full GPT language model, with a context size of block_size """ + def __init__(self, vocab_size, block_size, n_layer=12, n_head=8, n_embd=256, + embd_pdrop=0., resid_pdrop=0., attn_pdrop=0., n_unmasked=0): + super().__init__() + config = GPTConfig(vocab_size=vocab_size, block_size=block_size, + embd_pdrop=embd_pdrop, resid_pdrop=resid_pdrop, attn_pdrop=attn_pdrop, + n_layer=n_layer, n_head=n_head, n_embd=n_embd, + n_unmasked=n_unmasked) + # input embedding stem + self.tok_emb = nn.Embedding(config.vocab_size, config.n_embd) + self.pos_emb = nn.Parameter(torch.zeros(1, config.block_size, config.n_embd)) + self.drop = nn.Dropout(config.embd_pdrop) + # transformer + self.blocks = nn.Sequential(*[Block(config) for _ in range(config.n_layer)]) + # decoder head + self.ln_f = nn.LayerNorm(config.n_embd) + self.head = nn.Linear(config.n_embd, config.vocab_size, bias=False) + self.block_size = config.block_size + self.apply(self._init_weights) + self.config = config + logger.info("number of parameters: %e", sum(p.numel() for p in self.parameters())) + + def get_block_size(self): + return self.block_size + + def _init_weights(self, module): + if isinstance(module, (nn.Linear, nn.Embedding)): + module.weight.data.normal_(mean=0.0, std=0.02) + if isinstance(module, nn.Linear) and module.bias is not None: + module.bias.data.zero_() + elif isinstance(module, nn.LayerNorm): + module.bias.data.zero_() + module.weight.data.fill_(1.0) + + def forward(self, idx, embeddings=None, targets=None): + # forward the GPT model + token_embeddings = self.tok_emb(idx) # each index maps to a (learnable) vector + + if embeddings is not None: # prepend explicit embeddings + token_embeddings = torch.cat((embeddings, token_embeddings), dim=1) + + t = token_embeddings.shape[1] + assert t <= self.block_size, "Cannot forward, model block size is exhausted." + position_embeddings = self.pos_emb[:, :t, :] # each position maps to a (learnable) vector + x = self.drop(token_embeddings + position_embeddings) + x = self.blocks(x) + x = self.ln_f(x) + logits = self.head(x) + + # if we are given some desired targets also calculate the loss + loss = None + if targets is not None: + loss = F.cross_entropy(logits.view(-1, logits.size(-1)), targets.view(-1)) + + return logits, loss + + def forward_with_past(self, idx, embeddings=None, targets=None, past=None, past_length=None): + # inference only + assert not self.training + token_embeddings = self.tok_emb(idx) # each index maps to a (learnable) vector + if embeddings is not None: # prepend explicit embeddings + token_embeddings = torch.cat((embeddings, token_embeddings), dim=1) + + if past is not None: + assert past_length is not None + past = torch.cat(past, dim=-2) # n_layer, 2, b, nh, len_past, dim_head + past_shape = list(past.shape) + expected_shape = [self.config.n_layer, 2, idx.shape[0], self.config.n_head, past_length, self.config.n_embd//self.config.n_head] + assert past_shape == expected_shape, f"{past_shape} =/= {expected_shape}" + position_embeddings = self.pos_emb[:, past_length, :] # each position maps to a (learnable) vector + else: + position_embeddings = self.pos_emb[:, :token_embeddings.shape[1], :] + + x = self.drop(token_embeddings + position_embeddings) + presents = [] # accumulate over layers + for i, block in enumerate(self.blocks): + x, present = block(x, layer_past=past[i, ...] if past is not None else None, return_present=True) + presents.append(present) + + x = self.ln_f(x) + logits = self.head(x) + # if we are given some desired targets also calculate the loss + loss = None + if targets is not None: + loss = F.cross_entropy(logits.view(-1, logits.size(-1)), targets.view(-1)) + + return logits, loss, torch.stack(presents) # _, _, n_layer, 2, b, nh, 1, dim_head + + +class DummyGPT(nn.Module): + # for debugging + def __init__(self, add_value=1): + super().__init__() + self.add_value = add_value + + def forward(self, idx): + return idx + self.add_value, None + + +class CodeGPT(nn.Module): + """Takes in semi-embeddings""" + def __init__(self, vocab_size, block_size, in_channels, n_layer=12, n_head=8, n_embd=256, + embd_pdrop=0., resid_pdrop=0., attn_pdrop=0., n_unmasked=0): + super().__init__() + config = GPTConfig(vocab_size=vocab_size, block_size=block_size, + embd_pdrop=embd_pdrop, resid_pdrop=resid_pdrop, attn_pdrop=attn_pdrop, + n_layer=n_layer, n_head=n_head, n_embd=n_embd, + n_unmasked=n_unmasked) + # input embedding stem + self.tok_emb = nn.Linear(in_channels, config.n_embd) + self.pos_emb = nn.Parameter(torch.zeros(1, config.block_size, config.n_embd)) + self.drop = nn.Dropout(config.embd_pdrop) + # transformer + self.blocks = nn.Sequential(*[Block(config) for _ in range(config.n_layer)]) + # decoder head + self.ln_f = nn.LayerNorm(config.n_embd) + self.head = nn.Linear(config.n_embd, config.vocab_size, bias=False) + self.block_size = config.block_size + self.apply(self._init_weights) + self.config = config + logger.info("number of parameters: %e", sum(p.numel() for p in self.parameters())) + + def get_block_size(self): + return self.block_size + + def _init_weights(self, module): + if isinstance(module, (nn.Linear, nn.Embedding)): + module.weight.data.normal_(mean=0.0, std=0.02) + if isinstance(module, nn.Linear) and module.bias is not None: + module.bias.data.zero_() + elif isinstance(module, nn.LayerNorm): + module.bias.data.zero_() + module.weight.data.fill_(1.0) + + def forward(self, idx, embeddings=None, targets=None): + # forward the GPT model + token_embeddings = self.tok_emb(idx) # each index maps to a (learnable) vector + + if embeddings is not None: # prepend explicit embeddings + token_embeddings = torch.cat((embeddings, token_embeddings), dim=1) + + t = token_embeddings.shape[1] + assert t <= self.block_size, "Cannot forward, model block size is exhausted." + position_embeddings = self.pos_emb[:, :t, :] # each position maps to a (learnable) vector + x = self.drop(token_embeddings + position_embeddings) + x = self.blocks(x) + x = self.taming_cinln_f(x) + logits = self.head(x) + + # if we are given some desired targets also calculate the loss + loss = None + if targets is not None: + loss = F.cross_entropy(logits.view(-1, logits.size(-1)), targets.view(-1)) + + return logits, loss + + + +#### sampling utils + +def top_k_logits(logits, k): + v, ix = torch.topk(logits, k) + out = logits.clone() + out[out < v[:, [-1]]] = -float('Inf') + return out + +@torch.no_grad() +def sample(model, x, steps, temperature=1.0, sample=False, top_k=None): + """ + take a conditioning sequence of indices in x (of shape (b,t)) and predict the next token in + the sequence, feeding the predictions back into the model each time. Clearly the sampling + has quadratic complexity unlike an RNN that is only linear, and has a finite context window + of block_size, unlike an RNN that has an infinite context window. + """ + block_size = model.get_block_size() + model.eval() + for k in range(steps): + x_cond = x if x.size(1) <= block_size else x[:, -block_size:] # crop context if needed + logits, _ = model(x_cond) + # pluck the logits at the final step and scale by temperature + logits = logits[:, -1, :] / temperature + # optionally crop probabilities to only the top k options + if top_k is not None: + logits = top_k_logits(logits, top_k) + # apply softmax to convert to probabilities + probs = F.softmax(logits, dim=-1) + # sample from the distribution or take the most likely + if sample: + ix = torch.multinomial(probs, num_samples=1) + else: + _, ix = torch.topk(probs, k=1, dim=-1) + # append to the sequence and continue + x = torch.cat((x, ix), dim=1) + + return x + + +@torch.no_grad() +def sample_with_past(x, model, steps, temperature=1., sample_logits=True, + top_k=None, top_p=None, callback=None): + # x is conditioning + sample = x + cond_len = x.shape[1] + past = None + for n in range(steps): + if callback is not None: + callback(n) + logits, _, present = model.forward_with_past(x, past=past, past_length=(n+cond_len-1)) + if past is None: + past = [present] + else: + past.append(present) + logits = logits[:, -1, :] / temperature + if top_k is not None: + logits = top_k_top_p_filtering(logits, top_k=top_k, top_p=top_p) + + probs = F.softmax(logits, dim=-1) + if not sample_logits: + _, x = torch.topk(probs, k=1, dim=-1) + else: + x = torch.multinomial(probs, num_samples=1) + # append to the sequence and continue + sample = torch.cat((sample, x), dim=1) + del past + sample = sample[:, cond_len:] # cut conditioning off + return sample + + +#### clustering utils + +class KMeans(nn.Module): + def __init__(self, ncluster=512, nc=3, niter=10): + super().__init__() + self.ncluster = ncluster + self.nc = nc + self.niter = niter + self.shape = (3,32,32) + self.register_buffer("C", torch.zeros(self.ncluster,nc)) + self.register_buffer('initialized', torch.tensor(0, dtype=torch.uint8)) + + def is_initialized(self): + return self.initialized.item() == 1 + + @torch.no_grad() + def initialize(self, x): + N, D = x.shape + assert D == self.nc, D + c = x[torch.randperm(N)[:self.ncluster]] # init clusters at random + for i in range(self.niter): + # assign all pixels to the closest codebook element + a = ((x[:, None, :] - c[None, :, :])**2).sum(-1).argmin(1) + # move each codebook element to be the mean of the pixels that assigned to it + c = torch.stack([x[a==k].mean(0) for k in range(self.ncluster)]) + # re-assign any poorly positioned codebook elements + nanix = torch.any(torch.isnan(c), dim=1) + ndead = nanix.sum().item() + print('done step %d/%d, re-initialized %d dead clusters' % (i+1, self.niter, ndead)) + c[nanix] = x[torch.randperm(N)[:ndead]] # re-init dead clusters + + self.C.copy_(c) + self.initialized.fill_(1) + + + def forward(self, x, reverse=False, shape=None): + if not reverse: + # flatten + bs,c,h,w = x.shape + assert c == self.nc + x = x.reshape(bs,c,h*w,1) + C = self.C.permute(1,0) + C = C.reshape(1,c,1,self.ncluster) + a = ((x-C)**2).sum(1).argmin(-1) # bs, h*w indices + return a + else: + # flatten + bs, HW = x.shape + """ + c = self.C.reshape( 1, self.nc, 1, self.ncluster) + c = c[bs*[0],:,:,:] + c = c[:,:,HW*[0],:] + x = x.reshape(bs, 1, HW, 1) + x = x[:,3*[0],:,:] + x = torch.gather(c, dim=3, index=x) + """ + x = self.C[x] + x = x.permute(0,2,1) + shape = shape if shape is not None else self.shape + x = x.reshape(bs, *shape) + + return x diff --git a/taming/modules/transformer/permuter.py b/taming/modules/transformer/permuter.py new file mode 100644 index 0000000..0d43bb1 --- /dev/null +++ b/taming/modules/transformer/permuter.py @@ -0,0 +1,248 @@ +import torch +import torch.nn as nn +import numpy as np + + +class AbstractPermuter(nn.Module): + def __init__(self, *args, **kwargs): + super().__init__() + def forward(self, x, reverse=False): + raise NotImplementedError + + +class Identity(AbstractPermuter): + def __init__(self): + super().__init__() + + def forward(self, x, reverse=False): + return x + + +class Subsample(AbstractPermuter): + def __init__(self, H, W): + super().__init__() + C = 1 + indices = np.arange(H*W).reshape(C,H,W) + while min(H, W) > 1: + indices = indices.reshape(C,H//2,2,W//2,2) + indices = indices.transpose(0,2,4,1,3) + indices = indices.reshape(C*4,H//2, W//2) + H = H//2 + W = W//2 + C = C*4 + assert H == W == 1 + idx = torch.tensor(indices.ravel()) + self.register_buffer('forward_shuffle_idx', + nn.Parameter(idx, requires_grad=False)) + self.register_buffer('backward_shuffle_idx', + nn.Parameter(torch.argsort(idx), requires_grad=False)) + + def forward(self, x, reverse=False): + if not reverse: + return x[:, self.forward_shuffle_idx] + else: + return x[:, self.backward_shuffle_idx] + + +def mortonify(i, j): + """(i,j) index to linear morton code""" + i = np.uint64(i) + j = np.uint64(j) + + z = np.uint(0) + + for pos in range(32): + z = (z | + ((j & (np.uint64(1) << np.uint64(pos))) << np.uint64(pos)) | + ((i & (np.uint64(1) << np.uint64(pos))) << np.uint64(pos+1)) + ) + return z + + +class ZCurve(AbstractPermuter): + def __init__(self, H, W): + super().__init__() + reverseidx = [np.int64(mortonify(i,j)) for i in range(H) for j in range(W)] + idx = np.argsort(reverseidx) + idx = torch.tensor(idx) + reverseidx = torch.tensor(reverseidx) + self.register_buffer('forward_shuffle_idx', + idx) + self.register_buffer('backward_shuffle_idx', + reverseidx) + + def forward(self, x, reverse=False): + if not reverse: + return x[:, self.forward_shuffle_idx] + else: + return x[:, self.backward_shuffle_idx] + + +class SpiralOut(AbstractPermuter): + def __init__(self, H, W): + super().__init__() + assert H == W + size = W + indices = np.arange(size*size).reshape(size,size) + + i0 = size//2 + j0 = size//2-1 + + i = i0 + j = j0 + + idx = [indices[i0, j0]] + step_mult = 0 + for c in range(1, size//2+1): + step_mult += 1 + # steps left + for k in range(step_mult): + i = i - 1 + j = j + idx.append(indices[i, j]) + + # step down + for k in range(step_mult): + i = i + j = j + 1 + idx.append(indices[i, j]) + + step_mult += 1 + if c < size//2: + # step right + for k in range(step_mult): + i = i + 1 + j = j + idx.append(indices[i, j]) + + # step up + for k in range(step_mult): + i = i + j = j - 1 + idx.append(indices[i, j]) + else: + # end reached + for k in range(step_mult-1): + i = i + 1 + idx.append(indices[i, j]) + + assert len(idx) == size*size + idx = torch.tensor(idx) + self.register_buffer('forward_shuffle_idx', idx) + self.register_buffer('backward_shuffle_idx', torch.argsort(idx)) + + def forward(self, x, reverse=False): + if not reverse: + return x[:, self.forward_shuffle_idx] + else: + return x[:, self.backward_shuffle_idx] + + +class SpiralIn(AbstractPermuter): + def __init__(self, H, W): + super().__init__() + assert H == W + size = W + indices = np.arange(size*size).reshape(size,size) + + i0 = size//2 + j0 = size//2-1 + + i = i0 + j = j0 + + idx = [indices[i0, j0]] + step_mult = 0 + for c in range(1, size//2+1): + step_mult += 1 + # steps left + for k in range(step_mult): + i = i - 1 + j = j + idx.append(indices[i, j]) + + # step down + for k in range(step_mult): + i = i + j = j + 1 + idx.append(indices[i, j]) + + step_mult += 1 + if c < size//2: + # step right + for k in range(step_mult): + i = i + 1 + j = j + idx.append(indices[i, j]) + + # step up + for k in range(step_mult): + i = i + j = j - 1 + idx.append(indices[i, j]) + else: + # end reached + for k in range(step_mult-1): + i = i + 1 + idx.append(indices[i, j]) + + assert len(idx) == size*size + idx = idx[::-1] + idx = torch.tensor(idx) + self.register_buffer('forward_shuffle_idx', idx) + self.register_buffer('backward_shuffle_idx', torch.argsort(idx)) + + def forward(self, x, reverse=False): + if not reverse: + return x[:, self.forward_shuffle_idx] + else: + return x[:, self.backward_shuffle_idx] + + +class Random(nn.Module): + def __init__(self, H, W): + super().__init__() + indices = np.random.RandomState(1).permutation(H*W) + idx = torch.tensor(indices.ravel()) + self.register_buffer('forward_shuffle_idx', idx) + self.register_buffer('backward_shuffle_idx', torch.argsort(idx)) + + def forward(self, x, reverse=False): + if not reverse: + return x[:, self.forward_shuffle_idx] + else: + return x[:, self.backward_shuffle_idx] + + +class AlternateParsing(AbstractPermuter): + def __init__(self, H, W): + super().__init__() + indices = np.arange(W*H).reshape(H,W) + for i in range(1, H, 2): + indices[i, :] = indices[i, ::-1] + idx = indices.flatten() + assert len(idx) == H*W + idx = torch.tensor(idx) + self.register_buffer('forward_shuffle_idx', idx) + self.register_buffer('backward_shuffle_idx', torch.argsort(idx)) + + def forward(self, x, reverse=False): + if not reverse: + return x[:, self.forward_shuffle_idx] + else: + return x[:, self.backward_shuffle_idx] + + +if __name__ == "__main__": + p0 = AlternateParsing(16, 16) + print(p0.forward_shuffle_idx) + print(p0.backward_shuffle_idx) + + x = torch.randint(0, 768, size=(11, 256)) + y = p0(x) + xre = p0(y, reverse=True) + assert torch.equal(x, xre) + + p1 = SpiralOut(2, 2) + print(p1.forward_shuffle_idx) + print(p1.backward_shuffle_idx) diff --git a/taming/modules/util.py b/taming/modules/util.py new file mode 100644 index 0000000..9ee1638 --- /dev/null +++ b/taming/modules/util.py @@ -0,0 +1,130 @@ +import torch +import torch.nn as nn + + +def count_params(model): + total_params = sum(p.numel() for p in model.parameters()) + return total_params + + +class ActNorm(nn.Module): + def __init__(self, num_features, logdet=False, affine=True, + allow_reverse_init=False): + assert affine + super().__init__() + self.logdet = logdet + self.loc = nn.Parameter(torch.zeros(1, num_features, 1, 1)) + self.scale = nn.Parameter(torch.ones(1, num_features, 1, 1)) + self.allow_reverse_init = allow_reverse_init + + self.register_buffer('initialized', torch.tensor(0, dtype=torch.uint8)) + + def initialize(self, input): + with torch.no_grad(): + flatten = input.permute(1, 0, 2, 3).contiguous().view(input.shape[1], -1) + mean = ( + flatten.mean(1) + .unsqueeze(1) + .unsqueeze(2) + .unsqueeze(3) + .permute(1, 0, 2, 3) + ) + std = ( + flatten.std(1) + .unsqueeze(1) + .unsqueeze(2) + .unsqueeze(3) + .permute(1, 0, 2, 3) + ) + + self.loc.data.copy_(-mean) + self.scale.data.copy_(1 / (std + 1e-6)) + + def forward(self, input, reverse=False): + if reverse: + return self.reverse(input) + if len(input.shape) == 2: + input = input[:,:,None,None] + squeeze = True + else: + squeeze = False + + _, _, height, width = input.shape + + if self.training and self.initialized.item() == 0: + self.initialize(input) + self.initialized.fill_(1) + + h = self.scale * (input + self.loc) + + if squeeze: + h = h.squeeze(-1).squeeze(-1) + + if self.logdet: + log_abs = torch.log(torch.abs(self.scale)) + logdet = height*width*torch.sum(log_abs) + logdet = logdet * torch.ones(input.shape[0]).to(input) + return h, logdet + + return h + + def reverse(self, output): + if self.training and self.initialized.item() == 0: + if not self.allow_reverse_init: + raise RuntimeError( + "Initializing ActNorm in reverse direction is " + "disabled by default. Use allow_reverse_init=True to enable." + ) + else: + self.initialize(output) + self.initialized.fill_(1) + + if len(output.shape) == 2: + output = output[:,:,None,None] + squeeze = True + else: + squeeze = False + + h = output / self.scale - self.loc + + if squeeze: + h = h.squeeze(-1).squeeze(-1) + return h + + +class AbstractEncoder(nn.Module): + def __init__(self): + super().__init__() + + def encode(self, *args, **kwargs): + raise NotImplementedError + + +class Labelator(AbstractEncoder): + """Net2Net Interface for Class-Conditional Model""" + def __init__(self, n_classes, quantize_interface=True): + super().__init__() + self.n_classes = n_classes + self.quantize_interface = quantize_interface + + def encode(self, c): + c = c[:,None] + if self.quantize_interface: + return c, None, [None, None, c.long()] + return c + + +class SOSProvider(AbstractEncoder): + # for unconditional training + def __init__(self, sos_token, quantize_interface=True): + super().__init__() + self.sos_token = sos_token + self.quantize_interface = quantize_interface + + def encode(self, x): + # get batch size from data and replicate sos_token + c = torch.ones(x.shape[0], 1)*self.sos_token + c = c.long().to(x.device) + if self.quantize_interface: + return c, None, [None, None, c] + return c diff --git a/taming/modules/vqvae/quantize.py b/taming/modules/vqvae/quantize.py new file mode 100644 index 0000000..d75544e --- /dev/null +++ b/taming/modules/vqvae/quantize.py @@ -0,0 +1,445 @@ +import torch +import torch.nn as nn +import torch.nn.functional as F +import numpy as np +from torch import einsum +from einops import rearrange + + +class VectorQuantizer(nn.Module): + """ + see https://github.com/MishaLaskin/vqvae/blob/d761a999e2267766400dc646d82d3ac3657771d4/models/quantizer.py + ____________________________________________ + Discretization bottleneck part of the VQ-VAE. + Inputs: + - n_e : number of embeddings + - e_dim : dimension of embedding + - beta : commitment cost used in loss term, beta * ||z_e(x)-sg[e]||^2 + _____________________________________________ + """ + + # NOTE: this class contains a bug regarding beta; see VectorQuantizer2 for + # a fix and use legacy=False to apply that fix. VectorQuantizer2 can be + # used wherever VectorQuantizer has been used before and is additionally + # more efficient. + def __init__(self, n_e, e_dim, beta): + super(VectorQuantizer, self).__init__() + self.n_e = n_e + self.e_dim = e_dim + self.beta = beta + + self.embedding = nn.Embedding(self.n_e, self.e_dim) + self.embedding.weight.data.uniform_(-1.0 / self.n_e, 1.0 / self.n_e) + + def forward(self, z): + """ + Inputs the output of the encoder network z and maps it to a discrete + one-hot vector that is the index of the closest embedding vector e_j + z (continuous) -> z_q (discrete) + z.shape = (batch, channel, height, width) + quantization pipeline: + 1. get encoder input (B,C,H,W) + 2. flatten input to (B*H*W,C) + """ + # reshape z -> (batch, height, width, channel) and flatten + z = z.permute(0, 2, 3, 1).contiguous() + z_flattened = z.view(-1, self.e_dim) + # distances from z to embeddings e_j (z - e)^2 = z^2 + e^2 - 2 e * z + + d = torch.sum(z_flattened ** 2, dim=1, keepdim=True) + \ + torch.sum(self.embedding.weight**2, dim=1) - 2 * \ + torch.matmul(z_flattened, self.embedding.weight.t()) + + ## could possible replace this here + # #\start... + # find closest encodings + min_encoding_indices = torch.argmin(d, dim=1).unsqueeze(1) + + min_encodings = torch.zeros( + min_encoding_indices.shape[0], self.n_e).to(z) + min_encodings.scatter_(1, min_encoding_indices, 1) + + # dtype min encodings: torch.float32 + # min_encodings shape: torch.Size([2048, 512]) + # min_encoding_indices.shape: torch.Size([2048, 1]) + + # get quantized latent vectors + z_q = torch.matmul(min_encodings, self.embedding.weight).view(z.shape) + #.........\end + + # with: + # .........\start + #min_encoding_indices = torch.argmin(d, dim=1) + #z_q = self.embedding(min_encoding_indices) + # ......\end......... (TODO) + + # compute loss for embedding + loss = torch.mean((z_q.detach()-z)**2) + self.beta * \ + torch.mean((z_q - z.detach()) ** 2) + + # preserve gradients + z_q = z + (z_q - z).detach() + + # perplexity + e_mean = torch.mean(min_encodings, dim=0) + perplexity = torch.exp(-torch.sum(e_mean * torch.log(e_mean + 1e-10))) + + # reshape back to match original input shape + z_q = z_q.permute(0, 3, 1, 2).contiguous() + + return z_q, loss, (perplexity, min_encodings, min_encoding_indices) + + def get_codebook_entry(self, indices, shape): + # shape specifying (batch, height, width, channel) + # TODO: check for more easy handling with nn.Embedding + min_encodings = torch.zeros(indices.shape[0], self.n_e).to(indices) + min_encodings.scatter_(1, indices[:,None], 1) + + # get quantized latent vectors + z_q = torch.matmul(min_encodings.float(), self.embedding.weight) + + if shape is not None: + z_q = z_q.view(shape) + + # reshape back to match original input shape + z_q = z_q.permute(0, 3, 1, 2).contiguous() + + return z_q + + +class GumbelQuantize(nn.Module): + """ + credit to @karpathy: https://github.com/karpathy/deep-vector-quantization/blob/main/model.py (thanks!) + Gumbel Softmax trick quantizer + Categorical Reparameterization with Gumbel-Softmax, Jang et al. 2016 + https://arxiv.org/abs/1611.01144 + """ + def __init__(self, num_hiddens, embedding_dim, n_embed, straight_through=True, + kl_weight=5e-4, temp_init=1.0, use_vqinterface=True, + remap=None, unknown_index="random"): + super().__init__() + + self.embedding_dim = embedding_dim + self.n_embed = n_embed + + self.straight_through = straight_through + self.temperature = temp_init + self.kl_weight = kl_weight + + self.proj = nn.Conv2d(num_hiddens, n_embed, 1) + self.embed = nn.Embedding(n_embed, embedding_dim) + + self.use_vqinterface = use_vqinterface + + self.remap = remap + if self.remap is not None: + self.register_buffer("used", torch.tensor(np.load(self.remap))) + self.re_embed = self.used.shape[0] + self.unknown_index = unknown_index # "random" or "extra" or integer + if self.unknown_index == "extra": + self.unknown_index = self.re_embed + self.re_embed = self.re_embed+1 + print(f"Remapping {self.n_embed} indices to {self.re_embed} indices. " + f"Using {self.unknown_index} for unknown indices.") + else: + self.re_embed = n_embed + + def remap_to_used(self, inds): + ishape = inds.shape + assert len(ishape)>1 + inds = inds.reshape(ishape[0],-1) + used = self.used.to(inds) + match = (inds[:,:,None]==used[None,None,...]).long() + new = match.argmax(-1) + unknown = match.sum(2)<1 + if self.unknown_index == "random": + new[unknown]=torch.randint(0,self.re_embed,size=new[unknown].shape).to(device=new.device) + else: + new[unknown] = self.unknown_index + return new.reshape(ishape) + + def unmap_to_all(self, inds): + ishape = inds.shape + assert len(ishape)>1 + inds = inds.reshape(ishape[0],-1) + used = self.used.to(inds) + if self.re_embed > self.used.shape[0]: # extra token + inds[inds>=self.used.shape[0]] = 0 # simply set to zero + back=torch.gather(used[None,:][inds.shape[0]*[0],:], 1, inds) + return back.reshape(ishape) + + def forward(self, z, temp=None, return_logits=False): + # force hard = True when we are in eval mode, as we must quantize. actually, always true seems to work + hard = self.straight_through if self.training else True + temp = self.temperature if temp is None else temp + + logits = self.proj(z) + if self.remap is not None: + # continue only with used logits + full_zeros = torch.zeros_like(logits) + logits = logits[:,self.used,...] + + soft_one_hot = F.gumbel_softmax(logits, tau=temp, dim=1, hard=hard) + if self.remap is not None: + # go back to all entries but unused set to zero + full_zeros[:,self.used,...] = soft_one_hot + soft_one_hot = full_zeros + z_q = einsum('b n h w, n d -> b d h w', soft_one_hot, self.embed.weight) + + # + kl divergence to the prior loss + qy = F.softmax(logits, dim=1) + diff = self.kl_weight * torch.sum(qy * torch.log(qy * self.n_embed + 1e-10), dim=1).mean() + + ind = soft_one_hot.argmax(dim=1) + if self.remap is not None: + ind = self.remap_to_used(ind) + if self.use_vqinterface: + if return_logits: + return z_q, diff, (None, None, ind), logits + return z_q, diff, (None, None, ind) + return z_q, diff, ind + + def get_codebook_entry(self, indices, shape): + b, h, w, c = shape + assert b*h*w == indices.shape[0] + indices = rearrange(indices, '(b h w) -> b h w', b=b, h=h, w=w) + if self.remap is not None: + indices = self.unmap_to_all(indices) + one_hot = F.one_hot(indices, num_classes=self.n_embed).permute(0, 3, 1, 2).float() + z_q = einsum('b n h w, n d -> b d h w', one_hot, self.embed.weight) + return z_q + + +class VectorQuantizer2(nn.Module): + """ + Improved version over VectorQuantizer, can be used as a drop-in replacement. Mostly + avoids costly matrix multiplications and allows for post-hoc remapping of indices. + """ + # NOTE: due to a bug the beta term was applied to the wrong term. for + # backwards compatibility we use the buggy version by default, but you can + # specify legacy=False to fix it. + def __init__(self, n_e, e_dim, beta, remap=None, unknown_index="random", + sane_index_shape=False, legacy=True): + super().__init__() + self.n_e = n_e + self.e_dim = e_dim + self.beta = beta + self.legacy = legacy + + self.embedding = nn.Embedding(self.n_e, self.e_dim) + self.embedding.weight.data.uniform_(-1.0 / self.n_e, 1.0 / self.n_e) + + self.remap = remap + if self.remap is not None: + self.register_buffer("used", torch.tensor(np.load(self.remap))) + self.re_embed = self.used.shape[0] + self.unknown_index = unknown_index # "random" or "extra" or integer + if self.unknown_index == "extra": + self.unknown_index = self.re_embed + self.re_embed = self.re_embed+1 + print(f"Remapping {self.n_e} indices to {self.re_embed} indices. " + f"Using {self.unknown_index} for unknown indices.") + else: + self.re_embed = n_e + + self.sane_index_shape = sane_index_shape + + def remap_to_used(self, inds): + ishape = inds.shape + assert len(ishape)>1 + inds = inds.reshape(ishape[0],-1) + used = self.used.to(inds) + match = (inds[:,:,None]==used[None,None,...]).long() + new = match.argmax(-1) + unknown = match.sum(2)<1 + if self.unknown_index == "random": + new[unknown]=torch.randint(0,self.re_embed,size=new[unknown].shape).to(device=new.device) + else: + new[unknown] = self.unknown_index + return new.reshape(ishape) + + def unmap_to_all(self, inds): + ishape = inds.shape + assert len(ishape)>1 + inds = inds.reshape(ishape[0],-1) + used = self.used.to(inds) + if self.re_embed > self.used.shape[0]: # extra token + inds[inds>=self.used.shape[0]] = 0 # simply set to zero + back=torch.gather(used[None,:][inds.shape[0]*[0],:], 1, inds) + return back.reshape(ishape) + + def forward(self, z, temp=None, rescale_logits=False, return_logits=False): + assert temp is None or temp==1.0, "Only for interface compatible with Gumbel" + assert rescale_logits==False, "Only for interface compatible with Gumbel" + assert return_logits==False, "Only for interface compatible with Gumbel" + # reshape z -> (batch, height, width, channel) and flatten + z = rearrange(z, 'b c h w -> b h w c').contiguous() + z_flattened = z.view(-1, self.e_dim) + # distances from z to embeddings e_j (z - e)^2 = z^2 + e^2 - 2 e * z + + d = torch.sum(z_flattened ** 2, dim=1, keepdim=True) + \ + torch.sum(self.embedding.weight**2, dim=1) - 2 * \ + torch.einsum('bd,dn->bn', z_flattened, rearrange(self.embedding.weight, 'n d -> d n')) + + min_encoding_indices = torch.argmin(d, dim=1) + z_q = self.embedding(min_encoding_indices).view(z.shape) + perplexity = None + min_encodings = None + + # compute loss for embedding + if not self.legacy: + loss = self.beta * torch.mean((z_q.detach()-z)**2) + \ + torch.mean((z_q - z.detach()) ** 2) + else: + loss = torch.mean((z_q.detach()-z)**2) + self.beta * \ + torch.mean((z_q - z.detach()) ** 2) + + # preserve gradients + z_q = z + (z_q - z).detach() + + # reshape back to match original input shape + z_q = rearrange(z_q, 'b h w c -> b c h w').contiguous() + + if self.remap is not None: + min_encoding_indices = min_encoding_indices.reshape(z.shape[0],-1) # add batch axis + min_encoding_indices = self.remap_to_used(min_encoding_indices) + min_encoding_indices = min_encoding_indices.reshape(-1,1) # flatten + + if self.sane_index_shape: + min_encoding_indices = min_encoding_indices.reshape( + z_q.shape[0], z_q.shape[2], z_q.shape[3]) + + return z_q, loss, (perplexity, min_encodings, min_encoding_indices) + + def get_codebook_entry(self, indices, shape): + # shape specifying (batch, height, width, channel) + if self.remap is not None: + indices = indices.reshape(shape[0],-1) # add batch axis + indices = self.unmap_to_all(indices) + indices = indices.reshape(-1) # flatten again + + # get quantized latent vectors + z_q = self.embedding(indices) + + if shape is not None: + z_q = z_q.view(shape) + # reshape back to match original input shape + z_q = z_q.permute(0, 3, 1, 2).contiguous() + + return z_q + +class EmbeddingEMA(nn.Module): + def __init__(self, num_tokens, codebook_dim, decay=0.99, eps=1e-5): + super().__init__() + self.decay = decay + self.eps = eps + weight = torch.randn(num_tokens, codebook_dim) + self.weight = nn.Parameter(weight, requires_grad = False) + self.cluster_size = nn.Parameter(torch.zeros(num_tokens), requires_grad = False) + self.embed_avg = nn.Parameter(weight.clone(), requires_grad = False) + self.update = True + + def forward(self, embed_id): + return F.embedding(embed_id, self.weight) + + def cluster_size_ema_update(self, new_cluster_size): + self.cluster_size.data.mul_(self.decay).add_(new_cluster_size, alpha=1 - self.decay) + + def embed_avg_ema_update(self, new_embed_avg): + self.embed_avg.data.mul_(self.decay).add_(new_embed_avg, alpha=1 - self.decay) + + def weight_update(self, num_tokens): + n = self.cluster_size.sum() + smoothed_cluster_size = ( + (self.cluster_size + self.eps) / (n + num_tokens * self.eps) * n + ) + #normalize embedding average with smoothed cluster size + embed_normalized = self.embed_avg / smoothed_cluster_size.unsqueeze(1) + self.weight.data.copy_(embed_normalized) + + +class EMAVectorQuantizer(nn.Module): + def __init__(self, n_embed, embedding_dim, beta, decay=0.99, eps=1e-5, + remap=None, unknown_index="random"): + super().__init__() + self.codebook_dim = codebook_dim + self.num_tokens = num_tokens + self.beta = beta + self.embedding = EmbeddingEMA(self.num_tokens, self.codebook_dim, decay, eps) + + self.remap = remap + if self.remap is not None: + self.register_buffer("used", torch.tensor(np.load(self.remap))) + self.re_embed = self.used.shape[0] + self.unknown_index = unknown_index # "random" or "extra" or integer + if self.unknown_index == "extra": + self.unknown_index = self.re_embed + self.re_embed = self.re_embed+1 + print(f"Remapping {self.n_embed} indices to {self.re_embed} indices. " + f"Using {self.unknown_index} for unknown indices.") + else: + self.re_embed = n_embed + + def remap_to_used(self, inds): + ishape = inds.shape + assert len(ishape)>1 + inds = inds.reshape(ishape[0],-1) + used = self.used.to(inds) + match = (inds[:,:,None]==used[None,None,...]).long() + new = match.argmax(-1) + unknown = match.sum(2)<1 + if self.unknown_index == "random": + new[unknown]=torch.randint(0,self.re_embed,size=new[unknown].shape).to(device=new.device) + else: + new[unknown] = self.unknown_index + return new.reshape(ishape) + + def unmap_to_all(self, inds): + ishape = inds.shape + assert len(ishape)>1 + inds = inds.reshape(ishape[0],-1) + used = self.used.to(inds) + if self.re_embed > self.used.shape[0]: # extra token + inds[inds>=self.used.shape[0]] = 0 # simply set to zero + back=torch.gather(used[None,:][inds.shape[0]*[0],:], 1, inds) + return back.reshape(ishape) + + def forward(self, z): + # reshape z -> (batch, height, width, channel) and flatten + #z, 'b c h w -> b h w c' + z = rearrange(z, 'b c h w -> b h w c') + z_flattened = z.reshape(-1, self.codebook_dim) + + # distances from z to embeddings e_j (z - e)^2 = z^2 + e^2 - 2 e * z + d = z_flattened.pow(2).sum(dim=1, keepdim=True) + \ + self.embedding.weight.pow(2).sum(dim=1) - 2 * \ + torch.einsum('bd,nd->bn', z_flattened, self.embedding.weight) # 'n d -> d n' + + + encoding_indices = torch.argmin(d, dim=1) + + z_q = self.embedding(encoding_indices).view(z.shape) + encodings = F.one_hot(encoding_indices, self.num_tokens).type(z.dtype) + avg_probs = torch.mean(encodings, dim=0) + perplexity = torch.exp(-torch.sum(avg_probs * torch.log(avg_probs + 1e-10))) + + if self.training and self.embedding.update: + #EMA cluster size + encodings_sum = encodings.sum(0) + self.embedding.cluster_size_ema_update(encodings_sum) + #EMA embedding average + embed_sum = encodings.transpose(0,1) @ z_flattened + self.embedding.embed_avg_ema_update(embed_sum) + #normalize embed_avg and update weight + self.embedding.weight_update(self.num_tokens) + + # compute loss for embedding + loss = self.beta * F.mse_loss(z_q.detach(), z) + + # preserve gradients + z_q = z + (z_q - z).detach() + + # reshape back to match original input shape + #z_q, 'b h w c -> b c h w' + z_q = rearrange(z_q, 'b h w c -> b c h w') + return z_q, loss, (perplexity, encodings, encoding_indices) diff --git a/taming/util.py b/taming/util.py new file mode 100644 index 0000000..06053e5 --- /dev/null +++ b/taming/util.py @@ -0,0 +1,157 @@ +import os, hashlib +import requests +from tqdm import tqdm + +URL_MAP = { + "vgg_lpips": "https://heibox.uni-heidelberg.de/f/607503859c864bc1b30b/?dl=1" +} + +CKPT_MAP = { + "vgg_lpips": "vgg.pth" +} + +MD5_MAP = { + "vgg_lpips": "d507d7349b931f0638a25a48a722f98a" +} + + +def download(url, local_path, chunk_size=1024): + os.makedirs(os.path.split(local_path)[0], exist_ok=True) + with requests.get(url, stream=True) as r: + total_size = int(r.headers.get("content-length", 0)) + with tqdm(total=total_size, unit="B", unit_scale=True) as pbar: + with open(local_path, "wb") as f: + for data in r.iter_content(chunk_size=chunk_size): + if data: + f.write(data) + pbar.update(chunk_size) + + +def md5_hash(path): + with open(path, "rb") as f: + content = f.read() + return hashlib.md5(content).hexdigest() + + +def get_ckpt_path(name, root, check=False): + assert name in URL_MAP + path = os.path.join(root, CKPT_MAP[name]) + if not os.path.exists(path) or (check and not md5_hash(path) == MD5_MAP[name]): + print("Downloading {} model from {} to {}".format(name, URL_MAP[name], path)) + download(URL_MAP[name], path) + md5 = md5_hash(path) + assert md5 == MD5_MAP[name], md5 + return path + + +class KeyNotFoundError(Exception): + def __init__(self, cause, keys=None, visited=None): + self.cause = cause + self.keys = keys + self.visited = visited + messages = list() + if keys is not None: + messages.append("Key not found: {}".format(keys)) + if visited is not None: + messages.append("Visited: {}".format(visited)) + messages.append("Cause:\n{}".format(cause)) + message = "\n".join(messages) + super().__init__(message) + + +def retrieve( + list_or_dict, key, splitval="/", default=None, expand=True, pass_success=False +): + """Given a nested list or dict return the desired value at key expanding + callable nodes if necessary and :attr:`expand` is ``True``. The expansion + is done in-place. + + Parameters + ---------- + list_or_dict : list or dict + Possibly nested list or dictionary. + key : str + key/to/value, path like string describing all keys necessary to + consider to get to the desired value. List indices can also be + passed here. + splitval : str + String that defines the delimiter between keys of the + different depth levels in `key`. + default : obj + Value returned if :attr:`key` is not found. + expand : bool + Whether to expand callable nodes on the path or not. + + Returns + ------- + The desired value or if :attr:`default` is not ``None`` and the + :attr:`key` is not found returns ``default``. + + Raises + ------ + Exception if ``key`` not in ``list_or_dict`` and :attr:`default` is + ``None``. + """ + + keys = key.split(splitval) + + success = True + try: + visited = [] + parent = None + last_key = None + for key in keys: + if callable(list_or_dict): + if not expand: + raise KeyNotFoundError( + ValueError( + "Trying to get past callable node with expand=False." + ), + keys=keys, + visited=visited, + ) + list_or_dict = list_or_dict() + parent[last_key] = list_or_dict + + last_key = key + parent = list_or_dict + + try: + if isinstance(list_or_dict, dict): + list_or_dict = list_or_dict[key] + else: + list_or_dict = list_or_dict[int(key)] + except (KeyError, IndexError, ValueError) as e: + raise KeyNotFoundError(e, keys=keys, visited=visited) + + visited += [key] + # final expansion of retrieved value + if expand and callable(list_or_dict): + list_or_dict = list_or_dict() + parent[last_key] = list_or_dict + except KeyNotFoundError as e: + if default is None: + raise e + else: + list_or_dict = default + success = False + + if not pass_success: + return list_or_dict + else: + return list_or_dict, success + + +if __name__ == "__main__": + config = {"keya": "a", + "keyb": "b", + "keyc": + {"cc1": 1, + "cc2": 2, + } + } + from omegaconf import OmegaConf + config = OmegaConf.create(config) + print(config) + retrieve(config, "keya") + diff --git a/textual-inversion/autoinit.py b/textual-inversion/autoinit.py new file mode 100644 index 0000000..e6f3303 --- /dev/null +++ b/textual-inversion/autoinit.py @@ -0,0 +1,119 @@ +""" +It takes about 2 minutes to compute and save embeddings for all noun tokens in the CLIP tokenizer vocabulary. Examples: + +python autoinit.py save_embeddings +python autoinit.py get_initialization /path/to/bird.jpg + +""" +import sys +from pathlib import Path +from typing import Optional + +import torch +import torch.nn.functional as F +from PIL import Image +from tqdm import tqdm +from transformers import CLIPModel, CLIPProcessor + +torch.set_grad_enabled(False) + +DEFAULT_EMB_FILE = 'clip-vit-large-patch14-text-embeddings.pth' + + +def get_model(): + model: CLIPModel = CLIPModel.from_pretrained("openai/clip-vit-large-patch14").eval() + processor: CLIPProcessor = CLIPProcessor.from_pretrained("openai/clip-vit-large-patch14") + return model, processor + + +def save_embeddings(file_name: str = DEFAULT_EMB_FILE, device: str = 'cuda'): + try: + import nltk + from nltk.corpus import wordnet as wn + except ImportError: + print('Please install google fire with `pip install fire`') + sys.exit() + + # # The first time you run this code you will have to run this + # nltk.download('wordnet') + # nltk.download('omw-1.4') + # All English nouns + english_nouns = {x.name().split('.', 1)[0] for x in wn.all_synsets('n')} + print(f'Found {len(english_nouns)} English nouns') + + # Get model + model, processor = get_model() + model.to(device) + + # Get all tokens in CLIP tokenizer that are nouns + all_noun_ids = [] + all_token_ids = sorted(processor.tokenizer.vocab.values()) + for token_id in tqdm(all_token_ids): + token_str = processor.tokenizer.convert_ids_to_tokens(token_id) + if token_str.replace('', '') in english_nouns and token_str.endswith(''): + all_noun_ids.append(token_id) + print(f'Found {len(all_noun_ids)} English nouns in the CLIP tokenizer') + + # Get all embeddings + all_text_emb = [] + all_text_str = [] + for token_id in tqdm(all_noun_ids): + text_ids = [49406, 550, 2867, 539, 320, token_id, 49407] # " an image of a _ " + text_str = processor.tokenizer.decode(text_ids, skip_special_tokens=True) + inputs = processor(text=text_str, return_tensors="pt", padding=True) + text_emb = model.get_text_features(**inputs.to(device)) + text_emb = F.normalize(text_emb, p=2, dim=-1) + all_text_emb.append(text_emb.detach().cpu()) + all_text_str.append(text_str) + all_text_emb = torch.cat(all_text_emb) + + # Save + torch.save({ + 'idx': all_noun_ids, + 'emb': all_text_emb, + }, file_name) + print(f'Saved embeddings to {file_name}') + +# %% + +def get_initialization(image_file: str, text_emb_file: str = DEFAULT_EMB_FILE, device: str = 'cuda', + save: bool = False, save_dir: Optional[str] = None): + + # Load text embeddings + text_emb = torch.load(text_emb_file) + all_noun_ids = text_emb['idx'] + all_noun_emb = text_emb['emb'] + + # Get model + model, processor = get_model() + model.to(device) + + # Load and process + image = Image.open(image_file) + inputs = processor(images=image, return_tensors="pt", padding=True) + image_emb = model.get_image_features(**inputs.to(device)) + image_emb = F.normalize(image_emb, p=2, dim=-1) + + # Get similarities + sim = all_noun_emb.to(device) @ image_emb.to(device).squeeze() # (V, ) + sim = F.softmax(sim, dim=-1) # (V, ) + topk_texts = sim.topk(k=5, largest=True, sorted=True) + topk_indices = [all_noun_ids[idx] for idx in topk_texts.indices.cpu()] + + # Print topk + topk_tokens = processor.tokenizer.convert_ids_to_tokens(topk_indices) + top_token = topk_tokens[0].replace('', '') + print('Top tokens:') + print(topk_tokens) + if save: + save_dir = Path(image_file).parent if save_dir is None else Path(save_dir) + text_file = save_dir / 'token_autoinit.txt' + text_file.write_text(top_token) + +if __name__ == "__main__": + try: + import fire + except ImportError: + print('Please install google fire with `pip install fire`') + sys.exit() + fire.Fire(dict(get_initialization=get_initialization, save_embeddings=save_embeddings)) \ No newline at end of file diff --git a/textual-inversion/null_inversion.py b/textual-inversion/null_inversion.py new file mode 100644 index 0000000..1ee4746 --- /dev/null +++ b/textual-inversion/null_inversion.py @@ -0,0 +1,340 @@ +# %% [markdown] +# ## Copyright 2022 Google LLC. Double-click for license information. + +# %% +# Copyright 2022 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# %% [markdown] +# # Null-text inversion + Editing with Prompt-to-Prompt + +# %% +from typing import Optional, Union, Tuple, List, Callable, Dict +# from tqdm.notebook import tqdm +from tqdm import tqdm +import torch +from diffusers import StableDiffusionPipeline, DDIMScheduler +from diffusers.utils.import_utils import is_xformers_available +import torch.nn.functional as nnf +import numpy as np +import abc +import ptp_utils +import seq_aligner +import shutil +from torch.optim.adam import Adam +from PIL import Image + +# %% [markdown] +# For loading the Stable Diffusion using Diffusers, follow the instuctions https://huggingface.co/blog/stable_diffusion and update MY_TOKEN with your token. + +# %% +scheduler = DDIMScheduler(beta_start=0.00085, beta_end=0.012, beta_schedule="scaled_linear", clip_sample=False, set_alpha_to_one=False) +MY_TOKEN = '' +LOW_RESOURCE = False +NUM_DDIM_STEPS = 50 +GUIDANCE_SCALE = 7.5 +MAX_NUM_WORDS = 77 +device = torch.device('cuda:0') if torch.cuda.is_available() else torch.device('cpu') +# ldm_stable = StableDiffusionPipeline.from_pretrained("stabilityai/stable-diffusion-2-1-base", scheduler=scheduler).to(device) +ldm_stable = StableDiffusionPipeline.from_pretrained("stabilityai/stable-diffusion-2-1-base").to(device) +# try: +# ldm_stable.disable_xformers_memory_efficient_attention() +# except AttributeError: +# print("Attribute disable_xformers_memory_efficient_attention() is missing") +if is_xformers_available(): + ldm_stable.enable_xformers_memory_efficient_attention() + +tokenizer = ldm_stable.tokenizer +def load_512(image_path, left=0, right=0, top=0, bottom=0): + if type(image_path) is str: + image = np.array(Image.open(image_path))[:, :, :3] + else: + image = image_path + h, w, c = image.shape + left = min(left, w-1) + right = min(right, w - left - 1) + top = min(top, h - left - 1) + bottom = min(bottom, h - top - 1) + image = image[top:h-bottom, left:w-right] + h, w, c = image.shape + if h < w: + offset = (w - h) // 2 + image = image[:, offset:offset + h] + elif w < h: + offset = (h - w) // 2 + image = image[offset:offset + w] + image = np.array(Image.fromarray(image).resize((512, 512))) + return image + + +class NullInversion: + + def prev_step(self, model_output: Union[torch.FloatTensor, np.ndarray], timestep: int, sample: Union[torch.FloatTensor, np.ndarray]): + prev_timestep = timestep - self.scheduler.config.num_train_timesteps // self.scheduler.num_inference_steps + alpha_prod_t = self.scheduler.alphas_cumprod[timestep] + alpha_prod_t_prev = self.scheduler.alphas_cumprod[prev_timestep] if prev_timestep >= 0 else self.scheduler.final_alpha_cumprod + beta_prod_t = 1 - alpha_prod_t + pred_original_sample = (sample - beta_prod_t ** 0.5 * model_output) / alpha_prod_t ** 0.5 + pred_sample_direction = (1 - alpha_prod_t_prev) ** 0.5 * model_output + prev_sample = alpha_prod_t_prev ** 0.5 * pred_original_sample + pred_sample_direction + return prev_sample + + def next_step(self, model_output: Union[torch.FloatTensor, np.ndarray], timestep: int, sample: Union[torch.FloatTensor, np.ndarray]): + timestep, next_timestep = min(timestep - self.scheduler.config.num_train_timesteps // self.scheduler.num_inference_steps, 999), timestep + alpha_prod_t = self.scheduler.alphas_cumprod[timestep] if timestep >= 0 else self.scheduler.final_alpha_cumprod + alpha_prod_t_next = self.scheduler.alphas_cumprod[next_timestep] + beta_prod_t = 1 - alpha_prod_t + next_original_sample = (sample - beta_prod_t ** 0.5 * model_output) / alpha_prod_t ** 0.5 + next_sample_direction = (1 - alpha_prod_t_next) ** 0.5 * model_output + next_sample = alpha_prod_t_next ** 0.5 * next_original_sample + next_sample_direction + return next_sample + + def get_noise_pred_single(self, latents, t, context): + noise_pred = self.model.unet(latents, t, encoder_hidden_states=context)["sample"] + return noise_pred + + def get_noise_pred(self, latents, t, is_forward=True, context=None): + latents_input = torch.cat([latents] * 2) + if context is None: + context = self.context + guidance_scale = 1 if is_forward else GUIDANCE_SCALE + noise_pred = self.model.unet(latents_input, t, encoder_hidden_states=context)["sample"] + noise_pred_uncond, noise_prediction_text = noise_pred.chunk(2) + noise_pred = noise_pred_uncond + guidance_scale * (noise_prediction_text - noise_pred_uncond) + if is_forward: + latents = self.next_step(noise_pred, t, latents) + else: + latents = self.prev_step(noise_pred, t, latents) + return latents + + @torch.no_grad() + def latent2image(self, latents, return_type='np'): + latents = 1 / 0.18215 * latents.detach() + image = self.model.vae.decode(latents)['sample'] + if return_type == 'np': + image = (image / 2 + 0.5).clamp(0, 1) + image = image.cpu().permute(0, 2, 3, 1).numpy()[0] + image = (image * 255).astype(np.uint8) + return image + + @torch.no_grad() + def image2latent(self, image): + with torch.no_grad(): + if type(image) is Image: + image = np.array(image) + if type(image) is torch.Tensor and image.dim() == 4: + latents = image + else: + image = torch.from_numpy(image).float() / 127.5 - 1 + image = image.permute(2, 0, 1).unsqueeze(0).to(device) + latents = self.model.vae.encode(image)['latent_dist'].mean + latents = latents * 0.18215 + return latents + + @torch.no_grad() + def init_prompt(self, prompt: str): + uncond_input = self.model.tokenizer( + [""], padding="max_length", max_length=self.model.tokenizer.model_max_length, + return_tensors="pt" + ) + uncond_embeddings = self.model.text_encoder(uncond_input.input_ids.to(self.model.device))[0] + text_input = self.model.tokenizer( + [prompt], + padding="max_length", + max_length=self.model.tokenizer.model_max_length, + truncation=True, + return_tensors="pt", + ) + text_embeddings = self.model.text_encoder(text_input.input_ids.to(self.model.device))[0] + self.context = torch.cat([uncond_embeddings, text_embeddings]) + self.prompt = prompt + + @torch.no_grad() + def ddim_loop(self, latent): + uncond_embeddings, cond_embeddings = self.context.chunk(2) + all_latent = [latent] + latent = latent.clone().detach() + for i in range(NUM_DDIM_STEPS): + t = self.model.scheduler.timesteps[len(self.model.scheduler.timesteps) - i - 1] + noise_pred = self.get_noise_pred_single(latent, t, cond_embeddings) + latent = self.next_step(noise_pred, t, latent) + all_latent.append(latent) + return all_latent + + @property + def scheduler(self): + return self.model.scheduler + + @torch.no_grad() + def ddim_inversion(self, image): + latent = self.image2latent(image) + image_rec = self.latent2image(latent) + ddim_latents = self.ddim_loop(latent) + return image_rec, ddim_latents + + def null_optimization(self, latents, num_inner_steps, epsilon): + uncond_embeddings, cond_embeddings = self.context.chunk(2) + uncond_embeddings_list = [] + latent_cur = latents[-1] + bar = tqdm(total=num_inner_steps * NUM_DDIM_STEPS) + for i in range(NUM_DDIM_STEPS): + uncond_embeddings = uncond_embeddings.clone().detach() + uncond_embeddings.requires_grad = True + optimizer = Adam([uncond_embeddings], lr=1e-2 * (1. - i / 100.)) + latent_prev = latents[len(latents) - i - 2] + t = self.model.scheduler.timesteps[i] + with torch.no_grad(): + noise_pred_cond = self.get_noise_pred_single(latent_cur, t, cond_embeddings) + for j in range(num_inner_steps): + noise_pred_uncond = self.get_noise_pred_single(latent_cur, t, uncond_embeddings) + noise_pred = noise_pred_uncond + GUIDANCE_SCALE * (noise_pred_cond - noise_pred_uncond) + latents_prev_rec = self.prev_step(noise_pred, t, latent_cur) + loss = nnf.mse_loss(latents_prev_rec, latent_prev) + optimizer.zero_grad() + loss.backward() + optimizer.step() + loss_item = loss.item() + bar.update() + if loss_item < epsilon + i * 2e-5: + break + for j in range(j + 1, num_inner_steps): + bar.update() + uncond_embeddings_list.append(uncond_embeddings[:1].detach()) + with torch.no_grad(): + context = torch.cat([uncond_embeddings, cond_embeddings]) + latent_cur = self.get_noise_pred(latent_cur, t, False, context) + bar.close() + return uncond_embeddings_list + + def invert(self, image_path: str, prompt: str, offsets=(0,0,0,0), num_inner_steps=10, early_stop_epsilon=1e-5, verbose=False): + self.init_prompt(prompt) + image_gt = load_512(image_path, *offsets) + if verbose: + print("DDIM inversion...") + image_rec, ddim_latents = self.ddim_inversion(image_gt) + + uncond_embeddings = None + # if verbose: + # print("Null-text optimization...") + # uncond_embeddings = self.null_optimization(ddim_latents, num_inner_steps, early_stop_epsilon) + return (image_gt, image_rec), ddim_latents[-1], uncond_embeddings + + + def __init__(self, model): + scheduler = DDIMScheduler(beta_start=0.00085, beta_end=0.012, beta_schedule="scaled_linear", clip_sample=False, + set_alpha_to_one=False) + self.model = model + self.tokenizer = self.model.tokenizer + self.model.scheduler.set_timesteps(NUM_DDIM_STEPS) + self.prompt = None + self.context = None + +null_inversion = NullInversion(ldm_stable) + + +# %% [markdown] +# ## Infernce Code + +# %% +@torch.no_grad() +def text2image_ldm_stable( + model, + prompt: List[str], + controller, + num_inference_steps: int = 50, + guidance_scale: Optional[float] = 7.5, + generator: Optional[torch.Generator] = None, + latent: Optional[torch.FloatTensor] = None, + uncond_embeddings=None, + start_time=50, + return_type='image' +): + batch_size = len(prompt) + height = width = 512 + + text_input = model.tokenizer( + prompt, + padding="max_length", + max_length=model.tokenizer.model_max_length, + truncation=True, + return_tensors="pt", + ) + text_embeddings = model.text_encoder(text_input.input_ids.to(model.device))[0] + max_length = text_input.input_ids.shape[-1] + if uncond_embeddings is None: + uncond_input = model.tokenizer( + [""] * batch_size, padding="max_length", max_length=max_length, return_tensors="pt" + ) + uncond_embeddings_ = model.text_encoder(uncond_input.input_ids.to(model.device))[0] + else: + uncond_embeddings_ = None + + latent, latents = ptp_utils.init_latent(latent, model, height, width, generator, batch_size) + model.scheduler.set_timesteps(num_inference_steps) + for i, t in enumerate(tqdm(model.scheduler.timesteps[-start_time:])): + if uncond_embeddings_ is None: + context = torch.cat([uncond_embeddings[i].expand(*text_embeddings.shape), text_embeddings]) + else: + context = torch.cat([uncond_embeddings_, text_embeddings]) + latents = ptp_utils.diffusion_step(model, controller, latents, context, t, guidance_scale, low_resource=False) + + if return_type == 'image': + image = ptp_utils.latent2image(model.vae, latents) + else: + image = latents + return image, latent + + + +# def run_and_display(prompts, latent=None, run_baseline=False, generator=None, uncond_embeddings=None, verbose=True): +# images, latent = run_and_display(prompts, latent=latent, run_baseline=False, generator=generator) +# if verbose: +# ptp_utils.view_images(images) +# return images, x_t + +class EmptyControl: + + + def step_callback(self, x_t): + return x_t + + def between_steps(self): + return + + def __call__(self, attn, is_cross: bool, place_in_unet: str): + return attn + +def run_and_display(prompts, controller, latent=None, run_baseline=False, generator=None, uncond_embeddings=None, verbose=True): + if run_baseline: + print("w.o. prompt-to-prompt") + images, latent = run_and_display(prompts, EmptyControl(), latent=latent, run_baseline=False, generator=generator) + print("with prompt-to-prompt") + images, x_t = text2image_ldm_stable(ldm_stable, prompts, controller, latent=latent, num_inference_steps=NUM_DDIM_STEPS, guidance_scale=GUIDANCE_SCALE, generator=generator, uncond_embeddings=uncond_embeddings) + if verbose: + ptp_utils.view_images(images) + return images, x_t + +# %% +image_path = "../data/dragon_statue_1/image.png" +prompt = "A high-resolution DSLR image of a grey dragon statue" +offsets = (0, 0, 0, 0) +img = load_512(image_path, *offsets) +ptp_utils.view_images(img) + +(image_gt, image_enc), x_t, uncond_embeddings = null_inversion.invert(image_path, prompt, offsets=offsets, verbose=True) + +prompts = [prompt] +image_inv, x_t = run_and_display(prompts, EmptyControl(), run_baseline=False, latent=x_t, uncond_embeddings=uncond_embeddings, verbose=False) +print("showing from left to right: the ground truth image, the vq-autoencoder reconstruction, the null-text inverted image") +ptp_utils.view_images([image_gt, image_enc, image_inv[0]]) \ No newline at end of file diff --git a/textual-inversion/null_text_w_ptp.ipynb b/textual-inversion/null_text_w_ptp.ipynb new file mode 100644 index 0000000..e7ab9f1 --- /dev/null +++ b/textual-inversion/null_text_w_ptp.ipynb @@ -0,0 +1,1470 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "bcafe28c-9f59-4d96-b52f-3e3f45a16c3a", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "## Copyright 2022 Google LLC. Double-click for license information." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "a952f9ab-ed6f-4e99-8304-99a3716734b5", + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "# Copyright 2022 Google LLC\n", + "#\n", + "# Licensed under the Apache License, Version 2.0 (the \"License\");\n", + "# you may not use this file except in compliance with the License.\n", + "# You may obtain a copy of the License at\n", + "#\n", + "# http://www.apache.org/licenses/LICENSE-2.0\n", + "#\n", + "# Unless required by applicable law or agreed to in writing, software\n", + "# distributed under the License is distributed on an \"AS IS\" BASIS,\n", + "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n", + "# See the License for the specific language governing permissions and\n", + "# limitations under the License." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "ed9ffa91", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"1\"" + ] + }, + { + "cell_type": "markdown", + "id": "6d2b343b-1c90-4747-a753-71eb7071a289", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "# Null-text inversion + Editing with Prompt-to-Prompt" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "7b1b6199-9dfe-4055-8a84-66ff4bfa8901", + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/qiang/anaconda3/envs/realfusion/lib/python3.8/site-packages/scipy/__init__.py:146: UserWarning: A NumPy version >=1.16.5 and <1.23.0 is required for this version of SciPy (detected version 1.24.2\n", + " warnings.warn(f\"A NumPy version >={np_minversion} and <{np_maxversion}\"\n" + ] + } + ], + "source": [ + "from typing import Optional, Union, Tuple, List, Callable, Dict\n", + "from tqdm.notebook import tqdm\n", + "import torch\n", + "from diffusers import StableDiffusionPipeline, DDIMScheduler\n", + "import torch.nn.functional as nnf\n", + "import numpy as np\n", + "import abc\n", + "import ptp_utils\n", + "import seq_aligner\n", + "import shutil\n", + "from torch.optim.adam import Adam\n", + "from PIL import Image" + ] + }, + { + "cell_type": "markdown", + "id": "7c6a4bd1-3130-408b-ae2d-a166b9f19cb7", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "For loading the Stable Diffusion using Diffusers, follow the instuctions https://huggingface.co/blog/stable_diffusion and update MY_TOKEN with your token." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "7558a4b4-fec6-4bd2-9c8f-139809b1a1a1", + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Fetching 13 files: 100%|██████████| 13/13 [00:00<00:00, 76581.39it/s]\n", + "/home/qiang/anaconda3/envs/realfusion/lib/python3.8/site-packages/transformers/models/clip/feature_extraction_clip.py:28: FutureWarning: The class CLIPFeatureExtractor is deprecated and will be removed in version 5 of Transformers. Please use CLIPImageProcessor instead.\n", + " warnings.warn(\n", + "/home/qiang/anaconda3/envs/realfusion/lib/python3.8/site-packages/diffusers/pipelines/stable_diffusion/pipeline_stable_diffusion.py:106: FutureWarning: The configuration file of this scheduler: DDIMScheduler {\n", + " \"_class_name\": \"DDIMScheduler\",\n", + " \"_diffusers_version\": \"0.14.0\",\n", + " \"beta_end\": 0.012,\n", + " \"beta_schedule\": \"scaled_linear\",\n", + " \"beta_start\": 0.00085,\n", + " \"clip_sample\": false,\n", + " \"num_train_timesteps\": 1000,\n", + " \"prediction_type\": \"epsilon\",\n", + " \"set_alpha_to_one\": false,\n", + " \"steps_offset\": 0,\n", + " \"trained_betas\": null\n", + "}\n", + " is outdated. `steps_offset` should be set to 1 instead of 0. Please make sure to update the config accordingly as leaving `steps_offset` might led to incorrect results in future versions. If you have downloaded this checkpoint from the Hugging Face Hub, it would be very nice if you could open a Pull request for the `scheduler/scheduler_config.json` file\n", + " deprecate(\"steps_offset!=1\", \"1.0.0\", deprecation_message, standard_warn=False)\n" + ] + } + ], + "source": [ + "scheduler = DDIMScheduler(beta_start=0.00085, beta_end=0.012, beta_schedule=\"scaled_linear\", clip_sample=False, set_alpha_to_one=False)\n", + "MY_TOKEN = ''\n", + "LOW_RESOURCE = False \n", + "NUM_DDIM_STEPS = 50\n", + "GUIDANCE_SCALE = 7.5\n", + "MAX_NUM_WORDS = 77\n", + "device = torch.device('cuda:0') if torch.cuda.is_available() else torch.device('cpu')\n", + "ldm_stable = StableDiffusionPipeline.from_pretrained(\"stabilityai/stable-diffusion-2-1-base\", use_auth_token=MY_TOKEN, scheduler=scheduler).to(device)\n", + "try:\n", + " ldm_stable.disable_xformers_memory_efficient_attention()\n", + "except AttributeError:\n", + " print(\"Attribute disable_xformers_memory_efficient_attention() is missing\")\n", + "tokenizer = ldm_stable.tokenizer" + ] + }, + { + "cell_type": "markdown", + "id": "01422991-cafe-4cf0-8406-66f052a75d9b", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "## Prompt-to-Prompt code" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "dc083590-15de-4216-8d8d-50336f9f1d34", + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "\n", + "class LocalBlend:\n", + " \n", + " def get_mask(self, maps, alpha, use_pool):\n", + " k = 1\n", + " maps = (maps * alpha).sum(-1).mean(1)\n", + " if use_pool:\n", + " maps = nnf.max_pool2d(maps, (k * 2 + 1, k * 2 +1), (1, 1), padding=(k, k))\n", + " mask = nnf.interpolate(maps, size=(x_t.shape[2:]))\n", + " mask = mask / mask.max(2, keepdims=True)[0].max(3, keepdims=True)[0]\n", + " mask = mask.gt(self.th[1-int(use_pool)])\n", + " mask = mask[:1] + mask\n", + " return mask\n", + " \n", + " def __call__(self, x_t, attention_store):\n", + " self.counter += 1\n", + " if self.counter > self.start_blend:\n", + " \n", + " maps = attention_store[\"down_cross\"][2:4] + attention_store[\"up_cross\"][:3]\n", + " maps = [item.reshape(self.alpha_layers.shape[0], -1, 1, 16, 16, MAX_NUM_WORDS) for item in maps]\n", + " maps = torch.cat(maps, dim=1)\n", + " mask = self.get_mask(maps, self.alpha_layers, True)\n", + " if self.substruct_layers is not None:\n", + " maps_sub = ~self.get_mask(maps, self.substruct_layers, False)\n", + " mask = mask * maps_sub\n", + " mask = mask.float()\n", + " x_t = x_t[:1] + mask * (x_t - x_t[:1])\n", + " return x_t\n", + " \n", + " def __init__(self, prompts: List[str], words: [List[List[str]]], substruct_words=None, start_blend=0.2, th=(.3, .3)):\n", + " alpha_layers = torch.zeros(len(prompts), 1, 1, 1, 1, MAX_NUM_WORDS)\n", + " for i, (prompt, words_) in enumerate(zip(prompts, words)):\n", + " if type(words_) is str:\n", + " words_ = [words_]\n", + " for word in words_:\n", + " ind = ptp_utils.get_word_inds(prompt, word, tokenizer)\n", + " alpha_layers[i, :, :, :, :, ind] = 1\n", + " \n", + " if substruct_words is not None:\n", + " substruct_layers = torch.zeros(len(prompts), 1, 1, 1, 1, MAX_NUM_WORDS)\n", + " for i, (prompt, words_) in enumerate(zip(prompts, substruct_words)):\n", + " if type(words_) is str:\n", + " words_ = [words_]\n", + " for word in words_:\n", + " ind = ptp_utils.get_word_inds(prompt, word, tokenizer)\n", + " substruct_layers[i, :, :, :, :, ind] = 1\n", + " self.substruct_layers = substruct_layers.to(device)\n", + " else:\n", + " self.substruct_layers = None\n", + " self.alpha_layers = alpha_layers.to(device)\n", + " self.start_blend = int(start_blend * NUM_DDIM_STEPS)\n", + " self.counter = 0 \n", + " self.th=th\n", + "\n", + "\n", + " \n", + " \n", + "class EmptyControl:\n", + " \n", + " \n", + " def step_callback(self, x_t):\n", + " return x_t\n", + " \n", + " def between_steps(self):\n", + " return\n", + " \n", + " def __call__(self, attn, is_cross: bool, place_in_unet: str):\n", + " return attn\n", + "\n", + " \n", + "class AttentionControl(abc.ABC):\n", + " \n", + " def step_callback(self, x_t):\n", + " return x_t\n", + " \n", + " def between_steps(self):\n", + " return\n", + " \n", + " @property\n", + " def num_uncond_att_layers(self):\n", + " return self.num_att_layers if LOW_RESOURCE else 0\n", + " \n", + " @abc.abstractmethod\n", + " def forward (self, attn, is_cross: bool, place_in_unet: str):\n", + " raise NotImplementedError\n", + "\n", + " def __call__(self, attn, is_cross: bool, place_in_unet: str):\n", + " if self.cur_att_layer >= self.num_uncond_att_layers:\n", + " if LOW_RESOURCE:\n", + " attn = self.forward(attn, is_cross, place_in_unet)\n", + " else:\n", + " h = attn.shape[0]\n", + " attn[h // 2:] = self.forward(attn[h // 2:], is_cross, place_in_unet)\n", + " self.cur_att_layer += 1\n", + " if self.cur_att_layer == self.num_att_layers + self.num_uncond_att_layers:\n", + " self.cur_att_layer = 0\n", + " self.cur_step += 1\n", + " self.between_steps()\n", + " return attn\n", + " \n", + " def reset(self):\n", + " self.cur_step = 0\n", + " self.cur_att_layer = 0\n", + "\n", + " def __init__(self):\n", + " self.cur_step = 0\n", + " self.num_att_layers = -1\n", + " self.cur_att_layer = 0\n", + "\n", + "class SpatialReplace(EmptyControl):\n", + " \n", + " def step_callback(self, x_t):\n", + " if self.cur_step < self.stop_inject:\n", + " b = x_t.shape[0]\n", + " x_t = x_t[:1].expand(b, *x_t.shape[1:])\n", + " return x_t\n", + "\n", + " def __init__(self, stop_inject: float):\n", + " super(SpatialReplace, self).__init__()\n", + " self.stop_inject = int((1 - stop_inject) * NUM_DDIM_STEPS)\n", + " \n", + "\n", + "class AttentionStore(AttentionControl):\n", + "\n", + " @staticmethod\n", + " def get_empty_store():\n", + " return {\"down_cross\": [], \"mid_cross\": [], \"up_cross\": [],\n", + " \"down_self\": [], \"mid_self\": [], \"up_self\": []}\n", + "\n", + " def forward(self, attn, is_cross: bool, place_in_unet: str):\n", + " key = f\"{place_in_unet}_{'cross' if is_cross else 'self'}\"\n", + " if attn.shape[1] <= 32 ** 2: # avoid memory overhead\n", + " self.step_store[key].append(attn)\n", + " return attn\n", + "\n", + " def between_steps(self):\n", + " if len(self.attention_store) == 0:\n", + " self.attention_store = self.step_store\n", + " else:\n", + " for key in self.attention_store:\n", + " for i in range(len(self.attention_store[key])):\n", + " self.attention_store[key][i] += self.step_store[key][i]\n", + " self.step_store = self.get_empty_store()\n", + "\n", + " def get_average_attention(self):\n", + " average_attention = {key: [item / self.cur_step for item in self.attention_store[key]] for key in self.attention_store}\n", + " return average_attention\n", + "\n", + "\n", + " def reset(self):\n", + " super(AttentionStore, self).reset()\n", + " self.step_store = self.get_empty_store()\n", + " self.attention_store = {}\n", + "\n", + " def __init__(self):\n", + " super(AttentionStore, self).__init__()\n", + " self.step_store = self.get_empty_store()\n", + " self.attention_store = {}\n", + "\n", + " \n", + "class AttentionControlEdit(AttentionStore, abc.ABC):\n", + " \n", + " def step_callback(self, x_t):\n", + " if self.local_blend is not None:\n", + " x_t = self.local_blend(x_t, self.attention_store)\n", + " return x_t\n", + " \n", + " def replace_self_attention(self, attn_base, att_replace, place_in_unet):\n", + " if att_replace.shape[2] <= 32 ** 2:\n", + " attn_base = attn_base.unsqueeze(0).expand(att_replace.shape[0], *attn_base.shape)\n", + " return attn_base\n", + " else:\n", + " return att_replace\n", + " \n", + " @abc.abstractmethod\n", + " def replace_cross_attention(self, attn_base, att_replace):\n", + " raise NotImplementedError\n", + " \n", + " def forward(self, attn, is_cross: bool, place_in_unet: str):\n", + " super(AttentionControlEdit, self).forward(attn, is_cross, place_in_unet)\n", + " if is_cross or (self.num_self_replace[0] <= self.cur_step < self.num_self_replace[1]):\n", + " h = attn.shape[0] // (self.batch_size)\n", + " attn = attn.reshape(self.batch_size, h, *attn.shape[1:])\n", + " attn_base, attn_repalce = attn[0], attn[1:]\n", + " if is_cross:\n", + " alpha_words = self.cross_replace_alpha[self.cur_step]\n", + " attn_repalce_new = self.replace_cross_attention(attn_base, attn_repalce) * alpha_words + (1 - alpha_words) * attn_repalce\n", + " attn[1:] = attn_repalce_new\n", + " else:\n", + " attn[1:] = self.replace_self_attention(attn_base, attn_repalce, place_in_unet)\n", + " attn = attn.reshape(self.batch_size * h, *attn.shape[2:])\n", + " return attn\n", + " \n", + " def __init__(self, prompts, num_steps: int,\n", + " cross_replace_steps: Union[float, Tuple[float, float], Dict[str, Tuple[float, float]]],\n", + " self_replace_steps: Union[float, Tuple[float, float]],\n", + " local_blend: Optional[LocalBlend]):\n", + " super(AttentionControlEdit, self).__init__()\n", + " self.batch_size = len(prompts)\n", + " self.cross_replace_alpha = ptp_utils.get_time_words_attention_alpha(prompts, num_steps, cross_replace_steps, tokenizer).to(device)\n", + " if type(self_replace_steps) is float:\n", + " self_replace_steps = 0, self_replace_steps\n", + " self.num_self_replace = int(num_steps * self_replace_steps[0]), int(num_steps * self_replace_steps[1])\n", + " self.local_blend = local_blend\n", + "\n", + "class AttentionReplace(AttentionControlEdit):\n", + "\n", + " def replace_cross_attention(self, attn_base, att_replace):\n", + " return torch.einsum('hpw,bwn->bhpn', attn_base, self.mapper)\n", + " \n", + " def __init__(self, prompts, num_steps: int, cross_replace_steps: float, self_replace_steps: float,\n", + " local_blend: Optional[LocalBlend] = None):\n", + " super(AttentionReplace, self).__init__(prompts, num_steps, cross_replace_steps, self_replace_steps, local_blend)\n", + " self.mapper = seq_aligner.get_replacement_mapper(prompts, tokenizer).to(device)\n", + " \n", + "\n", + "class AttentionRefine(AttentionControlEdit):\n", + "\n", + " def replace_cross_attention(self, attn_base, att_replace):\n", + " attn_base_replace = attn_base[:, :, self.mapper].permute(2, 0, 1, 3)\n", + " attn_replace = attn_base_replace * self.alphas + att_replace * (1 - self.alphas)\n", + " # attn_replace = attn_replace / attn_replace.sum(-1, keepdims=True)\n", + " return attn_replace\n", + "\n", + " def __init__(self, prompts, num_steps: int, cross_replace_steps: float, self_replace_steps: float,\n", + " local_blend: Optional[LocalBlend] = None):\n", + " super(AttentionRefine, self).__init__(prompts, num_steps, cross_replace_steps, self_replace_steps, local_blend)\n", + " self.mapper, alphas = seq_aligner.get_refinement_mapper(prompts, tokenizer)\n", + " self.mapper, alphas = self.mapper.to(device), alphas.to(device)\n", + " self.alphas = alphas.reshape(alphas.shape[0], 1, 1, alphas.shape[1])\n", + "\n", + "\n", + "class AttentionReweight(AttentionControlEdit):\n", + "\n", + " def replace_cross_attention(self, attn_base, att_replace):\n", + " if self.prev_controller is not None:\n", + " attn_base = self.prev_controller.replace_cross_attention(attn_base, att_replace)\n", + " attn_replace = attn_base[None, :, :, :] * self.equalizer[:, None, None, :]\n", + " # attn_replace = attn_replace / attn_replace.sum(-1, keepdims=True)\n", + " return attn_replace\n", + "\n", + " def __init__(self, prompts, num_steps: int, cross_replace_steps: float, self_replace_steps: float, equalizer,\n", + " local_blend: Optional[LocalBlend] = None, controller: Optional[AttentionControlEdit] = None):\n", + " super(AttentionReweight, self).__init__(prompts, num_steps, cross_replace_steps, self_replace_steps, local_blend)\n", + " self.equalizer = equalizer.to(device)\n", + " self.prev_controller = controller\n", + "\n", + "\n", + "def get_equalizer(text: str, word_select: Union[int, Tuple[int, ...]], values: Union[List[float],\n", + " Tuple[float, ...]]):\n", + " if type(word_select) is int or type(word_select) is str:\n", + " word_select = (word_select,)\n", + " equalizer = torch.ones(1, 77)\n", + " \n", + " for word, val in zip(word_select, values):\n", + " inds = ptp_utils.get_word_inds(text, word, tokenizer)\n", + " equalizer[:, inds] = val\n", + " return equalizer\n", + "\n", + "def aggregate_attention(attention_store: AttentionStore, res: int, from_where: List[str], is_cross: bool, select: int):\n", + " out = []\n", + " attention_maps = attention_store.get_average_attention()\n", + " num_pixels = res ** 2\n", + " for location in from_where:\n", + " for item in attention_maps[f\"{location}_{'cross' if is_cross else 'self'}\"]:\n", + " if item.shape[1] == num_pixels:\n", + " cross_maps = item.reshape(len(prompts), -1, res, res, item.shape[-1])[select]\n", + " out.append(cross_maps)\n", + " out = torch.cat(out, dim=0)\n", + " out = out.sum(0) / out.shape[0]\n", + " return out.cpu()\n", + "\n", + "\n", + "def make_controller(prompts: List[str], is_replace_controller: bool, cross_replace_steps: Dict[str, float], self_replace_steps: float, blend_words=None, equilizer_params=None) -> AttentionControlEdit:\n", + " if blend_words is None:\n", + " lb = None\n", + " else:\n", + " lb = LocalBlend(prompts, blend_word)\n", + " if is_replace_controller:\n", + " controller = AttentionReplace(prompts, NUM_DDIM_STEPS, cross_replace_steps=cross_replace_steps, self_replace_steps=self_replace_steps, local_blend=lb)\n", + " else:\n", + " controller = AttentionRefine(prompts, NUM_DDIM_STEPS, cross_replace_steps=cross_replace_steps, self_replace_steps=self_replace_steps, local_blend=lb)\n", + " if equilizer_params is not None:\n", + " eq = get_equalizer(prompts[1], equilizer_params[\"words\"], equilizer_params[\"values\"])\n", + " controller = AttentionReweight(prompts, NUM_DDIM_STEPS, cross_replace_steps=cross_replace_steps,\n", + " self_replace_steps=self_replace_steps, equalizer=eq, local_blend=lb, controller=controller)\n", + " return controller\n", + "\n", + "\n", + "def show_cross_attention(attention_store: AttentionStore, res: int, from_where: List[str], select: int = 0):\n", + " tokens = tokenizer.encode(prompts[select])\n", + " decoder = tokenizer.decode\n", + " attention_maps = aggregate_attention(attention_store, res, from_where, True, select)\n", + " images = []\n", + " for i in range(len(tokens)):\n", + " image = attention_maps[:, :, i]\n", + " image = 255 * image / image.max()\n", + " image = image.unsqueeze(-1).expand(*image.shape, 3)\n", + " image = image.numpy().astype(np.uint8)\n", + " image = np.array(Image.fromarray(image).resize((256, 256)))\n", + " image = ptp_utils.text_under_image(image, decoder(int(tokens[i])))\n", + " images.append(image)\n", + " ptp_utils.view_images(np.stack(images, axis=0))\n", + " \n", + "\n", + "def show_self_attention_comp(attention_store: AttentionStore, res: int, from_where: List[str],\n", + " max_com=10, select: int = 0):\n", + " attention_maps = aggregate_attention(attention_store, res, from_where, False, select).numpy().reshape((res ** 2, res ** 2))\n", + " u, s, vh = np.linalg.svd(attention_maps - np.mean(attention_maps, axis=1, keepdims=True))\n", + " images = []\n", + " for i in range(max_com):\n", + " image = vh[i].reshape(res, res)\n", + " image = image - image.min()\n", + " image = 255 * image / image.max()\n", + " image = np.repeat(np.expand_dims(image, axis=2), 3, axis=2).astype(np.uint8)\n", + " image = Image.fromarray(image).resize((256, 256))\n", + " image = np.array(image)\n", + " images.append(image)\n", + " ptp_utils.view_images(np.concatenate(images, axis=1))" + ] + }, + { + "cell_type": "markdown", + "id": "a914bda0-c191-4db6-b891-101cde74ddaf", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "## Null Text Inversion code" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "c442992d-8156-4dfc-a2a5-1fbf8bedb4b2", + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "def load_512(image_path, left=0, right=0, top=0, bottom=0):\n", + " if type(image_path) is str:\n", + " image = np.array(Image.open(image_path))[:, :, :3]\n", + " else:\n", + " image = image_path\n", + " h, w, c = image.shape\n", + " left = min(left, w-1)\n", + " right = min(right, w - left - 1)\n", + " top = min(top, h - left - 1)\n", + " bottom = min(bottom, h - top - 1)\n", + " image = image[top:h-bottom, left:w-right]\n", + " h, w, c = image.shape\n", + " if h < w:\n", + " offset = (w - h) // 2\n", + " image = image[:, offset:offset + h]\n", + " elif w < h:\n", + " offset = (h - w) // 2\n", + " image = image[offset:offset + w]\n", + " image = np.array(Image.fromarray(image).resize((512, 512)))\n", + " return image\n", + "\n", + "\n", + "class NullInversion:\n", + " \n", + " def prev_step(self, model_output: Union[torch.FloatTensor, np.ndarray], timestep: int, sample: Union[torch.FloatTensor, np.ndarray]):\n", + " prev_timestep = timestep - self.scheduler.config.num_train_timesteps // self.scheduler.num_inference_steps\n", + " alpha_prod_t = self.scheduler.alphas_cumprod[timestep]\n", + " alpha_prod_t_prev = self.scheduler.alphas_cumprod[prev_timestep] if prev_timestep >= 0 else self.scheduler.final_alpha_cumprod\n", + " beta_prod_t = 1 - alpha_prod_t\n", + " pred_original_sample = (sample - beta_prod_t ** 0.5 * model_output) / alpha_prod_t ** 0.5\n", + " pred_sample_direction = (1 - alpha_prod_t_prev) ** 0.5 * model_output\n", + " prev_sample = alpha_prod_t_prev ** 0.5 * pred_original_sample + pred_sample_direction\n", + " return prev_sample\n", + " \n", + " def next_step(self, model_output: Union[torch.FloatTensor, np.ndarray], timestep: int, sample: Union[torch.FloatTensor, np.ndarray]):\n", + " timestep, next_timestep = min(timestep - self.scheduler.config.num_train_timesteps // self.scheduler.num_inference_steps, 999), timestep\n", + " alpha_prod_t = self.scheduler.alphas_cumprod[timestep] if timestep >= 0 else self.scheduler.final_alpha_cumprod\n", + " alpha_prod_t_next = self.scheduler.alphas_cumprod[next_timestep]\n", + " beta_prod_t = 1 - alpha_prod_t\n", + " next_original_sample = (sample - beta_prod_t ** 0.5 * model_output) / alpha_prod_t ** 0.5\n", + " next_sample_direction = (1 - alpha_prod_t_next) ** 0.5 * model_output\n", + " next_sample = alpha_prod_t_next ** 0.5 * next_original_sample + next_sample_direction\n", + " return next_sample\n", + " \n", + " def get_noise_pred_single(self, latents, t, context):\n", + " noise_pred = self.model.unet(latents, t, encoder_hidden_states=context)[\"sample\"]\n", + " return noise_pred\n", + "\n", + " def get_noise_pred(self, latents, t, is_forward=True, context=None):\n", + " latents_input = torch.cat([latents] * 2)\n", + " if context is None:\n", + " context = self.context\n", + " guidance_scale = 1 if is_forward else GUIDANCE_SCALE\n", + " noise_pred = self.model.unet(latents_input, t, encoder_hidden_states=context)[\"sample\"]\n", + " noise_pred_uncond, noise_prediction_text = noise_pred.chunk(2)\n", + " noise_pred = noise_pred_uncond + guidance_scale * (noise_prediction_text - noise_pred_uncond)\n", + " if is_forward:\n", + " latents = self.next_step(noise_pred, t, latents)\n", + " else:\n", + " latents = self.prev_step(noise_pred, t, latents)\n", + " return latents\n", + "\n", + " @torch.no_grad()\n", + " def latent2image(self, latents, return_type='np'):\n", + " latents = 1 / 0.18215 * latents.detach()\n", + " image = self.model.vae.decode(latents)['sample']\n", + " if return_type == 'np':\n", + " image = (image / 2 + 0.5).clamp(0, 1)\n", + " image = image.cpu().permute(0, 2, 3, 1).numpy()[0]\n", + " image = (image * 255).astype(np.uint8)\n", + " return image\n", + "\n", + " @torch.no_grad()\n", + " def image2latent(self, image):\n", + " with torch.no_grad():\n", + " if type(image) is Image:\n", + " image = np.array(image)\n", + " if type(image) is torch.Tensor and image.dim() == 4:\n", + " latents = image\n", + " else:\n", + " image = torch.from_numpy(image).float() / 127.5 - 1\n", + " image = image.permute(2, 0, 1).unsqueeze(0).to(device)\n", + " latents = self.model.vae.encode(image)['latent_dist'].mean\n", + " latents = latents * 0.18215\n", + " return latents\n", + "\n", + " @torch.no_grad()\n", + " def init_prompt(self, prompt: str):\n", + " uncond_input = self.model.tokenizer(\n", + " [\"\"], padding=\"max_length\", max_length=self.model.tokenizer.model_max_length,\n", + " return_tensors=\"pt\"\n", + " )\n", + " uncond_embeddings = self.model.text_encoder(uncond_input.input_ids.to(self.model.device))[0]\n", + " text_input = self.model.tokenizer(\n", + " [prompt],\n", + " padding=\"max_length\",\n", + " max_length=self.model.tokenizer.model_max_length,\n", + " truncation=True,\n", + " return_tensors=\"pt\",\n", + " )\n", + " text_embeddings = self.model.text_encoder(text_input.input_ids.to(self.model.device))[0]\n", + " self.context = torch.cat([uncond_embeddings, text_embeddings])\n", + " self.prompt = prompt\n", + "\n", + " @torch.no_grad()\n", + " def ddim_loop(self, latent):\n", + " uncond_embeddings, cond_embeddings = self.context.chunk(2)\n", + " all_latent = [latent]\n", + " latent = latent.clone().detach()\n", + " for i in range(NUM_DDIM_STEPS):\n", + " t = self.model.scheduler.timesteps[len(self.model.scheduler.timesteps) - i - 1]\n", + " noise_pred = self.get_noise_pred_single(latent, t, cond_embeddings)\n", + " latent = self.next_step(noise_pred, t, latent)\n", + " all_latent.append(latent)\n", + " return all_latent\n", + "\n", + " @property\n", + " def scheduler(self):\n", + " return self.model.scheduler\n", + "\n", + " @torch.no_grad()\n", + " def ddim_inversion(self, image):\n", + " latent = self.image2latent(image)\n", + " image_rec = self.latent2image(latent)\n", + " ddim_latents = self.ddim_loop(latent)\n", + " return image_rec, ddim_latents\n", + "\n", + " def null_optimization(self, latents, num_inner_steps, epsilon):\n", + " uncond_embeddings, cond_embeddings = self.context.chunk(2)\n", + " uncond_embeddings_list = []\n", + " latent_cur = latents[-1]\n", + " bar = tqdm(total=num_inner_steps * NUM_DDIM_STEPS)\n", + " for i in range(NUM_DDIM_STEPS):\n", + " uncond_embeddings = uncond_embeddings.clone().detach()\n", + " uncond_embeddings.requires_grad = True\n", + " optimizer = Adam([uncond_embeddings], lr=1e-2 * (1. - i / 100.))\n", + " latent_prev = latents[len(latents) - i - 2]\n", + " t = self.model.scheduler.timesteps[i]\n", + " with torch.no_grad():\n", + " noise_pred_cond = self.get_noise_pred_single(latent_cur, t, cond_embeddings)\n", + " for j in range(num_inner_steps):\n", + " noise_pred_uncond = self.get_noise_pred_single(latent_cur, t, uncond_embeddings)\n", + " noise_pred = noise_pred_uncond + GUIDANCE_SCALE * (noise_pred_cond - noise_pred_uncond)\n", + " latents_prev_rec = self.prev_step(noise_pred, t, latent_cur)\n", + " loss = nnf.mse_loss(latents_prev_rec, latent_prev)\n", + " optimizer.zero_grad()\n", + " loss.backward()\n", + " optimizer.step()\n", + " loss_item = loss.item()\n", + " bar.update()\n", + " if loss_item < epsilon + i * 2e-5:\n", + " break\n", + " for j in range(j + 1, num_inner_steps):\n", + " bar.update()\n", + " uncond_embeddings_list.append(uncond_embeddings[:1].detach())\n", + " with torch.no_grad():\n", + " context = torch.cat([uncond_embeddings, cond_embeddings])\n", + " latent_cur = self.get_noise_pred(latent_cur, t, False, context)\n", + " bar.close()\n", + " return uncond_embeddings_list\n", + " \n", + " def invert(self, image_path: str, prompt: str, offsets=(0,0,0,0), num_inner_steps=10, early_stop_epsilon=1e-5, verbose=False):\n", + " self.init_prompt(prompt)\n", + " ptp_utils.register_attention_control(self.model, None)\n", + " image_gt = load_512(image_path, *offsets)\n", + " if verbose:\n", + " print(\"DDIM inversion...\")\n", + " image_rec, ddim_latents = self.ddim_inversion(image_gt)\n", + " if verbose:\n", + " print(\"Null-text optimization...\")\n", + " uncond_embeddings = self.null_optimization(ddim_latents, num_inner_steps, early_stop_epsilon)\n", + " return (image_gt, image_rec), ddim_latents[-1], uncond_embeddings\n", + " \n", + " \n", + " def __init__(self, model):\n", + " scheduler = DDIMScheduler(beta_start=0.00085, beta_end=0.012, beta_schedule=\"scaled_linear\", clip_sample=False,\n", + " set_alpha_to_one=False)\n", + " self.model = model\n", + " self.tokenizer = self.model.tokenizer\n", + " self.model.scheduler.set_timesteps(NUM_DDIM_STEPS)\n", + " self.prompt = None\n", + " self.context = None\n", + "\n", + "null_inversion = NullInversion(ldm_stable)\n" + ] + }, + { + "cell_type": "markdown", + "id": "c919e093-998c-4e4c-92a2-dc9517ef8ea4", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "## Infernce Code" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "f9499145-1a2b-4c91-900e-093c0c08043c", + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "@torch.no_grad()\n", + "def text2image_ldm_stable(\n", + " model,\n", + " prompt: List[str],\n", + " controller,\n", + " num_inference_steps: int = 50,\n", + " guidance_scale: Optional[float] = 7.5,\n", + " generator: Optional[torch.Generator] = None,\n", + " latent: Optional[torch.FloatTensor] = None,\n", + " uncond_embeddings=None,\n", + " start_time=50,\n", + " return_type='image'\n", + "):\n", + " batch_size = len(prompt)\n", + " ptp_utils.register_attention_control(model, controller)\n", + " height = width = 512\n", + " \n", + " text_input = model.tokenizer(\n", + " prompt,\n", + " padding=\"max_length\",\n", + " max_length=model.tokenizer.model_max_length,\n", + " truncation=True,\n", + " return_tensors=\"pt\",\n", + " )\n", + " text_embeddings = model.text_encoder(text_input.input_ids.to(model.device))[0]\n", + " max_length = text_input.input_ids.shape[-1]\n", + " if uncond_embeddings is None:\n", + " uncond_input = model.tokenizer(\n", + " [\"\"] * batch_size, padding=\"max_length\", max_length=max_length, return_tensors=\"pt\"\n", + " )\n", + " uncond_embeddings_ = model.text_encoder(uncond_input.input_ids.to(model.device))[0]\n", + " else:\n", + " uncond_embeddings_ = None\n", + "\n", + " latent, latents = ptp_utils.init_latent(latent, model, height, width, generator, batch_size)\n", + " model.scheduler.set_timesteps(num_inference_steps)\n", + " for i, t in enumerate(tqdm(model.scheduler.timesteps[-start_time:])):\n", + " if uncond_embeddings_ is None:\n", + " context = torch.cat([uncond_embeddings[i].expand(*text_embeddings.shape), text_embeddings])\n", + " else:\n", + " context = torch.cat([uncond_embeddings_, text_embeddings])\n", + " latents = ptp_utils.diffusion_step(model, controller, latents, context, t, guidance_scale, low_resource=False)\n", + " \n", + " if return_type == 'image':\n", + " image = ptp_utils.latent2image(model.vae, latents)\n", + " else:\n", + " image = latents\n", + " return image, latent\n", + "\n", + "\n", + "\n", + "# def run_and_display(prompts, controller, latent=None, run_baseline=False, generator=None, uncond_embeddings=None, verbose=True):\n", + "# if run_baseline:\n", + "# print(\"w.o. prompt-to-prompt\")\n", + "# images, latent = run_and_display(prompts, EmptyControl(), latent=latent, run_baseline=False, generator=generator)\n", + "# print(\"with prompt-to-prompt\")\n", + "# images, x_t = text2image_ldm_stable(ldm_stable, prompts, controller, latent=latent, num_inference_steps=NUM_DDIM_STEPS, guidance_scale=GUIDANCE_SCALE, generator=generator, uncond_embeddings=uncond_embeddings)\n", + "# if verbose:\n", + "# ptp_utils.view_images(images)\n", + "# return images, x_t\n", + "def run_and_display(prompts, latent=None, run_baseline=False, generator=None, uncond_embeddings=None, verbose=True):\n", + " images, latent = run_and_display(prompts, EmptyControl(), latent=latent, run_baseline=False, generator=generator)\n", + " if verbose:\n", + " ptp_utils.view_images(images)\n", + " return images" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "6ef5cbc6-2581-415f-b608-67f2e87c32f5", + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "image_path = \"../data/dragon_statue_1/image.png\"\n", + "prompt = \"A high-resolution DSLR image of a grey dragon statue\"\n", + "offsets = (0, 0, 0, 0)\n", + "img = load_512(image_path, *offsets)\n", + "ptp_utils.view_images(img)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "27fd08bb", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DDIM inversion...\n" + ] + }, + { + "data": { + "text/html": [ + "
╭─────────────────────────────── Traceback (most recent call last) ────────────────────────────────╮\n",
+       "│ in <module>:1                                                                                    │\n",
+       "│                                                                                                  │\n",
+       "│ ❱ 1 (image_gt, image_enc), x_t, uncond_embeddings = null_inversion.invert(image_path, prompt     │\n",
+       "│   2                                                                                              │\n",
+       "│   3 print(\"Modify or remove offsets according to your image!\")                                   │\n",
+       "│   4                                                                                              │\n",
+       "│                                                                                                  │\n",
+       "│ in invert:168                                                                                    │\n",
+       "│                                                                                                  │\n",
+       "│   165 │   │   image_gt = load_512(image_path, *offsets)                                          │\n",
+       "│   166 │   │   if verbose:                                                                        │\n",
+       "│   167 │   │   │   print(\"DDIM inversion...\")                                                     │\n",
+       "│ ❱ 168 │   │   image_rec, ddim_latents = self.ddim_inversion(image_gt)                            │\n",
+       "│   169 │   │   if verbose:                                                                        │\n",
+       "│   170 │   │   │   print(\"Null-text optimization...\")                                             │\n",
+       "│   171 │   │   uncond_embeddings = self.null_optimization(ddim_latents, num_inner_steps, early_   │\n",
+       "│                                                                                                  │\n",
+       "│ /home/qiang/anaconda3/envs/realfusion/lib/python3.8/site-packages/torch/autograd/grad_mode.py:27 │\n",
+       "│ in decorate_context                                                                              │\n",
+       "│                                                                                                  │\n",
+       "│    24 │   │   @functools.wraps(func)                                                             │\n",
+       "│    25 │   │   def decorate_context(*args, **kwargs):                                             │\n",
+       "│    26 │   │   │   with self.clone():                                                             │\n",
+       "│ ❱  27 │   │   │   │   return func(*args, **kwargs)                                               │\n",
+       "│    28 │   │   return cast(F, decorate_context)                                                   │\n",
+       "│    29 │                                                                                          │\n",
+       "│    30 │   def _wrap_generator(self, func):                                                       │\n",
+       "│                                                                                                  │\n",
+       "│ in ddim_inversion:125                                                                            │\n",
+       "│                                                                                                  │\n",
+       "│   122 │   def ddim_inversion(self, image):                                                       │\n",
+       "│   123 │   │   latent = self.image2latent(image)                                                  │\n",
+       "│   124 │   │   image_rec = self.latent2image(latent)                                              │\n",
+       "│ ❱ 125 │   │   ddim_latents = self.ddim_loop(latent)                                              │\n",
+       "│   126 │   │   return image_rec, ddim_latents                                                     │\n",
+       "│   127 │                                                                                          │\n",
+       "│   128 │   def null_optimization(self, latents, num_inner_steps, epsilon):                        │\n",
+       "│                                                                                                  │\n",
+       "│ /home/qiang/anaconda3/envs/realfusion/lib/python3.8/site-packages/torch/autograd/grad_mode.py:27 │\n",
+       "│ in decorate_context                                                                              │\n",
+       "│                                                                                                  │\n",
+       "│    24 │   │   @functools.wraps(func)                                                             │\n",
+       "│    25 │   │   def decorate_context(*args, **kwargs):                                             │\n",
+       "│    26 │   │   │   with self.clone():                                                             │\n",
+       "│ ❱  27 │   │   │   │   return func(*args, **kwargs)                                               │\n",
+       "│    28 │   │   return cast(F, decorate_context)                                                   │\n",
+       "│    29 │                                                                                          │\n",
+       "│    30 │   def _wrap_generator(self, func):                                                       │\n",
+       "│                                                                                                  │\n",
+       "│ in ddim_loop:112                                                                                 │\n",
+       "│                                                                                                  │\n",
+       "│   109 │   │   latent = latent.clone().detach()                                                   │\n",
+       "│   110 │   │   for i in range(NUM_DDIM_STEPS):                                                    │\n",
+       "│   111 │   │   │   t = self.model.scheduler.timesteps[len(self.model.scheduler.timesteps) - i -   │\n",
+       "│ ❱ 112 │   │   │   noise_pred = self.get_noise_pred_single(latent, t, cond_embeddings)            │\n",
+       "│   113 │   │   │   latent = self.next_step(noise_pred, t, latent)                                 │\n",
+       "│   114 │   │   │   all_latent.append(latent)                                                      │\n",
+       "│   115 │   │   return all_latent                                                                  │\n",
+       "│                                                                                                  │\n",
+       "│ in get_noise_pred_single:46                                                                      │\n",
+       "│                                                                                                  │\n",
+       "│    43 │   │   return next_sample                                                                 │\n",
+       "│    44 │                                                                                          │\n",
+       "│    45 │   def get_noise_pred_single(self, latents, t, context):                                  │\n",
+       "│ ❱  46 │   │   noise_pred = self.model.unet(latents, t, encoder_hidden_states=context)[\"sample\"   │\n",
+       "│    47 │   │   return noise_pred                                                                  │\n",
+       "│    48 │                                                                                          │\n",
+       "│    49 │   def get_noise_pred(self, latents, t, is_forward=True, context=None):                   │\n",
+       "│                                                                                                  │\n",
+       "│ /home/qiang/anaconda3/envs/realfusion/lib/python3.8/site-packages/torch/nn/modules/module.py:111 │\n",
+       "│ 0 in _call_impl                                                                                  │\n",
+       "│                                                                                                  │\n",
+       "│   1107 │   │   # this function, and just call forward.                                           │\n",
+       "│   1108 │   │   if not (self._backward_hooks or self._forward_hooks or self._forward_pre_hooks o  │\n",
+       "│   1109 │   │   │   │   or _global_forward_hooks or _global_forward_pre_hooks):                   │\n",
+       "│ ❱ 1110 │   │   │   return forward_call(*input, **kwargs)                                         │\n",
+       "│   1111 │   │   # Do not call functions when jit is used                                          │\n",
+       "│   1112 │   │   full_backward_hooks, non_full_backward_hooks = [], []                             │\n",
+       "│   1113 │   │   if self._backward_hooks or _global_backward_hooks:                                │\n",
+       "│                                                                                                  │\n",
+       "│ /home/qiang/anaconda3/envs/realfusion/lib/python3.8/site-packages/diffusers/models/unet_2d_condi │\n",
+       "│ tion.py:582 in forward                                                                           │\n",
+       "│                                                                                                  │\n",
+       "│   579 │   │   down_block_res_samples = (sample,)                                                 │\n",
+       "│   580 │   │   for downsample_block in self.down_blocks:                                          │\n",
+       "│   581 │   │   │   if hasattr(downsample_block, \"has_cross_attention\") and downsample_block.has   │\n",
+       "│ ❱ 582 │   │   │   │   sample, res_samples = downsample_block(                                    │\n",
+       "│   583 │   │   │   │   │   hidden_states=sample,                                                  │\n",
+       "│   584 │   │   │   │   │   temb=emb,                                                              │\n",
+       "│   585 │   │   │   │   │   encoder_hidden_states=encoder_hidden_states,                           │\n",
+       "│                                                                                                  │\n",
+       "│ /home/qiang/anaconda3/envs/realfusion/lib/python3.8/site-packages/torch/nn/modules/module.py:111 │\n",
+       "│ 0 in _call_impl                                                                                  │\n",
+       "│                                                                                                  │\n",
+       "│   1107 │   │   # this function, and just call forward.                                           │\n",
+       "│   1108 │   │   if not (self._backward_hooks or self._forward_hooks or self._forward_pre_hooks o  │\n",
+       "│   1109 │   │   │   │   or _global_forward_hooks or _global_forward_pre_hooks):                   │\n",
+       "│ ❱ 1110 │   │   │   return forward_call(*input, **kwargs)                                         │\n",
+       "│   1111 │   │   # Do not call functions when jit is used                                          │\n",
+       "│   1112 │   │   full_backward_hooks, non_full_backward_hooks = [], []                             │\n",
+       "│   1113 │   │   if self._backward_hooks or _global_backward_hooks:                                │\n",
+       "│                                                                                                  │\n",
+       "│ /home/qiang/anaconda3/envs/realfusion/lib/python3.8/site-packages/diffusers/models/unet_2d_block │\n",
+       "│ s.py:837 in forward                                                                              │\n",
+       "│                                                                                                  │\n",
+       "│    834 │   │   │   │   )[0]                                                                      │\n",
+       "│    835 │   │   │   else:                                                                         │\n",
+       "│    836 │   │   │   │   hidden_states = resnet(hidden_states, temb)                               │\n",
+       "│ ❱  837 │   │   │   │   hidden_states = attn(                                                     │\n",
+       "│    838 │   │   │   │   │   hidden_states,                                                        │\n",
+       "│    839 │   │   │   │   │   encoder_hidden_states=encoder_hidden_states,                          │\n",
+       "│    840 │   │   │   │   │   cross_attention_kwargs=cross_attention_kwargs,                        │\n",
+       "│                                                                                                  │\n",
+       "│ /home/qiang/anaconda3/envs/realfusion/lib/python3.8/site-packages/torch/nn/modules/module.py:111 │\n",
+       "│ 0 in _call_impl                                                                                  │\n",
+       "│                                                                                                  │\n",
+       "│   1107 │   │   # this function, and just call forward.                                           │\n",
+       "│   1108 │   │   if not (self._backward_hooks or self._forward_hooks or self._forward_pre_hooks o  │\n",
+       "│   1109 │   │   │   │   or _global_forward_hooks or _global_forward_pre_hooks):                   │\n",
+       "│ ❱ 1110 │   │   │   return forward_call(*input, **kwargs)                                         │\n",
+       "│   1111 │   │   # Do not call functions when jit is used                                          │\n",
+       "│   1112 │   │   full_backward_hooks, non_full_backward_hooks = [], []                             │\n",
+       "│   1113 │   │   if self._backward_hooks or _global_backward_hooks:                                │\n",
+       "│                                                                                                  │\n",
+       "│ /home/qiang/anaconda3/envs/realfusion/lib/python3.8/site-packages/diffusers/models/transformer_2 │\n",
+       "│ d.py:265 in forward                                                                              │\n",
+       "│                                                                                                  │\n",
+       "│   262 │   │                                                                                      │\n",
+       "│   263 │   │   # 2. Blocks                                                                        │\n",
+       "│   264 │   │   for block in self.transformer_blocks:                                              │\n",
+       "│ ❱ 265 │   │   │   hidden_states = block(                                                         │\n",
+       "│   266 │   │   │   │   hidden_states,                                                             │\n",
+       "│   267 │   │   │   │   encoder_hidden_states=encoder_hidden_states,                               │\n",
+       "│   268 │   │   │   │   timestep=timestep,                                                         │\n",
+       "│                                                                                                  │\n",
+       "│ /home/qiang/anaconda3/envs/realfusion/lib/python3.8/site-packages/torch/nn/modules/module.py:111 │\n",
+       "│ 0 in _call_impl                                                                                  │\n",
+       "│                                                                                                  │\n",
+       "│   1107 │   │   # this function, and just call forward.                                           │\n",
+       "│   1108 │   │   if not (self._backward_hooks or self._forward_hooks or self._forward_pre_hooks o  │\n",
+       "│   1109 │   │   │   │   or _global_forward_hooks or _global_forward_pre_hooks):                   │\n",
+       "│ ❱ 1110 │   │   │   return forward_call(*input, **kwargs)                                         │\n",
+       "│   1111 │   │   # Do not call functions when jit is used                                          │\n",
+       "│   1112 │   │   full_backward_hooks, non_full_backward_hooks = [], []                             │\n",
+       "│   1113 │   │   if self._backward_hooks or _global_backward_hooks:                                │\n",
+       "│                                                                                                  │\n",
+       "│ /home/qiang/anaconda3/envs/realfusion/lib/python3.8/site-packages/diffusers/models/attention.py: │\n",
+       "│ 291 in forward                                                                                   │\n",
+       "│                                                                                                  │\n",
+       "│   288 │   │                                                                                      │\n",
+       "│   289 │   │   # 1. Self-Attention                                                                │\n",
+       "│   290 │   │   cross_attention_kwargs = cross_attention_kwargs if cross_attention_kwargs is not   │\n",
+       "│ ❱ 291 │   │   attn_output = self.attn1(                                                          │\n",
+       "│   292 │   │   │   norm_hidden_states,                                                            │\n",
+       "│   293 │   │   │   encoder_hidden_states=encoder_hidden_states if self.only_cross_attention els   │\n",
+       "│   294 │   │   │   attention_mask=attention_mask,                                                 │\n",
+       "│                                                                                                  │\n",
+       "│ /home/qiang/anaconda3/envs/realfusion/lib/python3.8/site-packages/torch/nn/modules/module.py:111 │\n",
+       "│ 0 in _call_impl                                                                                  │\n",
+       "│                                                                                                  │\n",
+       "│   1107 │   │   # this function, and just call forward.                                           │\n",
+       "│   1108 │   │   if not (self._backward_hooks or self._forward_hooks or self._forward_pre_hooks o  │\n",
+       "│   1109 │   │   │   │   or _global_forward_hooks or _global_forward_pre_hooks):                   │\n",
+       "│ ❱ 1110 │   │   │   return forward_call(*input, **kwargs)                                         │\n",
+       "│   1111 │   │   # Do not call functions when jit is used                                          │\n",
+       "│   1112 │   │   full_backward_hooks, non_full_backward_hooks = [], []                             │\n",
+       "│   1113 │   │   if self._backward_hooks or _global_backward_hooks:                                │\n",
+       "╰──────────────────────────────────────────────────────────────────────────────────────────────────╯\n",
+       "TypeError: forward() got an unexpected keyword argument 'encoder_hidden_states'\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[31m╭─\u001b[0m\u001b[31m──────────────────────────────\u001b[0m\u001b[31m \u001b[0m\u001b[1;31mTraceback \u001b[0m\u001b[1;2;31m(most recent call last)\u001b[0m\u001b[31m \u001b[0m\u001b[31m───────────────────────────────\u001b[0m\u001b[31m─╮\u001b[0m\n", + "\u001b[31m│\u001b[0m in \u001b[92m\u001b[0m:\u001b[94m1\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m1 (image_gt, image_enc), x_t, uncond_embeddings = null_inversion.invert(image_path, prompt \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m2 \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m3 \u001b[0m\u001b[96mprint\u001b[0m(\u001b[33m\"\u001b[0m\u001b[33mModify or remove offsets according to your image!\u001b[0m\u001b[33m\"\u001b[0m) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m4 \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m in \u001b[92minvert\u001b[0m:\u001b[94m168\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m165 \u001b[0m\u001b[2m│ │ \u001b[0mimage_gt = load_512(image_path, *offsets) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m166 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mif\u001b[0m verbose: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m167 \u001b[0m\u001b[2m│ │ │ \u001b[0m\u001b[96mprint\u001b[0m(\u001b[33m\"\u001b[0m\u001b[33mDDIM inversion...\u001b[0m\u001b[33m\"\u001b[0m) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m168 \u001b[2m│ │ \u001b[0mimage_rec, ddim_latents = \u001b[96mself\u001b[0m.ddim_inversion(image_gt) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m169 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mif\u001b[0m verbose: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m170 \u001b[0m\u001b[2m│ │ │ \u001b[0m\u001b[96mprint\u001b[0m(\u001b[33m\"\u001b[0m\u001b[33mNull-text optimization...\u001b[0m\u001b[33m\"\u001b[0m) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m171 \u001b[0m\u001b[2m│ │ \u001b[0muncond_embeddings = \u001b[96mself\u001b[0m.null_optimization(ddim_latents, num_inner_steps, early_ \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/home/qiang/anaconda3/envs/realfusion/lib/python3.8/site-packages/torch/autograd/\u001b[0m\u001b[1;33mgrad_mode.py\u001b[0m:\u001b[94m27\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m in \u001b[92mdecorate_context\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 24 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[1;95m@functools\u001b[0m.wraps(func) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 25 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mdef\u001b[0m \u001b[92mdecorate_context\u001b[0m(*args, **kwargs): \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 26 \u001b[0m\u001b[2m│ │ │ \u001b[0m\u001b[94mwith\u001b[0m \u001b[96mself\u001b[0m.clone(): \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m 27 \u001b[2m│ │ │ │ \u001b[0m\u001b[94mreturn\u001b[0m func(*args, **kwargs) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 28 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mreturn\u001b[0m cast(F, decorate_context) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 29 \u001b[0m\u001b[2m│ \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 30 \u001b[0m\u001b[2m│ \u001b[0m\u001b[94mdef\u001b[0m \u001b[92m_wrap_generator\u001b[0m(\u001b[96mself\u001b[0m, func): \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m in \u001b[92mddim_inversion\u001b[0m:\u001b[94m125\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m122 \u001b[0m\u001b[2m│ \u001b[0m\u001b[94mdef\u001b[0m \u001b[92mddim_inversion\u001b[0m(\u001b[96mself\u001b[0m, image): \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m123 \u001b[0m\u001b[2m│ │ \u001b[0mlatent = \u001b[96mself\u001b[0m.image2latent(image) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m124 \u001b[0m\u001b[2m│ │ \u001b[0mimage_rec = \u001b[96mself\u001b[0m.latent2image(latent) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m125 \u001b[2m│ │ \u001b[0mddim_latents = \u001b[96mself\u001b[0m.ddim_loop(latent) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m126 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mreturn\u001b[0m image_rec, ddim_latents \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m127 \u001b[0m\u001b[2m│ \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m128 \u001b[0m\u001b[2m│ \u001b[0m\u001b[94mdef\u001b[0m \u001b[92mnull_optimization\u001b[0m(\u001b[96mself\u001b[0m, latents, num_inner_steps, epsilon): \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/home/qiang/anaconda3/envs/realfusion/lib/python3.8/site-packages/torch/autograd/\u001b[0m\u001b[1;33mgrad_mode.py\u001b[0m:\u001b[94m27\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m in \u001b[92mdecorate_context\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 24 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[1;95m@functools\u001b[0m.wraps(func) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 25 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mdef\u001b[0m \u001b[92mdecorate_context\u001b[0m(*args, **kwargs): \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 26 \u001b[0m\u001b[2m│ │ │ \u001b[0m\u001b[94mwith\u001b[0m \u001b[96mself\u001b[0m.clone(): \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m 27 \u001b[2m│ │ │ │ \u001b[0m\u001b[94mreturn\u001b[0m func(*args, **kwargs) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 28 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mreturn\u001b[0m cast(F, decorate_context) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 29 \u001b[0m\u001b[2m│ \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 30 \u001b[0m\u001b[2m│ \u001b[0m\u001b[94mdef\u001b[0m \u001b[92m_wrap_generator\u001b[0m(\u001b[96mself\u001b[0m, func): \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m in \u001b[92mddim_loop\u001b[0m:\u001b[94m112\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m109 \u001b[0m\u001b[2m│ │ \u001b[0mlatent = latent.clone().detach() \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m110 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mfor\u001b[0m i \u001b[95min\u001b[0m \u001b[96mrange\u001b[0m(NUM_DDIM_STEPS): \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m111 \u001b[0m\u001b[2m│ │ │ \u001b[0mt = \u001b[96mself\u001b[0m.model.scheduler.timesteps[\u001b[96mlen\u001b[0m(\u001b[96mself\u001b[0m.model.scheduler.timesteps) - i - \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m112 \u001b[2m│ │ │ \u001b[0mnoise_pred = \u001b[96mself\u001b[0m.get_noise_pred_single(latent, t, cond_embeddings) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m113 \u001b[0m\u001b[2m│ │ │ \u001b[0mlatent = \u001b[96mself\u001b[0m.next_step(noise_pred, t, latent) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m114 \u001b[0m\u001b[2m│ │ │ \u001b[0mall_latent.append(latent) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m115 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mreturn\u001b[0m all_latent \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m in \u001b[92mget_noise_pred_single\u001b[0m:\u001b[94m46\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 43 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mreturn\u001b[0m next_sample \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 44 \u001b[0m\u001b[2m│ \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 45 \u001b[0m\u001b[2m│ \u001b[0m\u001b[94mdef\u001b[0m \u001b[92mget_noise_pred_single\u001b[0m(\u001b[96mself\u001b[0m, latents, t, context): \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m 46 \u001b[2m│ │ \u001b[0mnoise_pred = \u001b[96mself\u001b[0m.model.unet(latents, t, encoder_hidden_states=context)[\u001b[33m\"\u001b[0m\u001b[33msample\u001b[0m\u001b[33m\"\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 47 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mreturn\u001b[0m noise_pred \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 48 \u001b[0m\u001b[2m│ \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 49 \u001b[0m\u001b[2m│ \u001b[0m\u001b[94mdef\u001b[0m \u001b[92mget_noise_pred\u001b[0m(\u001b[96mself\u001b[0m, latents, t, is_forward=\u001b[94mTrue\u001b[0m, context=\u001b[94mNone\u001b[0m): \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/home/qiang/anaconda3/envs/realfusion/lib/python3.8/site-packages/torch/nn/modules/\u001b[0m\u001b[1;33mmodule.py\u001b[0m:\u001b[94m111\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[94m0\u001b[0m in \u001b[92m_call_impl\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1107 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[2m# this function, and just call forward.\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1108 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mif\u001b[0m \u001b[95mnot\u001b[0m (\u001b[96mself\u001b[0m._backward_hooks \u001b[95mor\u001b[0m \u001b[96mself\u001b[0m._forward_hooks \u001b[95mor\u001b[0m \u001b[96mself\u001b[0m._forward_pre_hooks \u001b[95mo\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1109 \u001b[0m\u001b[2m│ │ │ │ \u001b[0m\u001b[95mor\u001b[0m _global_forward_hooks \u001b[95mor\u001b[0m _global_forward_pre_hooks): \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m1110 \u001b[2m│ │ │ \u001b[0m\u001b[94mreturn\u001b[0m forward_call(*\u001b[96minput\u001b[0m, **kwargs) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1111 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[2m# Do not call functions when jit is used\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1112 \u001b[0m\u001b[2m│ │ \u001b[0mfull_backward_hooks, non_full_backward_hooks = [], [] \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1113 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mif\u001b[0m \u001b[96mself\u001b[0m._backward_hooks \u001b[95mor\u001b[0m _global_backward_hooks: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/home/qiang/anaconda3/envs/realfusion/lib/python3.8/site-packages/diffusers/models/\u001b[0m\u001b[1;33munet_2d_condi\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[1;33mtion.py\u001b[0m:\u001b[94m582\u001b[0m in \u001b[92mforward\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m579 \u001b[0m\u001b[2m│ │ \u001b[0mdown_block_res_samples = (sample,) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m580 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mfor\u001b[0m downsample_block \u001b[95min\u001b[0m \u001b[96mself\u001b[0m.down_blocks: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m581 \u001b[0m\u001b[2m│ │ │ \u001b[0m\u001b[94mif\u001b[0m \u001b[96mhasattr\u001b[0m(downsample_block, \u001b[33m\"\u001b[0m\u001b[33mhas_cross_attention\u001b[0m\u001b[33m\"\u001b[0m) \u001b[95mand\u001b[0m downsample_block.has \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m582 \u001b[2m│ │ │ │ \u001b[0msample, res_samples = downsample_block( \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m583 \u001b[0m\u001b[2m│ │ │ │ │ \u001b[0mhidden_states=sample, \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m584 \u001b[0m\u001b[2m│ │ │ │ │ \u001b[0mtemb=emb, \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m585 \u001b[0m\u001b[2m│ │ │ │ │ \u001b[0mencoder_hidden_states=encoder_hidden_states, \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/home/qiang/anaconda3/envs/realfusion/lib/python3.8/site-packages/torch/nn/modules/\u001b[0m\u001b[1;33mmodule.py\u001b[0m:\u001b[94m111\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[94m0\u001b[0m in \u001b[92m_call_impl\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1107 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[2m# this function, and just call forward.\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1108 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mif\u001b[0m \u001b[95mnot\u001b[0m (\u001b[96mself\u001b[0m._backward_hooks \u001b[95mor\u001b[0m \u001b[96mself\u001b[0m._forward_hooks \u001b[95mor\u001b[0m \u001b[96mself\u001b[0m._forward_pre_hooks \u001b[95mo\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1109 \u001b[0m\u001b[2m│ │ │ │ \u001b[0m\u001b[95mor\u001b[0m _global_forward_hooks \u001b[95mor\u001b[0m _global_forward_pre_hooks): \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m1110 \u001b[2m│ │ │ \u001b[0m\u001b[94mreturn\u001b[0m forward_call(*\u001b[96minput\u001b[0m, **kwargs) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1111 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[2m# Do not call functions when jit is used\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1112 \u001b[0m\u001b[2m│ │ \u001b[0mfull_backward_hooks, non_full_backward_hooks = [], [] \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1113 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mif\u001b[0m \u001b[96mself\u001b[0m._backward_hooks \u001b[95mor\u001b[0m _global_backward_hooks: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/home/qiang/anaconda3/envs/realfusion/lib/python3.8/site-packages/diffusers/models/\u001b[0m\u001b[1;33munet_2d_block\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[1;33ms.py\u001b[0m:\u001b[94m837\u001b[0m in \u001b[92mforward\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 834 \u001b[0m\u001b[2m│ │ │ │ \u001b[0m)[\u001b[94m0\u001b[0m] \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 835 \u001b[0m\u001b[2m│ │ │ \u001b[0m\u001b[94melse\u001b[0m: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 836 \u001b[0m\u001b[2m│ │ │ │ \u001b[0mhidden_states = resnet(hidden_states, temb) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m 837 \u001b[2m│ │ │ │ \u001b[0mhidden_states = attn( \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 838 \u001b[0m\u001b[2m│ │ │ │ │ \u001b[0mhidden_states, \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 839 \u001b[0m\u001b[2m│ │ │ │ │ \u001b[0mencoder_hidden_states=encoder_hidden_states, \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m 840 \u001b[0m\u001b[2m│ │ │ │ │ \u001b[0mcross_attention_kwargs=cross_attention_kwargs, \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/home/qiang/anaconda3/envs/realfusion/lib/python3.8/site-packages/torch/nn/modules/\u001b[0m\u001b[1;33mmodule.py\u001b[0m:\u001b[94m111\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[94m0\u001b[0m in \u001b[92m_call_impl\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1107 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[2m# this function, and just call forward.\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1108 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mif\u001b[0m \u001b[95mnot\u001b[0m (\u001b[96mself\u001b[0m._backward_hooks \u001b[95mor\u001b[0m \u001b[96mself\u001b[0m._forward_hooks \u001b[95mor\u001b[0m \u001b[96mself\u001b[0m._forward_pre_hooks \u001b[95mo\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1109 \u001b[0m\u001b[2m│ │ │ │ \u001b[0m\u001b[95mor\u001b[0m _global_forward_hooks \u001b[95mor\u001b[0m _global_forward_pre_hooks): \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m1110 \u001b[2m│ │ │ \u001b[0m\u001b[94mreturn\u001b[0m forward_call(*\u001b[96minput\u001b[0m, **kwargs) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1111 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[2m# Do not call functions when jit is used\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1112 \u001b[0m\u001b[2m│ │ \u001b[0mfull_backward_hooks, non_full_backward_hooks = [], [] \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1113 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mif\u001b[0m \u001b[96mself\u001b[0m._backward_hooks \u001b[95mor\u001b[0m _global_backward_hooks: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/home/qiang/anaconda3/envs/realfusion/lib/python3.8/site-packages/diffusers/models/\u001b[0m\u001b[1;33mtransformer_2\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[1;33md.py\u001b[0m:\u001b[94m265\u001b[0m in \u001b[92mforward\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m262 \u001b[0m\u001b[2m│ │ \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m263 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[2m# 2. Blocks\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m264 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mfor\u001b[0m block \u001b[95min\u001b[0m \u001b[96mself\u001b[0m.transformer_blocks: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m265 \u001b[2m│ │ │ \u001b[0mhidden_states = block( \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m266 \u001b[0m\u001b[2m│ │ │ │ \u001b[0mhidden_states, \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m267 \u001b[0m\u001b[2m│ │ │ │ \u001b[0mencoder_hidden_states=encoder_hidden_states, \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m268 \u001b[0m\u001b[2m│ │ │ │ \u001b[0mtimestep=timestep, \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/home/qiang/anaconda3/envs/realfusion/lib/python3.8/site-packages/torch/nn/modules/\u001b[0m\u001b[1;33mmodule.py\u001b[0m:\u001b[94m111\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[94m0\u001b[0m in \u001b[92m_call_impl\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1107 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[2m# this function, and just call forward.\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1108 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mif\u001b[0m \u001b[95mnot\u001b[0m (\u001b[96mself\u001b[0m._backward_hooks \u001b[95mor\u001b[0m \u001b[96mself\u001b[0m._forward_hooks \u001b[95mor\u001b[0m \u001b[96mself\u001b[0m._forward_pre_hooks \u001b[95mo\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1109 \u001b[0m\u001b[2m│ │ │ │ \u001b[0m\u001b[95mor\u001b[0m _global_forward_hooks \u001b[95mor\u001b[0m _global_forward_pre_hooks): \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m1110 \u001b[2m│ │ │ \u001b[0m\u001b[94mreturn\u001b[0m forward_call(*\u001b[96minput\u001b[0m, **kwargs) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1111 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[2m# Do not call functions when jit is used\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1112 \u001b[0m\u001b[2m│ │ \u001b[0mfull_backward_hooks, non_full_backward_hooks = [], [] \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1113 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mif\u001b[0m \u001b[96mself\u001b[0m._backward_hooks \u001b[95mor\u001b[0m _global_backward_hooks: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/home/qiang/anaconda3/envs/realfusion/lib/python3.8/site-packages/diffusers/models/\u001b[0m\u001b[1;33mattention.py\u001b[0m: \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[94m291\u001b[0m in \u001b[92mforward\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m288 \u001b[0m\u001b[2m│ │ \u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m289 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[2m# 1. Self-Attention\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m290 \u001b[0m\u001b[2m│ │ \u001b[0mcross_attention_kwargs = cross_attention_kwargs \u001b[94mif\u001b[0m cross_attention_kwargs \u001b[95mis\u001b[0m \u001b[95mnot\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m291 \u001b[2m│ │ \u001b[0mattn_output = \u001b[96mself\u001b[0m.attn1( \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m292 \u001b[0m\u001b[2m│ │ │ \u001b[0mnorm_hidden_states, \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m293 \u001b[0m\u001b[2m│ │ │ \u001b[0mencoder_hidden_states=encoder_hidden_states \u001b[94mif\u001b[0m \u001b[96mself\u001b[0m.only_cross_attention \u001b[94mels\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m294 \u001b[0m\u001b[2m│ │ │ \u001b[0mattention_mask=attention_mask, \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2;33m/home/qiang/anaconda3/envs/realfusion/lib/python3.8/site-packages/torch/nn/modules/\u001b[0m\u001b[1;33mmodule.py\u001b[0m:\u001b[94m111\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[94m0\u001b[0m in \u001b[92m_call_impl\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1107 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[2m# this function, and just call forward.\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1108 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mif\u001b[0m \u001b[95mnot\u001b[0m (\u001b[96mself\u001b[0m._backward_hooks \u001b[95mor\u001b[0m \u001b[96mself\u001b[0m._forward_hooks \u001b[95mor\u001b[0m \u001b[96mself\u001b[0m._forward_pre_hooks \u001b[95mo\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1109 \u001b[0m\u001b[2m│ │ │ │ \u001b[0m\u001b[95mor\u001b[0m _global_forward_hooks \u001b[95mor\u001b[0m _global_forward_pre_hooks): \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[31m❱ \u001b[0m1110 \u001b[2m│ │ │ \u001b[0m\u001b[94mreturn\u001b[0m forward_call(*\u001b[96minput\u001b[0m, **kwargs) \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1111 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[2m# Do not call functions when jit is used\u001b[0m \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1112 \u001b[0m\u001b[2m│ │ \u001b[0mfull_backward_hooks, non_full_backward_hooks = [], [] \u001b[31m│\u001b[0m\n", + "\u001b[31m│\u001b[0m \u001b[2m1113 \u001b[0m\u001b[2m│ │ \u001b[0m\u001b[94mif\u001b[0m \u001b[96mself\u001b[0m._backward_hooks \u001b[95mor\u001b[0m _global_backward_hooks: \u001b[31m│\u001b[0m\n", + "\u001b[31m╰──────────────────────────────────────────────────────────────────────────────────────────────────╯\u001b[0m\n", + "\u001b[1;91mTypeError: \u001b[0m\u001b[1;35mforward\u001b[0m\u001b[1m(\u001b[0m\u001b[1m)\u001b[0m got an unexpected keyword argument \u001b[32m'encoder_hidden_states'\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "ename": "", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[1;31mThe Kernel crashed while executing code in the the current cell or a previous cell. Please review the code in the cell(s) to identify a possible cause of the failure. Click here for more info. View Jupyter log for further details." + ] + } + ], + "source": [ + "\n", + "(image_gt, image_enc), x_t, uncond_embeddings = null_inversion.invert(image_path, prompt, offsets=offsets, verbose=True)\n", + "\n", + "print(\"Modify or remove offsets according to your image!\")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "a36d450d-6764-4195-9ff1-842b2f60249e", + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "426b5cc834ce4f4cb86d0b6266b9210d", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/50 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "prompts = [prompt]\n", + "controller = AttentionStore()\n", + "image_inv, x_t = run_and_display(prompts, controller, run_baseline=False, latent=x_t, uncond_embeddings=uncond_embeddings, verbose=False)\n", + "print(\"showing from left to right: the ground truth image, the vq-autoencoder reconstruction, the null-text inverted image\")\n", + "ptp_utils.view_images([image_gt, image_enc, image_inv[0]])\n", + "show_cross_attention(controller, 16, [\"up\", \"down\"])\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "da742d87-b48e-40e1-8b8e-c0f9b7528cc9", + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "8a43bd01468e4b978e3ffa11b89699ee", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/50 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Image is highly affected by the self_replace_steps, usually 0.4 is a good default value, but you may want to try the range 0.3,0.4,0.5,0.7 \n" + ] + } + ], + "source": [ + "prompts = [\"a cat sitting next to a mirror\",\n", + " \"a tiger sitting next to a mirror\"\n", + " ]\n", + "\n", + "cross_replace_steps = {'default_': .8,}\n", + "self_replace_steps = .5\n", + "blend_word = ((('cat',), (\"tiger\",))) # for local edit. If it is not local yet - use only the source object: blend_word = ((('cat',), (\"cat\",))).\n", + "eq_params = {\"words\": (\"tiger\",), \"values\": (2,)} # amplify attention to the word \"tiger\" by *2 \n", + "\n", + "controller = make_controller(prompts, True, cross_replace_steps, self_replace_steps, blend_word, eq_params)\n", + "images, _ = run_and_display(prompts, controller, run_baseline=False, latent=x_t, uncond_embeddings=uncond_embeddings)\n", + "\n", + "print(\"Image is highly affected by the self_replace_steps, usually 0.4 is a good default value, but you may want to try the range 0.3,0.4,0.5,0.7 \")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "861db4be-72cc-4d8f-969b-bba1bf45bb50", + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "1171205e989f4c48898dbb50c5803de6", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/50 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "prompts = [\"a cat sitting next to a mirror\",\n", + " \"a silver cat sculpture sitting next to a mirror\"\n", + " ]\n", + "\n", + "cross_replace_steps = {'default_': .8, }\n", + "self_replace_steps = .6\n", + "blend_word = ((('cat',), (\"cat\",))) # for local edit\n", + "eq_params = {\"words\": (\"silver\", 'sculpture', ), \"values\": (2,2,)} # amplify attention to the words \"silver\" and \"sculpture\" by *2 \n", + " \n", + "controller = make_controller(prompts, False, cross_replace_steps, self_replace_steps, blend_word, eq_params)\n", + "images, _ = run_and_display(prompts, controller, run_baseline=False, latent=x_t, uncond_embeddings=uncond_embeddings)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "4b768dd2-a139-4163-823e-15318441ea49", + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "8d200aaed0624a14ba14b5389c9eb64c", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/50 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "prompts = [\"a cat sitting next to a mirror\",\n", + " \"watercolor painting of a cat sitting next to a mirror\"\n", + " ]\n", + "\n", + "cross_replace_steps = {'default_': .8, }\n", + "self_replace_steps = .7\n", + "blend_word = None\n", + "eq_params = {\"words\": (\"watercolor\", ), \"values\": (5, 2,)} # amplify attention to the word \"watercolor\" by 5\n", + " \n", + "controller = make_controller(prompts, False, cross_replace_steps, self_replace_steps, blend_word, eq_params)\n", + "images, _ = run_and_display(prompts, controller, run_baseline=False, latent=x_t, uncond_embeddings=uncond_embeddings)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6adfb554-148b-45af-ae8b-17b213f9070f", + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "environment": { + "kernel": "python3", + "name": "pytorch-gpu.1-12.m97", + "type": "gcloud", + "uri": "gcr.io/deeplearning-platform-release/pytorch-gpu.1-12:m97" + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.16" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/textual-inversion/ptp_utils.py b/textual-inversion/ptp_utils.py new file mode 100644 index 0000000..1e46c6d --- /dev/null +++ b/textual-inversion/ptp_utils.py @@ -0,0 +1,295 @@ +# Copyright 2022 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import numpy as np +import torch +from PIL import Image, ImageDraw, ImageFont +import cv2 +from typing import Optional, Union, Tuple, List, Callable, Dict +from IPython.display import display +from tqdm.notebook import tqdm + + +def text_under_image(image: np.ndarray, text: str, text_color: Tuple[int, int, int] = (0, 0, 0)): + h, w, c = image.shape + offset = int(h * .2) + img = np.ones((h + offset, w, c), dtype=np.uint8) * 255 + font = cv2.FONT_HERSHEY_SIMPLEX + # font = ImageFont.truetype("/usr/share/fonts/truetype/noto/NotoMono-Regular.ttf", font_size) + img[:h] = image + textsize = cv2.getTextSize(text, font, 1, 2)[0] + text_x, text_y = (w - textsize[0]) // 2, h + offset - textsize[1] // 2 + cv2.putText(img, text, (text_x, text_y ), font, 1, text_color, 2) + return img + + +def view_images(images, num_rows=1, offset_ratio=0.02): + if type(images) is list: + num_empty = len(images) % num_rows + elif images.ndim == 4: + num_empty = images.shape[0] % num_rows + else: + images = [images] + num_empty = 0 + + empty_images = np.ones(images[0].shape, dtype=np.uint8) * 255 + images = [image.astype(np.uint8) for image in images] + [empty_images] * num_empty + num_items = len(images) + + h, w, c = images[0].shape + offset = int(h * offset_ratio) + num_cols = num_items // num_rows + image_ = np.ones((h * num_rows + offset * (num_rows - 1), + w * num_cols + offset * (num_cols - 1), 3), dtype=np.uint8) * 255 + for i in range(num_rows): + for j in range(num_cols): + image_[i * (h + offset): i * (h + offset) + h:, j * (w + offset): j * (w + offset) + w] = images[ + i * num_cols + j] + + pil_img = Image.fromarray(image_) + display(pil_img) + + +def diffusion_step(model, controller, latents, context, t, guidance_scale, low_resource=False): + if low_resource: + noise_pred_uncond = model.unet(latents, t, encoder_hidden_states=context[0])["sample"] + noise_prediction_text = model.unet(latents, t, encoder_hidden_states=context[1])["sample"] + else: + latents_input = torch.cat([latents] * 2) + noise_pred = model.unet(latents_input, t, encoder_hidden_states=context)["sample"] + noise_pred_uncond, noise_prediction_text = noise_pred.chunk(2) + noise_pred = noise_pred_uncond + guidance_scale * (noise_prediction_text - noise_pred_uncond) + latents = model.scheduler.step(noise_pred, t, latents)["prev_sample"] + latents = controller.step_callback(latents) + return latents + + +def latent2image(vae, latents): + latents = 1 / 0.18215 * latents + image = vae.decode(latents)['sample'] + image = (image / 2 + 0.5).clamp(0, 1) + image = image.cpu().permute(0, 2, 3, 1).numpy() + image = (image * 255).astype(np.uint8) + return image + + +def init_latent(latent, model, height, width, generator, batch_size): + if latent is None: + latent = torch.randn( + (1, model.unet.in_channels, height // 8, width // 8), + generator=generator, + ) + latents = latent.expand(batch_size, model.unet.in_channels, height // 8, width // 8).to(model.device) + return latent, latents + + +@torch.no_grad() +def text2image_ldm( + model, + prompt: List[str], + controller, + num_inference_steps: int = 50, + guidance_scale: Optional[float] = 7., + generator: Optional[torch.Generator] = None, + latent: Optional[torch.FloatTensor] = None, +): + register_attention_control(model, controller) + height = width = 256 + batch_size = len(prompt) + + uncond_input = model.tokenizer([""] * batch_size, padding="max_length", max_length=77, return_tensors="pt") + uncond_embeddings = model.bert(uncond_input.input_ids.to(model.device))[0] + + text_input = model.tokenizer(prompt, padding="max_length", max_length=77, return_tensors="pt") + text_embeddings = model.bert(text_input.input_ids.to(model.device))[0] + latent, latents = init_latent(latent, model, height, width, generator, batch_size) + context = torch.cat([uncond_embeddings, text_embeddings]) + + model.scheduler.set_timesteps(num_inference_steps) + for t in tqdm(model.scheduler.timesteps): + latents = diffusion_step(model, controller, latents, context, t, guidance_scale) + + image = latent2image(model.vqvae, latents) + + return image, latent + + +@torch.no_grad() +def text2image_ldm_stable( + model, + prompt: List[str], + controller, + num_inference_steps: int = 50, + guidance_scale: float = 7.5, + generator: Optional[torch.Generator] = None, + latent: Optional[torch.FloatTensor] = None, + low_resource: bool = False, +): + register_attention_control(model, controller) + height = width = 512 + batch_size = len(prompt) + + text_input = model.tokenizer( + prompt, + padding="max_length", + max_length=model.tokenizer.model_max_length, + truncation=True, + return_tensors="pt", + ) + text_embeddings = model.text_encoder(text_input.input_ids.to(model.device))[0] + max_length = text_input.input_ids.shape[-1] + uncond_input = model.tokenizer( + [""] * batch_size, padding="max_length", max_length=max_length, return_tensors="pt" + ) + uncond_embeddings = model.text_encoder(uncond_input.input_ids.to(model.device))[0] + + context = [uncond_embeddings, text_embeddings] + if not low_resource: + context = torch.cat(context) + latent, latents = init_latent(latent, model, height, width, generator, batch_size) + + # set timesteps + extra_set_kwargs = {"offset": 1} + model.scheduler.set_timesteps(num_inference_steps, **extra_set_kwargs) + for t in tqdm(model.scheduler.timesteps): + latents = diffusion_step(model, controller, latents, context, t, guidance_scale, low_resource) + + image = latent2image(model.vae, latents) + + return image, latent + + +def register_attention_control(model, controller): + def ca_forward(self, place_in_unet): + to_out = self.to_out + if type(to_out) is torch.nn.modules.container.ModuleList: + to_out = self.to_out[0] + else: + to_out = self.to_out + + def forward(x, context=None, mask=None): + batch_size, sequence_length, dim = x.shape + h = self.heads + q = self.to_q(x) + is_cross = context is not None + context = context if is_cross else x + k = self.to_k(context) + v = self.to_v(context) + q = self.reshape_heads_to_batch_dim(q) + k = self.reshape_heads_to_batch_dim(k) + v = self.reshape_heads_to_batch_dim(v) + + sim = torch.einsum("b i d, b j d -> b i j", q, k) * self.scale + + if mask is not None: + mask = mask.reshape(batch_size, -1) + max_neg_value = -torch.finfo(sim.dtype).max + mask = mask[:, None, :].repeat(h, 1, 1) + sim.masked_fill_(~mask, max_neg_value) + + # attention, what we cannot get enough of + attn = sim.softmax(dim=-1) + attn = controller(attn, is_cross, place_in_unet) + out = torch.einsum("b i j, b j d -> b i d", attn, v) + out = self.reshape_batch_dim_to_heads(out) + return to_out(out) + + return forward + + class DummyController: + + def __call__(self, *args): + return args[0] + + def __init__(self): + self.num_att_layers = 0 + + if controller is None: + controller = DummyController() + + def register_recr(net_, count, place_in_unet): + if net_.__class__.__name__ == 'CrossAttention': + net_.forward = ca_forward(net_, place_in_unet) + return count + 1 + elif hasattr(net_, 'children'): + for net__ in net_.children(): + count = register_recr(net__, count, place_in_unet) + return count + + cross_att_count = 0 + sub_nets = model.unet.named_children() + for net in sub_nets: + if "down" in net[0]: + cross_att_count += register_recr(net[1], 0, "down") + elif "up" in net[0]: + cross_att_count += register_recr(net[1], 0, "up") + elif "mid" in net[0]: + cross_att_count += register_recr(net[1], 0, "mid") + + controller.num_att_layers = cross_att_count + + +def get_word_inds(text: str, word_place: int, tokenizer): + split_text = text.split(" ") + if type(word_place) is str: + word_place = [i for i, word in enumerate(split_text) if word_place == word] + elif type(word_place) is int: + word_place = [word_place] + out = [] + if len(word_place) > 0: + words_encode = [tokenizer.decode([item]).strip("#") for item in tokenizer.encode(text)][1:-1] + cur_len, ptr = 0, 0 + + for i in range(len(words_encode)): + cur_len += len(words_encode[i]) + if ptr in word_place: + out.append(i + 1) + if cur_len >= len(split_text[ptr]): + ptr += 1 + cur_len = 0 + return np.array(out) + + +def update_alpha_time_word(alpha, bounds: Union[float, Tuple[float, float]], prompt_ind: int, + word_inds: Optional[torch.Tensor]=None): + if type(bounds) is float: + bounds = 0, bounds + start, end = int(bounds[0] * alpha.shape[0]), int(bounds[1] * alpha.shape[0]) + if word_inds is None: + word_inds = torch.arange(alpha.shape[2]) + alpha[: start, prompt_ind, word_inds] = 0 + alpha[start: end, prompt_ind, word_inds] = 1 + alpha[end:, prompt_ind, word_inds] = 0 + return alpha + + +def get_time_words_attention_alpha(prompts, num_steps, + cross_replace_steps: Union[float, Dict[str, Tuple[float, float]]], + tokenizer, max_num_words=77): + if type(cross_replace_steps) is not dict: + cross_replace_steps = {"default_": cross_replace_steps} + if "default_" not in cross_replace_steps: + cross_replace_steps["default_"] = (0., 1.) + alpha_time_words = torch.zeros(num_steps + 1, len(prompts) - 1, max_num_words) + for i in range(len(prompts) - 1): + alpha_time_words = update_alpha_time_word(alpha_time_words, cross_replace_steps["default_"], + i) + for key, item in cross_replace_steps.items(): + if key != "default_": + inds = [get_word_inds(prompts[i], key, tokenizer) for i in range(1, len(prompts))] + for i, ind in enumerate(inds): + if len(ind) > 0: + alpha_time_words = update_alpha_time_word(alpha_time_words, item, i, ind) + alpha_time_words = alpha_time_words.reshape(num_steps + 1, len(prompts) - 1, 1, 1, max_num_words) + return alpha_time_words diff --git a/textual-inversion/seq_aligner.py b/textual-inversion/seq_aligner.py new file mode 100644 index 0000000..684036b --- /dev/null +++ b/textual-inversion/seq_aligner.py @@ -0,0 +1,196 @@ +# Copyright 2022 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +import torch +import numpy as np + + +class ScoreParams: + + def __init__(self, gap, match, mismatch): + self.gap = gap + self.match = match + self.mismatch = mismatch + + def mis_match_char(self, x, y): + if x != y: + return self.mismatch + else: + return self.match + + +def get_matrix(size_x, size_y, gap): + matrix = [] + for i in range(len(size_x) + 1): + sub_matrix = [] + for j in range(len(size_y) + 1): + sub_matrix.append(0) + matrix.append(sub_matrix) + for j in range(1, len(size_y) + 1): + matrix[0][j] = j*gap + for i in range(1, len(size_x) + 1): + matrix[i][0] = i*gap + return matrix + + +def get_matrix(size_x, size_y, gap): + matrix = np.zeros((size_x + 1, size_y + 1), dtype=np.int32) + matrix[0, 1:] = (np.arange(size_y) + 1) * gap + matrix[1:, 0] = (np.arange(size_x) + 1) * gap + return matrix + + +def get_traceback_matrix(size_x, size_y): + matrix = np.zeros((size_x + 1, size_y +1), dtype=np.int32) + matrix[0, 1:] = 1 + matrix[1:, 0] = 2 + matrix[0, 0] = 4 + return matrix + + +def global_align(x, y, score): + matrix = get_matrix(len(x), len(y), score.gap) + trace_back = get_traceback_matrix(len(x), len(y)) + for i in range(1, len(x) + 1): + for j in range(1, len(y) + 1): + left = matrix[i, j - 1] + score.gap + up = matrix[i - 1, j] + score.gap + diag = matrix[i - 1, j - 1] + score.mis_match_char(x[i - 1], y[j - 1]) + matrix[i, j] = max(left, up, diag) + if matrix[i, j] == left: + trace_back[i, j] = 1 + elif matrix[i, j] == up: + trace_back[i, j] = 2 + else: + trace_back[i, j] = 3 + return matrix, trace_back + + +def get_aligned_sequences(x, y, trace_back): + x_seq = [] + y_seq = [] + i = len(x) + j = len(y) + mapper_y_to_x = [] + while i > 0 or j > 0: + if trace_back[i, j] == 3: + x_seq.append(x[i-1]) + y_seq.append(y[j-1]) + i = i-1 + j = j-1 + mapper_y_to_x.append((j, i)) + elif trace_back[i][j] == 1: + x_seq.append('-') + y_seq.append(y[j-1]) + j = j-1 + mapper_y_to_x.append((j, -1)) + elif trace_back[i][j] == 2: + x_seq.append(x[i-1]) + y_seq.append('-') + i = i-1 + elif trace_back[i][j] == 4: + break + mapper_y_to_x.reverse() + return x_seq, y_seq, torch.tensor(mapper_y_to_x, dtype=torch.int64) + + +def get_mapper(x: str, y: str, tokenizer, max_len=77): + x_seq = tokenizer.encode(x) + y_seq = tokenizer.encode(y) + score = ScoreParams(0, 1, -1) + matrix, trace_back = global_align(x_seq, y_seq, score) + mapper_base = get_aligned_sequences(x_seq, y_seq, trace_back)[-1] + alphas = torch.ones(max_len) + alphas[: mapper_base.shape[0]] = mapper_base[:, 1].ne(-1).float() + mapper = torch.zeros(max_len, dtype=torch.int64) + mapper[:mapper_base.shape[0]] = mapper_base[:, 1] + mapper[mapper_base.shape[0]:] = len(y_seq) + torch.arange(max_len - len(y_seq)) + return mapper, alphas + + +def get_refinement_mapper(prompts, tokenizer, max_len=77): + x_seq = prompts[0] + mappers, alphas = [], [] + for i in range(1, len(prompts)): + mapper, alpha = get_mapper(x_seq, prompts[i], tokenizer, max_len) + mappers.append(mapper) + alphas.append(alpha) + return torch.stack(mappers), torch.stack(alphas) + + +def get_word_inds(text: str, word_place: int, tokenizer): + split_text = text.split(" ") + if type(word_place) is str: + word_place = [i for i, word in enumerate(split_text) if word_place == word] + elif type(word_place) is int: + word_place = [word_place] + out = [] + if len(word_place) > 0: + words_encode = [tokenizer.decode([item]).strip("#") for item in tokenizer.encode(text)][1:-1] + cur_len, ptr = 0, 0 + + for i in range(len(words_encode)): + cur_len += len(words_encode[i]) + if ptr in word_place: + out.append(i + 1) + if cur_len >= len(split_text[ptr]): + ptr += 1 + cur_len = 0 + return np.array(out) + + +def get_replacement_mapper_(x: str, y: str, tokenizer, max_len=77): + words_x = x.split(' ') + words_y = y.split(' ') + if len(words_x) != len(words_y): + raise ValueError(f"attention replacement edit can only be applied on prompts with the same length" + f" but prompt A has {len(words_x)} words and prompt B has {len(words_y)} words.") + inds_replace = [i for i in range(len(words_y)) if words_y[i] != words_x[i]] + inds_source = [get_word_inds(x, i, tokenizer) for i in inds_replace] + inds_target = [get_word_inds(y, i, tokenizer) for i in inds_replace] + mapper = np.zeros((max_len, max_len)) + i = j = 0 + cur_inds = 0 + while i < max_len and j < max_len: + if cur_inds < len(inds_source) and inds_source[cur_inds][0] == i: + inds_source_, inds_target_ = inds_source[cur_inds], inds_target[cur_inds] + if len(inds_source_) == len(inds_target_): + mapper[inds_source_, inds_target_] = 1 + else: + ratio = 1 / len(inds_target_) + for i_t in inds_target_: + mapper[inds_source_, i_t] = ratio + cur_inds += 1 + i += len(inds_source_) + j += len(inds_target_) + elif cur_inds < len(inds_source): + mapper[i, j] = 1 + i += 1 + j += 1 + else: + mapper[j, j] = 1 + i += 1 + j += 1 + + return torch.from_numpy(mapper).float() + + + +def get_replacement_mapper(prompts, tokenizer, max_len=77): + x_seq = prompts[0] + mappers = [] + for i in range(1, len(prompts)): + mapper = get_replacement_mapper_(x_seq, prompts[i], tokenizer, max_len) + mappers.append(mapper) + return torch.stack(mappers) + diff --git a/textual-inversion/textual_inversion.py b/textual-inversion/textual_inversion.py new file mode 100644 index 0000000..e278736 --- /dev/null +++ b/textual-inversion/textual_inversion.py @@ -0,0 +1,927 @@ +#!/usr/bin/env python + +# Adapted with almost no modifications from +# https://github.com/huggingface/diffusers/tree/3d2648d743e4257c550bba03242486b1f3834838/examples/textual_inversion + +# coding=utf-8 +# Copyright 2023 The HuggingFace Inc. team. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and + +import argparse +import logging +import math +import os +import random +import warnings +from pathlib import Path +from typing import Optional +import glob + +import numpy as np +import PIL +import torch +import torch.nn.functional as F +import torch.utils.checkpoint +import transformers +from accelerate import Accelerator +from accelerate.logging import get_logger +from accelerate.utils import ProjectConfiguration, set_seed +from huggingface_hub import HfFolder, Repository, create_repo, whoami + +# TODO: remove and import from diffusers.utils when the new version of diffusers is released +from packaging import version +from PIL import Image +from torch.utils.data import Dataset +from torchvision import transforms +from tqdm.auto import tqdm +from transformers import CLIPTextModel, CLIPTokenizer + +import diffusers +from diffusers import ( + AutoencoderKL, + DDPMScheduler, + DiffusionPipeline, + DPMSolverMultistepScheduler, + StableDiffusionPipeline, + UNet2DConditionModel, +) +from diffusers.optimization import get_scheduler +from diffusers.utils import check_min_version, is_wandb_available +from diffusers.utils.import_utils import is_xformers_available + + +if is_wandb_available(): + import wandb + +if version.parse(version.parse(PIL.__version__).base_version) >= version.parse("9.1.0"): + PIL_INTERPOLATION = { + "linear": PIL.Image.Resampling.BILINEAR, + "bilinear": PIL.Image.Resampling.BILINEAR, + "bicubic": PIL.Image.Resampling.BICUBIC, + "lanczos": PIL.Image.Resampling.LANCZOS, + "nearest": PIL.Image.Resampling.NEAREST, + } +else: + PIL_INTERPOLATION = { + "linear": PIL.Image.LINEAR, + "bilinear": PIL.Image.BILINEAR, + "bicubic": PIL.Image.BICUBIC, + "lanczos": PIL.Image.LANCZOS, + "nearest": PIL.Image.NEAREST, + } +# ------------------------------------------------------------------------------ + + +# Will error if the minimal version of diffusers is not installed. Remove at your own risks. +check_min_version("0.15.0.dev0") + +logger = get_logger(__name__) + + +def log_validation(text_encoder, tokenizer, unet, vae, args, accelerator, weight_dtype, epoch): + logger.info( + f"Running validation... \n Generating {args.num_validation_images} images with prompt:" + f" {args.validation_prompt}." + ) + # create pipeline (note: unet and vae are loaded again in float32) + pipeline = DiffusionPipeline.from_pretrained( + args.pretrained_model_name_or_path, + text_encoder=accelerator.unwrap_model(text_encoder), + tokenizer=tokenizer, + unet=unet, + vae=vae, + revision=args.revision, + torch_dtype=weight_dtype, + ) + pipeline.scheduler = DPMSolverMultistepScheduler.from_config(pipeline.scheduler.config) + pipeline = pipeline.to(accelerator.device) + pipeline.set_progress_bar_config(disable=True) + + # run inference + generator = None if args.seed is None else torch.Generator(device=accelerator.device).manual_seed(args.seed) + images = [] + for _ in range(args.num_validation_images): + with torch.autocast("cuda"): + image = pipeline(args.validation_prompt, num_inference_steps=25, generator=generator).images[0] + images.append(image) + + for tracker in accelerator.trackers: + if tracker.name == "tensorboard": + np_images = np.stack([np.asarray(img) for img in images]) + tracker.writer.add_images("validation", np_images, epoch, dataformats="NHWC") + if tracker.name == "wandb": + tracker.log( + { + "validation": [ + wandb.Image(image, caption=f"{i}: {args.validation_prompt}") for i, image in enumerate(images) + ] + } + ) + + del pipeline + torch.cuda.empty_cache() + + +def save_progress(text_encoder, placeholder_token_id, accelerator, args, save_path): + logger.info("Saving embeddings") + learned_embeds = accelerator.unwrap_model(text_encoder).get_input_embeddings().weight[placeholder_token_id] + learned_embeds_dict = {args.placeholder_token: learned_embeds.detach().cpu()} + torch.save(learned_embeds_dict, save_path) + + +def parse_args(): + parser = argparse.ArgumentParser(description="Simple example of a training script.") + parser.add_argument( + "--save_steps", + type=int, + default=500, + help="Save learned_embeds.bin every X updates steps.", + ) + parser.add_argument( + "--only_save_embeds", + action="store_true", + default=False, + help="Save only the embeddings for the new concept.", + ) + parser.add_argument( + "--pretrained_model_name_or_path", + type=str, + default=None, + required=True, + help="Path to pretrained model or model identifier from huggingface.co/models.", + ) + parser.add_argument( + "--revision", + type=str, + default=None, + required=False, + help="Revision of pretrained model identifier from huggingface.co/models.", + ) + parser.add_argument( + "--tokenizer_name", + type=str, + default=None, + help="Pretrained tokenizer name or path if not the same as model_name", + ) + parser.add_argument( + "--train_data_dir", type=str, default=None, required=True, help="A folder containing the training data." + ) + parser.add_argument( + "--placeholder_token", + type=str, + default=None, + required=True, + help="A token to use as a placeholder for the concept.", + ) + parser.add_argument( + "--initializer_token", type=str, default=None, required=True, help="A token to use as initializer word." + ) + parser.add_argument("--learnable_property", type=str, default="object", help="Choose between 'object' and 'style'") + parser.add_argument("--repeats", type=int, default=100, help="How many times to repeat the training data.") + parser.add_argument( + "--output_dir", + type=str, + default="text-inversion-model", + help="The output directory where the model predictions and checkpoints will be written.", + ) + parser.add_argument("--seed", type=int, default=None, help="A seed for reproducible training.") + parser.add_argument( + "--resolution", + type=int, + default=512, + help=( + "The resolution for input images, all the images in the train/validation dataset will be resized to this" + " resolution" + ), + ) + parser.add_argument( + "--center_crop", action="store_true", help="Whether to center crop images before resizing to resolution." + ) + parser.add_argument( + "--train_batch_size", type=int, default=16, help="Batch size (per device) for the training dataloader." + ) + parser.add_argument("--num_train_epochs", type=int, default=100) + parser.add_argument( + "--max_train_steps", + type=int, + default=5000, + help="Total number of training steps to perform. If provided, overrides num_train_epochs.", + ) + parser.add_argument( + "--gradient_accumulation_steps", + type=int, + default=1, + help="Number of updates steps to accumulate before performing a backward/update pass.", + ) + parser.add_argument( + "--gradient_checkpointing", + action="store_true", + help="Whether or not to use gradient checkpointing to save memory at the expense of slower backward pass.", + ) + parser.add_argument( + "--learning_rate", + type=float, + default=1e-4, + help="Initial learning rate (after the potential warmup period) to use.", + ) + parser.add_argument( + "--scale_lr", + action="store_true", + default=False, + help="Scale the learning rate by the number of GPUs, gradient accumulation steps, and batch size.", + ) + parser.add_argument( + "--lr_scheduler", + type=str, + default="constant", + help=( + 'The scheduler type to use. Choose between ["linear", "cosine", "cosine_with_restarts", "polynomial",' + ' "constant", "constant_with_warmup"]' + ), + ) + parser.add_argument( + "--lr_warmup_steps", type=int, default=500, help="Number of steps for the warmup in the lr scheduler." + ) + parser.add_argument( + "--dataloader_num_workers", + type=int, + default=0, + help=( + "Number of subprocesses to use for data loading. 0 means that the data will be loaded in the main process." + ), + ) + parser.add_argument("--adam_beta1", type=float, default=0.9, help="The beta1 parameter for the Adam optimizer.") + parser.add_argument("--adam_beta2", type=float, default=0.999, help="The beta2 parameter for the Adam optimizer.") + parser.add_argument("--adam_weight_decay", type=float, default=1e-2, help="Weight decay to use.") + parser.add_argument("--adam_epsilon", type=float, default=1e-08, help="Epsilon value for the Adam optimizer") + parser.add_argument("--push_to_hub", action="store_true", help="Whether or not to push the model to the Hub.") + parser.add_argument("--hub_token", type=str, default=None, help="The token to use to push to the Model Hub.") + parser.add_argument( + "--hub_model_id", + type=str, + default=None, + help="The name of the repository to keep in sync with the local `output_dir`.", + ) + parser.add_argument( + "--logging_dir", + type=str, + default="logs", + help=( + "[TensorBoard](https://www.tensorflow.org/tensorboard) log directory. Will default to" + " *output_dir/runs/**CURRENT_DATETIME_HOSTNAME***." + ), + ) + parser.add_argument( + "--mixed_precision", + type=str, + default="no", + choices=["no", "fp16", "bf16"], + help=( + "Whether to use mixed precision. Choose" + "between fp16 and bf16 (bfloat16). Bf16 requires PyTorch >= 1.10." + "and an Nvidia Ampere GPU." + ), + ) + parser.add_argument( + "--allow_tf32", + action="store_true", + help=( + "Whether or not to allow TF32 on Ampere GPUs. Can be used to speed up training. For more information, see" + " https://pytorch.org/docs/stable/notes/cuda.html#tensorfloat-32-tf32-on-ampere-devices" + ), + ) + parser.add_argument( + "--report_to", + type=str, + default="tensorboard", + help=( + 'The integration to report the results and logs to. Supported platforms are `"tensorboard"`' + ' (default), `"wandb"` and `"comet_ml"`. Use `"all"` to report to all integrations.' + ), + ) + parser.add_argument( + "--validation_prompt", + type=str, + default=None, + help="A prompt that is used during validation to verify that the model is learning.", + ) + parser.add_argument( + "--num_validation_images", + type=int, + default=4, + help="Number of images that should be generated during validation with `validation_prompt`.", + ) + parser.add_argument( + "--validation_steps", + type=int, + default=100, + help=( + "Run validation every X steps. Validation consists of running the prompt" + " `args.validation_prompt` multiple times: `args.num_validation_images`" + " and logging the images." + ), + ) + parser.add_argument( + "--validation_epochs", + type=int, + default=None, + help=( + "Deprecated in favor of validation_steps. Run validation every X epochs. Validation consists of running the prompt" + " `args.validation_prompt` multiple times: `args.num_validation_images`" + " and logging the images." + ), + ) + parser.add_argument("--local_rank", type=int, default=-1, help="For distributed training: local_rank") + parser.add_argument( + "--checkpointing_steps", + type=int, + default=500, + help=( + "Save a checkpoint of the training state every X updates. These checkpoints are only suitable for resuming" + " training using `--resume_from_checkpoint`." + ), + ) + parser.add_argument( + "--checkpoints_total_limit", + type=int, + default=None, + help=( + "Max number of checkpoints to store. Passed as `total_limit` to the `Accelerator` `ProjectConfiguration`." + " See Accelerator::save_state https://huggingface.co/docs/accelerate/package_reference/accelerator#accelerate.Accelerator.save_state" + " for more docs" + ), + ) + parser.add_argument( + "--resume_from_checkpoint", + type=str, + default=None, + help=( + "Whether training should be resumed from a previous checkpoint. Use a path saved by" + ' `--checkpointing_steps`, or `"latest"` to automatically select the last available checkpoint.' + ), + ) + parser.add_argument( + "--enable_xformers_memory_efficient_attention", action="store_true", help="Whether or not to use xformers." + ) + + # New: heavy image augmentations + parser.add_argument( + "--use_augmentations", action="store_true", help="Whether or not to use heavy image augmentations." + ) + + args = parser.parse_args() + env_local_rank = int(os.environ.get("LOCAL_RANK", -1)) + if env_local_rank != -1 and env_local_rank != args.local_rank: + args.local_rank = env_local_rank + + if args.train_data_dir is None: + raise ValueError("You must specify a train data directory.") + + return args + + +imagenet_templates_small = [ + "a photo of a {}", + "a rendering of a {}", + "a cropped photo of the {}", + "the photo of a {}", + "a photo of a clean {}", + "a photo of a dirty {}", + "a dark photo of the {}", + "a photo of my {}", + "a photo of the cool {}", + "a close-up photo of a {}", + "a bright photo of the {}", + "a cropped photo of a {}", + "a photo of the {}", + "a good photo of the {}", + "a photo of one {}", + "a close-up photo of the {}", + "a rendition of the {}", + "a photo of the clean {}", + "a rendition of a {}", + "a photo of a nice {}", + "a good photo of a {}", + "a photo of the nice {}", + "a photo of the small {}", + "a photo of the weird {}", + "a photo of the large {}", + "a photo of a cool {}", + "a photo of a small {}", +] + +imagenet_style_templates_small = [ + "a painting in the style of {}", + "a rendering in the style of {}", + "a cropped painting in the style of {}", + "the painting in the style of {}", + "a clean painting in the style of {}", + "a dirty painting in the style of {}", + "a dark painting in the style of {}", + "a picture in the style of {}", + "a cool painting in the style of {}", + "a close-up painting in the style of {}", + "a bright painting in the style of {}", + "a cropped painting in the style of {}", + "a good painting in the style of {}", + "a close-up painting in the style of {}", + "a rendition in the style of {}", + "a nice painting in the style of {}", + "a small painting in the style of {}", + "a weird painting in the style of {}", + "a large painting in the style of {}", +] + + +class TextualInversionDataset(Dataset): + def __init__( + self, + data_root, + tokenizer, + learnable_property="object", # [object, style] + size=512, + repeats=100, + interpolation="bicubic", + flip_p=0.5, + set="train", + placeholder_token="*", + center_crop=False, + use_augmentations=False, + ): + self.data_root = data_root + self.tokenizer = tokenizer + self.learnable_property = learnable_property + self.size = size + self.placeholder_token = placeholder_token + self.center_crop = center_crop + self.flip_p = flip_p + + #self.image_paths = [os.path.join(self.data_root, file_path) for file_path in os.listdir(self.data_root)] + self.image_paths = [self.data_root] + self.num_images = len(self.image_paths) + self._length = self.num_images + + if set == "train": + self._length = self.num_images * repeats + + self.interpolation = { + "linear": PIL_INTERPOLATION["linear"], + "bilinear": PIL_INTERPOLATION["bilinear"], + "bicubic": PIL_INTERPOLATION["bicubic"], + "lanczos": PIL_INTERPOLATION["lanczos"], + }[interpolation] + + self.templates = imagenet_style_templates_small if learnable_property == "style" else imagenet_templates_small + self.flip_transform = transforms.RandomHorizontalFlip(p=self.flip_p) + + self.use_augmentations = use_augmentations + if self.use_augmentations: + # This is unnecessarily convoluted because I previously used the albumentations library, but + # I wanted to remove that dependency. In torchvision, there is no good way of randomly rotating + # and then cropping into the rotation by the correct amount such that there is no padding. But + # this is a hack that works ok for that case. + self.aug_transform = transforms.Compose([ + transforms.Resize(int(self.size * 5/4)), + transforms.CenterCrop(int(self.size * 5/4)), + transforms.RandomApply([ + transforms.RandomRotation(degrees=10, fill=255), + transforms.CenterCrop(int(self.size * 5/6)), + transforms.Resize(self.size), + ], p=0.75), + transforms.RandomResizedCrop(self.size, scale=(0.85, 1.15)), + transforms.RandomApply([transforms.ColorJitter(0.04, 0.04, 0.04, 0.04)], p=0.75), + transforms.RandomGrayscale(p=0.10), + transforms.RandomApply([transforms.GaussianBlur(5, (0.1, 2))], p=0.10), + transforms.RandomHorizontalFlip(), + transforms.ToTensor(), + ]) + + + def __len__(self): + return self._length + + def __getitem__(self, i): + example = {} + image = Image.open(self.image_paths[i % self.num_images]) + + if not image.mode == "RGB": + image = image.convert("RGB") + + placeholder_string = self.placeholder_token + text = random.choice(self.templates).format(placeholder_string) + + example["input_ids"] = self.tokenizer( + text, + padding="max_length", + truncation=True, + max_length=self.tokenizer.model_max_length, + return_tensors="pt", + ).input_ids[0] + + # default to score-sde preprocessing + img = np.array(image).astype(np.uint8) + + if self.center_crop: + crop = min(img.shape[0], img.shape[1]) + ( + h, + w, + ) = ( + img.shape[0], + img.shape[1], + ) + img = img[(h - crop) // 2 : (h + crop) // 2, (w - crop) // 2 : (w + crop) // 2] + + image = Image.fromarray(img) + if self.use_augmentations: + image = self.aug_transform(image) + else: + image = image.resize((self.size, self.size), resample=self.interpolation) + image = self.flip_transform(image) + image = np.array(image).astype(np.uint8) + image = (image / 127.5 - 1.0).astype(np.float32) + image = torch.from_numpy(image).permute(2, 0, 1) + + example["pixel_values"] = image + return example + + +def get_full_repo_name(model_id: str, organization: Optional[str] = None, token: Optional[str] = None): + if token is None: + token = HfFolder.get_token() + if organization is None: + username = whoami(token)["name"] + return f"{username}/{model_id}" + else: + return f"{organization}/{model_id}" + + +def main(): + args = parse_args() + logging_dir = os.path.join(args.output_dir, args.logging_dir) + + accelerator_project_config = ProjectConfiguration(total_limit=args.checkpoints_total_limit) + + accelerator = Accelerator( + gradient_accumulation_steps=args.gradient_accumulation_steps, + mixed_precision=args.mixed_precision, + log_with=args.report_to, + project_dir=logging_dir, + project_config=accelerator_project_config, + ) + + if args.report_to == "wandb": + if not is_wandb_available(): + raise ImportError("Make sure to install wandb if you want to use it for logging during training.") + + # Make one log on every process with the configuration for debugging. + logging.basicConfig( + format="%(asctime)s - %(levelname)s - %(name)s - %(message)s", + datefmt="%m/%d/%Y %H:%M:%S", + level=logging.INFO, + ) + logger.info(args) + logger.info(accelerator.state, main_process_only=False) + if accelerator.is_local_main_process: + transformers.utils.logging.set_verbosity_warning() + diffusers.utils.logging.set_verbosity_info() + else: + transformers.utils.logging.set_verbosity_error() + diffusers.utils.logging.set_verbosity_error() + + # If passed along, set the training seed now. + if args.seed is not None: + set_seed(args.seed) + + # Handle the repository creation + if accelerator.is_main_process: + if args.push_to_hub: + if args.hub_model_id is None: + repo_name = get_full_repo_name(Path(args.output_dir).name, token=args.hub_token) + else: + repo_name = args.hub_model_id + create_repo(repo_name, exist_ok=True, token=args.hub_token) + repo = Repository(args.output_dir, clone_from=repo_name, token=args.hub_token) + + with open(os.path.join(args.output_dir, ".gitignore"), "w+") as gitignore: + if "step_*" not in gitignore: + gitignore.write("step_*\n") + if "epoch_*" not in gitignore: + gitignore.write("epoch_*\n") + elif args.output_dir is not None: + os.makedirs(args.output_dir, exist_ok=True) + + # Load tokenizer + if args.tokenizer_name: + tokenizer = CLIPTokenizer.from_pretrained(args.tokenizer_name) + elif args.pretrained_model_name_or_path: + tokenizer = CLIPTokenizer.from_pretrained(args.pretrained_model_name_or_path, subfolder="tokenizer") + + # Load scheduler and models + noise_scheduler = DDPMScheduler.from_pretrained(args.pretrained_model_name_or_path, subfolder="scheduler") + text_encoder = CLIPTextModel.from_pretrained( + args.pretrained_model_name_or_path, subfolder="text_encoder", revision=args.revision + ) + vae = AutoencoderKL.from_pretrained(args.pretrained_model_name_or_path, subfolder="vae", revision=args.revision) + unet = UNet2DConditionModel.from_pretrained( + args.pretrained_model_name_or_path, subfolder="unet", revision=args.revision + ) + + # Add the placeholder token in tokenizer + num_added_tokens = tokenizer.add_tokens(args.placeholder_token) + if num_added_tokens == 0: + raise ValueError( + f"The tokenizer already contains the token {args.placeholder_token}. Please pass a different" + " `placeholder_token` that is not already in the tokenizer." + ) + + # Convert the initializer_token, placeholder_token to ids + token_ids = tokenizer.encode(args.initializer_token, add_special_tokens=False) + # Check if initializer_token is a single token or a sequence of tokens + if len(token_ids) > 1: + raise ValueError("The initializer token must be a single token.") + + initializer_token_id = token_ids[0] + placeholder_token_id = tokenizer.convert_tokens_to_ids(args.placeholder_token) + + # Resize the token embeddings as we are adding new special tokens to the tokenizer + text_encoder.resize_token_embeddings(len(tokenizer)) + + # Initialise the newly added placeholder token with the embeddings of the initializer token + token_embeds = text_encoder.get_input_embeddings().weight.data + token_embeds[placeholder_token_id] = token_embeds[initializer_token_id] + + # Freeze vae and unet + vae.requires_grad_(False) + unet.requires_grad_(False) + # Freeze all parameters except for the token embeddings in text encoder + text_encoder.text_model.encoder.requires_grad_(False) + text_encoder.text_model.final_layer_norm.requires_grad_(False) + text_encoder.text_model.embeddings.position_embedding.requires_grad_(False) + + if args.gradient_checkpointing: + # Keep unet in train mode if we are using gradient checkpointing to save memory. + # The dropout cannot be != 0 so it doesn't matter if we are in eval or train mode. + unet.train() + text_encoder.gradient_checkpointing_enable() + unet.enable_gradient_checkpointing() + + if args.enable_xformers_memory_efficient_attention: + if is_xformers_available(): + import xformers + + xformers_version = version.parse(xformers.__version__) + if xformers_version == version.parse("0.0.16"): + logger.warn( + "xFormers 0.0.16 cannot be used for training in some GPUs. If you observe problems during training, please update xFormers to at least 0.0.17. See https://huggingface.co/docs/diffusers/main/en/optimization/xformers for more details." + ) + unet.enable_xformers_memory_efficient_attention() + else: + raise ValueError("xformers is not available. Make sure it is installed correctly") + + # Enable TF32 for faster training on Ampere GPUs, + # cf https://pytorch.org/docs/stable/notes/cuda.html#tensorfloat-32-tf32-on-ampere-devices + if args.allow_tf32: + torch.backends.cuda.matmul.allow_tf32 = True + + if args.scale_lr: + args.learning_rate = ( + args.learning_rate * args.gradient_accumulation_steps * args.train_batch_size * accelerator.num_processes + ) + + # Initialize the optimizer + optimizer = torch.optim.AdamW( + text_encoder.get_input_embeddings().parameters(), # only optimize the embeddings + lr=args.learning_rate, + betas=(args.adam_beta1, args.adam_beta2), + weight_decay=args.adam_weight_decay, + eps=args.adam_epsilon, + ) + + # Dataset and DataLoaders creation: + train_dataset = TextualInversionDataset( + data_root=args.train_data_dir, + tokenizer=tokenizer, + size=args.resolution, + placeholder_token=args.placeholder_token, + repeats=args.repeats, + learnable_property=args.learnable_property, + center_crop=args.center_crop, + set="train", + use_augmentations=args.use_augmentations, + ) + train_dataloader = torch.utils.data.DataLoader( + train_dataset, batch_size=args.train_batch_size, shuffle=True, num_workers=args.dataloader_num_workers + ) + if args.validation_epochs is not None: + warnings.warn( + f"FutureWarning: You are doing logging with validation_epochs={args.validation_epochs}." + " Deprecated validation_epochs in favor of `validation_steps`" + f"Setting `args.validation_steps` to {args.validation_epochs * len(train_dataset)}", + FutureWarning, + stacklevel=2, + ) + args.validation_steps = args.validation_epochs * len(train_dataset) + + # Scheduler and math around the number of training steps. + overrode_max_train_steps = False + num_update_steps_per_epoch = math.ceil(len(train_dataloader) / args.gradient_accumulation_steps) + if args.max_train_steps is None: + args.max_train_steps = args.num_train_epochs * num_update_steps_per_epoch + overrode_max_train_steps = True + + lr_scheduler = get_scheduler( + args.lr_scheduler, + optimizer=optimizer, + num_warmup_steps=args.lr_warmup_steps * args.gradient_accumulation_steps, + num_training_steps=args.max_train_steps * args.gradient_accumulation_steps, + ) + + # Prepare everything with our `accelerator`. + text_encoder, optimizer, train_dataloader, lr_scheduler = accelerator.prepare( + text_encoder, optimizer, train_dataloader, lr_scheduler + ) + + # For mixed precision training we cast the unet and vae weights to half-precision + # as these models are only used for inference, keeping weights in full precision is not required. + weight_dtype = torch.float32 + if accelerator.mixed_precision == "fp16": + weight_dtype = torch.float16 + elif accelerator.mixed_precision == "bf16": + weight_dtype = torch.bfloat16 + + # Move vae and unet to device and cast to weight_dtype + unet.to(accelerator.device, dtype=weight_dtype) + vae.to(accelerator.device, dtype=weight_dtype) + + # We need to recalculate our total training steps as the size of the training dataloader may have changed. + num_update_steps_per_epoch = math.ceil(len(train_dataloader) / args.gradient_accumulation_steps) + if overrode_max_train_steps: + args.max_train_steps = args.num_train_epochs * num_update_steps_per_epoch + # Afterwards we recalculate our number of training epochs + args.num_train_epochs = math.ceil(args.max_train_steps / num_update_steps_per_epoch) + + # We need to initialize the trackers we use, and also store our configuration. + # The trackers initializes automatically on the main process. + if accelerator.is_main_process: + accelerator.init_trackers("textual_inversion", config=vars(args)) + + # Train! + total_batch_size = args.train_batch_size * accelerator.num_processes * args.gradient_accumulation_steps + + logger.info("***** Running training *****") + logger.info(f" Num examples = {len(train_dataset)}") + logger.info(f" Num Epochs = {args.num_train_epochs}") + logger.info(f" Instantaneous batch size per device = {args.train_batch_size}") + logger.info(f" Total train batch size (w. parallel, distributed & accumulation) = {total_batch_size}") + logger.info(f" Gradient Accumulation steps = {args.gradient_accumulation_steps}") + logger.info(f" Total optimization steps = {args.max_train_steps}") + global_step = 0 + first_epoch = 0 + # Potentially load in the weights and states from a previous save + if args.resume_from_checkpoint: + if args.resume_from_checkpoint != "latest": + path = os.path.basename(args.resume_from_checkpoint) + else: + # Get the most recent checkpoint + dirs = os.listdir(args.output_dir) + dirs = [d for d in dirs if d.startswith("checkpoint")] + dirs = sorted(dirs, key=lambda x: int(x.split("-")[1])) + path = dirs[-1] if len(dirs) > 0 else None + + if path is None: + accelerator.print( + f"Checkpoint '{args.resume_from_checkpoint}' does not exist. Starting a new training run." + ) + args.resume_from_checkpoint = None + else: + accelerator.print(f"Resuming from checkpoint {path}") + accelerator.load_state(os.path.join(args.output_dir, path)) + global_step = int(path.split("-")[1]) + + resume_global_step = global_step * args.gradient_accumulation_steps + first_epoch = global_step // num_update_steps_per_epoch + resume_step = resume_global_step % (num_update_steps_per_epoch * args.gradient_accumulation_steps) + + # Only show the progress bar once on each machine. + progress_bar = tqdm(range(global_step, args.max_train_steps), disable=not accelerator.is_local_main_process) + progress_bar.set_description("Steps") + + # keep original embeddings as reference + orig_embeds_params = accelerator.unwrap_model(text_encoder).get_input_embeddings().weight.data.clone() + + for epoch in range(first_epoch, args.num_train_epochs): + text_encoder.train() + for step, batch in enumerate(train_dataloader): + # Skip steps until we reach the resumed step + if args.resume_from_checkpoint and epoch == first_epoch and step < resume_step: + if step % args.gradient_accumulation_steps == 0: + progress_bar.update(1) + continue + + with accelerator.accumulate(text_encoder): + # Convert images to latent space + latents = vae.encode(batch["pixel_values"].to(dtype=weight_dtype)).latent_dist.sample().detach() + latents = latents * vae.config.scaling_factor + + # Sample noise that we'll add to the latents + noise = torch.randn_like(latents) + bsz = latents.shape[0] + # Sample a random timestep for each image + timesteps = torch.randint(0, noise_scheduler.config.num_train_timesteps, (bsz,), device=latents.device) + timesteps = timesteps.long() + + # Add noise to the latents according to the noise magnitude at each timestep + # (this is the forward diffusion process) + noisy_latents = noise_scheduler.add_noise(latents, noise, timesteps) + + # Get the text embedding for conditioning + encoder_hidden_states = text_encoder(batch["input_ids"])[0].to(dtype=weight_dtype) + + # Predict the noise residual + model_pred = unet(noisy_latents, timesteps, encoder_hidden_states).sample + + # Get the target for loss depending on the prediction type + if noise_scheduler.config.prediction_type == "epsilon": + target = noise + elif noise_scheduler.config.prediction_type == "v_prediction": + target = noise_scheduler.get_velocity(latents, noise, timesteps) + else: + raise ValueError(f"Unknown prediction type {noise_scheduler.config.prediction_type}") + + loss = F.mse_loss(model_pred.float(), target.float(), reduction="mean") + + accelerator.backward(loss) + + optimizer.step() + lr_scheduler.step() + optimizer.zero_grad() + + # Let's make sure we don't update any embedding weights besides the newly added token + index_no_updates = torch.arange(len(tokenizer)) != placeholder_token_id + with torch.no_grad(): + accelerator.unwrap_model(text_encoder).get_input_embeddings().weight[ + index_no_updates + ] = orig_embeds_params[index_no_updates] + + # Checks if the accelerator has performed an optimization step behind the scenes + if accelerator.sync_gradients: + progress_bar.update(1) + global_step += 1 + if global_step % args.save_steps == 0: + save_path = os.path.join(args.output_dir, f"learned_embeds-steps-{global_step}.bin") + save_progress(text_encoder, placeholder_token_id, accelerator, args, save_path) + + if global_step % args.checkpointing_steps == 0: + if accelerator.is_main_process: + save_path = os.path.join(args.output_dir, f"checkpoint-{global_step}") + accelerator.save_state(save_path) + logger.info(f"Saved state to {save_path}") + if args.validation_prompt is not None and global_step % args.validation_steps == 0: + log_validation(text_encoder, tokenizer, unet, vae, args, accelerator, weight_dtype, epoch) + + logs = {"loss": loss.detach().item(), "lr": lr_scheduler.get_last_lr()[0]} + progress_bar.set_postfix(**logs) + accelerator.log(logs, step=global_step) + + if global_step >= args.max_train_steps: + break + # Create the pipeline using using the trained modules and save it. + accelerator.wait_for_everyone() + if accelerator.is_main_process: + if args.push_to_hub and args.only_save_embeds: + logger.warn("Enabling full model saving because --push_to_hub=True was specified.") + save_full_model = True + else: + save_full_model = not args.only_save_embeds + if save_full_model: + pipeline = StableDiffusionPipeline.from_pretrained( + args.pretrained_model_name_or_path, + text_encoder=accelerator.unwrap_model(text_encoder), + vae=vae, + unet=unet, + tokenizer=tokenizer, + ) + pipeline.save_pretrained(args.output_dir) + # Save the newly trained embeddings + save_path = os.path.join(args.output_dir, "learned_embeds.bin") + save_progress(text_encoder, placeholder_token_id, accelerator, args, save_path) + + if args.push_to_hub: + repo.push_to_hub(commit_message="End of training", blocking=False, auto_lfs_prune=True) + + accelerator.end_training() + + +if __name__ == "__main__": + main()