Code Refactoring - Initial Version

README.md

@@ -9,19 +9,46 @@ license: cc-by-nc-sa-4.0
 short_description: The code of gg prior.
 ---
 
-# Nerfies
-
-This is the repository that contains source code for the [Nerfies website](https://nerfies.github.io).
-
-If you find Nerfies useful for your work please cite:
-```
-@article{park2021nerfies
-  author    = {Park, Keunhong and Sinha, Utkarsh and Barron, Jonathan T. and Bouaziz, Sofien and Goldman, Dan B and Seitz, Steven M. and Martin-Brualla, Ricardo},
-  title     = {Nerfies: Deformable Neural Radiance Fields},
-  journal   = {ICCV},
-  year      = {2021},
-}
-```
+# Introduction
+- Reference: It Takes a Good Model to Train a Good Model: Generalized Gaussian Priors for Optimized LLMs
+- Authors: Jun Wu, Yirong Xiong, Jiangtao Wen, Yuxing Han
+- Paper Link: [https://services.arxiv.org/html/submission/6499264/view](https://services.arxiv.org/html/submission/6499264/view)
+
+This repository provides a complete implementation of the methods described in the corresponding paper. Specifically, we implement the Generalized Gaussian Initialization, DeepShape, and the RF8 floating-point format as proposed in the paper. Furthermore, we adapt and reproduce the BackSlash training algorithm, and incorporate it seamlessly into our framework based on generalized Gaussian priors.
+
+
+# BackSlash
+- Reference: BackSlash: Rate Constrained Optimized Training of Large Language Models
+- Authors: Jun Wu, Jiangtao Wen, Yuxing Han
+- Paper Link: [https://arxiv.org/abs/2504.16968](https://arxiv.org/abs/2504.16968)
+
+We reproduced the BackSlash training algorithm based on the algorithm diagram provided in the source paper, and assisted us in conducting more in-depth research on generalized Gaussian priors.
+
+In BackSlash, estimating the shape parameters of the model parameter distribution requires looking up the mapping between $\rho(\nu)$ and $\nu$. To achieve this, we precompute the values of $\nu$ and $\rho(\nu)$ over the interval $[0.1,\, 3.0]$ with a step size of $0.01$, and store them in `data/gamma_table.pt` (for $\nu$) and `data/r\_gamma\_table.pt` (for $\rho(\nu)$), respectively.
+
+The code for reproducing the shape parameter estimation and the BackSlash algorithm is stored in the `backslash.py` module. During model training, after each batch iteration, the BackSlash function is invoked to perform rate suppression on the model parameters. After a few epochs of BackSlash training, we further fine-tune the model using several epochs of standard training. This helps the model achieve significantly improved performance while maintaining a low bit rate. The same procedure is applied consistently across all experiments.
+
+# Generalized Gaussian Initialization
+
+The Generalized Gaussian Initialization algorithm is implemented in the file `gg_init.py`. In practice, this initialization function is applied to all linear layers of the model prior to the start of training.
+
+The generalized Gaussian initialization takes two parameters: `shape` and `xi`. 
+
+- `shape` represents the user-specified shape parameter for generalized Gaussian initialization, which affects the parameter distribution during initialization.
+- `xi` represents the user-specified activation function coefficient, whose value is determined by the specific type of activation function.
+
+# DeepShape
+
+The implementation of DeepShape is preserved in the file `deepshape.py`. We apply the classical image processing technique "histogram equalization" to adjust the parameter distribution of post-trained models.
+
+While DeepShape effectively compresses parameter bitrate, it inevitably impacts model prediction accuracy. This effect on model performance can be mitigated through a limited number of post-training epochs.
+
+# 8-bit Residual Floating-Point Format
+
+The implementation method of the RF8 floating-point format is documented in the file `rf8.py`. In this paper, we only quantize the model parameters to RF8 format before inference, without considering the training scenario or quantizing the activation values during forward propagation in inference.
+
+In RF8 format, all model parameters will be preserved as only the sum of the first two significant digits in their binary representation. The multiplicative relationship between these two significant digits does not exceed $2^{4}$.
+
 
 # Website License
 <a rel="license" href="http://creativecommons.org/licenses/by-sa/4.0/"><img alt="Creative Commons License" style="border-width:0" src="https://i.creativecommons.org/l/by-sa/4.0/88x31.png" /></a><br />This work is licensed under a <a rel="license" href="http://creativecommons.org/licenses/by-sa/4.0/">Creative Commons Attribution-ShareAlike 4.0 International License</a>.

backslash.py

@@ -0,0 +1,26 @@
+import torch
+def backslash(model):
+    with torch.no_grad():
+        device = torch.device("cuda:0")
+        
+        # Evaluate the shape parameter
+        n, var, mean = 0, 0, 0
+        for param in model.parameters():
+            param = param.flatten().detach()
+            n += param.shape[0]
+            var += torch.sum((param ** 2).to(device))
+            mean += torch.sum(torch.abs(param).to(device))
+        r_gamma = (n * var / mean ** 2).to(device=torch.device("cpu"))
+        pos = torch.argmin(torch.abs(r_gamma - model.r_gamma_table))
+        shape = model.gamma_table[pos]
+        std = torch.sqrt(var / n)
+        n = torch.tensor(n)
+
+        # Rate Constrained Optimization
+        for param in model.parameters():
+            constant = model.rdo * shape / n * torch.sign(param.data)
+            param_reg = torch.pow(
+                torch.abs(param.data) + model.clip, shape - 1)
+            param.data -= constant * param_reg
+        distribution = {"shape": shape, "standard": std}
+    return distribution

deepshape.py

@@ -0,0 +1,152 @@
+import torch
+from utils.encode.quantizer import LinearQuantizer
+import math
+from scipy.special import gamma as Gamma
+import numpy  as np
+import dask.array as da
+
+
+class DeepShape:
+    def __init__(self):
+        self.gamma_table = torch.load('utils/gamma_table.pt')
+        self.rho_table = torch.load('utils/rho_table.pt')
+    
+    """estimate GGD parameters"""
+    def Calc_GG_params(self, model, adj_minnum = 0):
+        #get parameters
+        params = []
+        for param in model.parameters():
+            params.append(param.flatten())
+        params = torch.cat(params).detach()
+        params_org = params.clone()
+        
+        # Quantization
+        lq = LinearQuantizer(params, 13)
+        params = lq.quant(params)   
+        
+        #sorting
+        elements, counts = torch.unique(params, return_counts=True)   
+        # dask_params = da.from_array(params.numpy(), chunks=int(1e8))  #if param's size is big
+        # elements, counts = da.unique(dask_params, return_counts=True)
+        # elements = torch.from_numpy(elements.compute())
+        # counts = torch.from_numpy(counts.compute())
+        indices = torch.argsort(counts, descending=True)
+        elements = elements[indices]
+        counts = counts[indices]
+
+        if adj_minnum > 0:
+            param_max = torch.min(elements[(counts<=adj_minnum) & (elements>0)]).long()
+            # print("param_max", (param_max/(2**13)))
+            # print('max_param, num_max_param', (elements[0]/(2**13)), counts[0])
+            elements_cut = params_org[torch.abs(params_org)<=(param_max.float()/(2**13))]
+        else:
+            elements_cut = params_org
+
+        #estimate
+        n = len(elements_cut)
+        var = torch.sum(torch.pow(elements_cut, 2))
+        mean = torch.sum(torch.abs(elements_cut))
+        self.gamma_table = self.gamma_table.to(elements_cut.device)
+        self.rho_table = self.rho_table.to(elements_cut.device)
+        rho = n * var / mean ** 2
+        pos = torch.argmin(torch.abs(rho - self.rho_table)).item()
+        shape = self.gamma_table[pos].item()
+        std = torch.sqrt(var / n)
+        beta = math.sqrt(Gamma(1/shape) / Gamma(3/shape))* std
+        mu = torch.mean(elements_cut)
+        print("mu:", mu)
+        print('shape:', shape)
+        print('beta',(beta))
+        
+        return mu, shape, beta
+        
+    
+    """GGD deepshape remap"""
+    def GGD_deepshape(self, model, shape_scale=0.8, std_scale=0.6, adj_minnum = 1000): 
+        #get parameters
+        params = []
+        for param in model.parameters():
+            params.append(param.flatten())
+        params = torch.cat(params).detach()
+        params_org = params.clone()
+        
+        # Quantization
+        lq = LinearQuantizer(params, 13)
+        params = lq.quant(params)   
+        
+        #sorting
+        elements, counts = torch.unique(params, return_counts=True)
+        indices = torch.argsort(counts, descending=True)
+        elements = elements[indices]
+        counts = counts[indices]
+             
+        if adj_minnum > 0:
+            param_max = torch.min(elements[(counts<=adj_minnum) & (elements>0)]).long()
+            elements_cut = params_org[torch.abs(params_org)<=(param_max.float()/(2**13))]
+        else:
+            elements_cut = params_org
+            param_max=0
+        
+        #estimate org GGD    
+        n = len(elements_cut)
+        var = torch.sum(torch.pow(elements_cut, 2))
+        mean = torch.sum(torch.abs(elements_cut))
+        self.gamma_table = self.gamma_table.to(elements_cut.device)
+        self.rho_table = self.rho_table.to(elements_cut.device)
+        rho = n * var / mean ** 2
+        pos = torch.argmin(torch.abs(rho - self.rho_table)).item()
+        shape = self.gamma_table[pos].item()
+        std = torch.sqrt(var / n)
+        beta = math.sqrt(Gamma(1/shape) / Gamma(3/shape))* std
+        mu_est = torch.mean(elements_cut)
+    
+        print("org mu:", mu_est)
+        print('org shape:', shape)
+        print('org beta',beta)
+        
+        beta = (beta * (2**13))
+        mu_est = int(mu_est*(2**13))
+        
+        #sorting params in [-param_pax, param_max]  
+        if adj_minnum>0:
+            adj_indices = torch.nonzero((params>=mu_est-param_max)&(params<=mu_est+param_max), as_tuple=False).squeeze()
+            adj_indices = adj_indices[torch.argsort(params[(params>=mu_est-param_max)&(params<=mu_est+param_max)], descending=False)]
+            adj_num = len(adj_indices)
+        else:
+            adj_indices = torch.argsort(params, descending=False)
+            adj_num = len(adj_indices)
+            
+        #remape new GGD
+        new_params = params.clone()
+        new_shape = shape * shape_scale
+        new_beta = beta * std_scale
+        if(beta<=0):
+            beta=1
+        
+        x = torch.arange(mu_est-param_max, mu_est+param_max+1, device=params.device)
+        new_ratio = -torch.pow(torch.abs(x.float()-mu_est)/new_beta, new_shape)
+        new_ratio = torch.exp(new_ratio)
+        new_ratio = new_ratio / torch.sum(new_ratio)
+        new_num = (adj_num * new_ratio).long()
+        num_temp = 0
+        for i in range(0, 2*param_max+1):
+            new_params[adj_indices[num_temp : num_temp+new_num[i]]]=i+mu_est-param_max
+            num_temp += new_num[i]
+        new_params=new_params.float()/(2**13)
+        
+        #modify model parameters
+        j=0
+        for name, param in model.named_parameters():
+            shape=param.data.shape
+            param_flatten = torch.flatten(param.data)
+            param_flatten = new_params[j: j+len(param_flatten)]
+            j+=len(param_flatten)
+            param_flatten = param_flatten.reshape(shape)
+            param.data= param_flatten
+        
+        print("new mu:", float(mu_est)/(2**13))
+        print('new_shape:', new_shape)
+        print('new beta', float(new_beta)/(2**13))
+        return float(mu_est)/(2**13), new_shape, float(new_beta)/(2**13)
+    
+   

gg_init.py

@@ -0,0 +1,30 @@
+import torch
+from torch.nn import init
+from scipy.special import gamma as Gamma
+from scipy.stats import gennorm
+import numpy as np
+
+
+def gg_init(model, shape=2, xi=2):
+    """Generalized Gaussian Initialization for ReLU"""
+    # shape for the shape of parameter distribution
+    # xi = 1 for Sigmoid or no activation
+    # xi = 2 for ReLU
+    # xi = 2 / (1 + k^2) for LeakyReLU 
+    with torch.no_grad():
+        for name, param in model.named_parameters():
+            param_device = param.device
+            param_dtype = param.dtype
+            if len(param.shape) == 2:
+                n_dim = param.shape[0]
+                alpha = np.sqrt(xi/n_dim*Gamma(1/shape) / Gamma(3/shape))
+                gennorm_params = gennorm.rvs(
+                    shape, loc=0, scale=alpha, size=param.shape)
+                param.data = torch.from_numpy(gennorm_params)
+            else:
+                if "weight" in name:
+                    param.data = torch.ones(param.shape)
+                elif "bias" in name:
+                    param.data = torch.zeros(param.shape)
+
+            param.data = param.data.to(param_dtype).to(param_device)

index.html

@@ -1,435 +0,0 @@
-<!DOCTYPE html>
-<html>
-<head>
-  <meta charset="utf-8">
-  <meta name="description"
-        content="Deformable Neural Radiance Fields creates free-viewpoint portraits (nerfies) from casually captured videos.">
-  <meta name="keywords" content="Nerfies, D-NeRF, NeRF">
-  <meta name="viewport" content="width=device-width, initial-scale=1">
-  <title>Nerfies: Deformable Neural Radiance Fields</title>
-
-  <link href="https://fonts.googleapis.com/css?family=Google+Sans|Noto+Sans|Castoro"
-        rel="stylesheet">
-
-  <link rel="stylesheet" href="./static/css/bulma.min.css">
-  <link rel="stylesheet" href="./static/css/bulma-carousel.min.css">
-  <link rel="stylesheet" href="./static/css/bulma-slider.min.css">
-  <link rel="stylesheet" href="./static/css/fontawesome.all.min.css">
-  <link rel="stylesheet"
-        href="https://cdn.jsdelivr.net/gh/jpswalsh/academicons@1/css/academicons.min.css">
-  <link rel="stylesheet" href="./static/css/index.css">
-  <link rel="icon" href="./static/images/favicon.svg">
-
-  <script src="https://ajax.googleapis.com/ajax/libs/jquery/3.5.1/jquery.min.js"></script>
-  <script defer src="./static/js/fontawesome.all.min.js"></script>
-  <script src="./static/js/bulma-carousel.min.js"></script>
-  <script src="./static/js/bulma-slider.min.js"></script>
-  <script src="./static/js/index.js"></script>
-</head>
-<body>
-
-<section class="hero">
-  <div class="hero-body">
-    <div class="container is-max-desktop">
-      <div class="columns is-centered">
-        <div class="column has-text-centered">
-          <h1 class="title is-1 publication-title">Nerfies: Deformable Neural Radiance Fields</h1>
-          <div class="is-size-5 publication-authors">
-            <span class="author-block">
-              <a href="https://keunhong.com" target="_blank">Keunhong Park</a><sup>1</sup>,</span>
-            <span class="author-block">
-              <a href="https://utkarshsinha.com" target="_blank">Utkarsh Sinha</a><sup>2</sup>,</span>
-            <span class="author-block">
-              <a href="https://jonbarron.info" target="_blank">Jonathan T. Barron</a><sup>2</sup>,
-            </span>
-            <span class="author-block">
-              <a href="http://sofienbouaziz.com" target="_blank">Sofien Bouaziz</a><sup>2</sup>,
-            </span>
-            <span class="author-block">
-              <a href="https://www.danbgoldman.com" target="_blank">Dan B Goldman</a><sup>2</sup>,
-            </span>
-            <span class="author-block">
-              <a href="https://homes.cs.washington.edu/~seitz/" target="_blank">Steven M. Seitz</a><sup>1,2</sup>,
-            </span>
-            <span class="author-block">
-              <a href="http://www.ricardomartinbrualla.com" target="_blank">Ricardo Martin-Brualla</a><sup>2</sup>
-            </span>
-          </div>
-
-          <div class="is-size-5 publication-authors">
-            <span class="author-block"><sup>1</sup>University of Washington,</span>
-            <span class="author-block"><sup>2</sup>Google Research</span>
-          </div>
-
-          <div class="column has-text-centered">
-            <div class="publication-links">
-              <!-- PDF Link. -->
-              <span class="link-block">
-                <a href="https://arxiv.org/pdf/2011.12948" target="_blank"
-                   class="external-link button is-normal is-rounded is-dark">
-                  <span class="icon">
-                      <i class="fas fa-file-pdf"></i>
-                  </span>
-                  <span>Paper</span>
-                </a>
-              </span>
-              <span class="link-block">
-                <a href="https://arxiv.org/abs/2011.12948" target="_blank"
-                   class="external-link button is-normal is-rounded is-dark">
-                  <span class="icon">
-                      <i class="ai ai-arxiv"></i>
-                  </span>
-                  <span>arXiv</span>
-                </a>
-              </span>
-              <!-- Video Link. -->
-              <span class="link-block">
-                <a href="https://www.youtube.com/watch?v=MrKrnHhk8IA" target="_blank"
-                   class="external-link button is-normal is-rounded is-dark">
-                  <span class="icon">
-                      <i class="fab fa-youtube"></i>
-                  </span>
-                  <span>Video</span>
-                </a>
-              </span>
-              <!-- Code Link. -->
-              <span class="link-block">
-                <a href="https://github.com/google/nerfies" target="_blank"
-                   class="external-link button is-normal is-rounded is-dark">
-                  <span class="icon">
-                      <i class="fab fa-github"></i>
-                  </span>
-                  <span>Code</span>
-                  </a>
-              </span>
-              <!-- Dataset Link. -->
-              <span class="link-block">
-                <a href="https://github.com/google/nerfies/releases/tag/0.1" target="_blank"
-                   class="external-link button is-normal is-rounded is-dark">
-                  <span class="icon">
-                      <i class="far fa-images"></i>
-                  </span>
-                  <span>Data</span>
-                  </a>
-            </div>
-
-          </div>
-        </div>
-      </div>
-    </div>
-  </div>
-</section>
-
-<section class="hero teaser">
-  <div class="container is-max-desktop">
-    <div class="hero-body">
-      <video id="teaser" autoplay muted loop playsinline height="100%">
-        <source src="./static/videos/teaser.mp4"
-                type="video/mp4">
-      </video>
-      <h2 class="subtitle has-text-centered">
-        <span class="dnerf">Nerfies</span> turns selfie videos from your phone into
-        free-viewpoint
-        portraits.
-      </h2>
-    </div>
-  </div>
-</section>
-
-
-<section class="hero is-light is-small">
-  <div class="hero-body">
-    <div class="container">
-      <div id="results-carousel" class="carousel results-carousel">
-        <div class="item item-steve">
-          <video poster="" id="steve" autoplay controls muted loop playsinline height="100%">
-            <source src="./static/videos/steve.mp4"
-                    type="video/mp4">
-          </video>
-        </div>
-        <div class="item item-chair-tp">
-          <video poster="" id="chair-tp" autoplay controls muted loop playsinline height="100%">
-            <source src="./static/videos/chair-tp.mp4"
-                    type="video/mp4">
-          </video>
-        </div>
-        <div class="item item-shiba">
-          <video poster="" id="shiba" autoplay controls muted loop playsinline height="100%">
-            <source src="./static/videos/shiba.mp4"
-                    type="video/mp4">
-          </video>
-        </div>
-        <div class="item item-fullbody">
-          <video poster="" id="fullbody" autoplay controls muted loop playsinline height="100%">
-            <source src="./static/videos/fullbody.mp4"
-                    type="video/mp4">
-          </video>
-        </div>
-        <div class="item item-blueshirt">
-          <video poster="" id="blueshirt" autoplay controls muted loop playsinline height="100%">
-            <source src="./static/videos/blueshirt.mp4"
-                    type="video/mp4">
-          </video>
-        </div>
-        <div class="item item-mask">
-          <video poster="" id="mask" autoplay controls muted loop playsinline height="100%">
-            <source src="./static/videos/mask.mp4"
-                    type="video/mp4">
-          </video>
-        </div>
-        <div class="item item-coffee">
-          <video poster="" id="coffee" autoplay controls muted loop playsinline height="100%">
-            <source src="./static/videos/coffee.mp4"
-                    type="video/mp4">
-          </video>
-        </div>
-        <div class="item item-toby">
-          <video poster="" id="toby" autoplay controls muted loop playsinline height="100%">
-            <source src="./static/videos/toby2.mp4"
-                    type="video/mp4">
-          </video>
-        </div>
-      </div>
-    </div>
-  </div>
-</section>
-
-
-<section class="section">
-  <div class="container is-max-desktop">
-    <!-- Abstract. -->
-    <div class="columns is-centered has-text-centered">
-      <div class="column is-four-fifths">
-        <h2 class="title is-3">Abstract</h2>
-        <div class="content has-text-justified">
-          <p>
-            We present the first method capable of photorealistically reconstructing a non-rigidly
-            deforming scene using photos/videos captured casually from mobile phones.
-          </p>
-          <p>
-            Our approach augments neural radiance fields
-            (NeRF) by optimizing an
-            additional continuous volumetric deformation field that warps each observed point into a
-            canonical 5D NeRF.
-            We observe that these NeRF-like deformation fields are prone to local minima, and
-            propose a coarse-to-fine optimization method for coordinate-based models that allows for
-            more robust optimization.
-            By adapting principles from geometry processing and physical simulation to NeRF-like
-            models, we propose an elastic regularization of the deformation field that further
-            improves robustness.
-          </p>
-          <p>
-            We show that <span class="dnerf">Nerfies</span> can turn casually captured selfie
-            photos/videos into deformable NeRF
-            models that allow for photorealistic renderings of the subject from arbitrary
-            viewpoints, which we dub <i>"nerfies"</i>. We evaluate our method by collecting data
-            using a
-            rig with two mobile phones that take time-synchronized photos, yielding train/validation
-            images of the same pose at different viewpoints. We show that our method faithfully
-            reconstructs non-rigidly deforming scenes and reproduces unseen views with high
-            fidelity.
-          </p>
-        </div>
-      </div>
-    </div>
-    <!--/ Abstract. -->
-
-    <!-- Paper video. -->
-    <div class="columns is-centered has-text-centered">
-      <div class="column is-four-fifths">
-        <h2 class="title is-3">Video</h2>
-        <div class="publication-video">
-          <iframe src="https://www.youtube.com/embed/MrKrnHhk8IA?rel=0&amp;showinfo=0"
-                  frameborder="0" allow="autoplay; encrypted-media" allowfullscreen></iframe>
-        </div>
-      </div>
-    </div>
-    <!--/ Paper video. -->
-  </div>
-</section>
-
-
-<section class="section">
-  <div class="container is-max-desktop">
-
-    <div class="columns is-centered">
-
-      <!-- Visual Effects. -->
-      <div class="column">
-        <div class="content">
-          <h2 class="title is-3">Visual Effects</h2>
-          <p>
-            Using <i>nerfies</i> you can create fun visual effects. This Dolly zoom effect
-            would be impossible without nerfies since it would require going through a wall.
-          </p>
-          <video id="dollyzoom" autoplay controls muted loop playsinline height="100%">
-            <source src="./static/videos/dollyzoom-stacked.mp4"
-                    type="video/mp4">
-          </video>
-        </div>
-      </div>
-      <!--/ Visual Effects. -->
-
-      <!-- Matting. -->
-      <div class="column">
-        <h2 class="title is-3">Matting</h2>
-        <div class="columns is-centered">
-          <div class="column content">
-            <p>
-              As a byproduct of our method, we can also solve the matting problem by ignoring
-              samples that fall outside of a bounding box during rendering.
-            </p>
-            <video id="matting-video" controls playsinline height="100%">
-              <source src="./static/videos/matting.mp4"
-                      type="video/mp4">
-            </video>
-          </div>
-
-        </div>
-      </div>
-    </div>
-    <!--/ Matting. -->
-
-    <!-- Animation. -->
-    <div class="columns is-centered">
-      <div class="column is-full-width">
-        <h2 class="title is-3">Animation</h2>
-
-        <!-- Interpolating. -->
-        <h3 class="title is-4">Interpolating states</h3>
-        <div class="content has-text-justified">
-          <p>
-            We can also animate the scene by interpolating the deformation latent codes of two input
-            frames. Use the slider here to linearly interpolate between the left frame and the right
-            frame.
-          </p>
-        </div>
-        <div class="columns is-vcentered interpolation-panel">
-          <div class="column is-3 has-text-centered">
-            <img src="./static/images/interpolate_start.jpg"
-                 class="interpolation-image"
-                 alt="Interpolate start reference image."/>
-            <p>Start Frame</p>
-          </div>
-          <div class="column interpolation-video-column">
-            <div id="interpolation-image-wrapper">
-              Loading...
-            </div>
-            <input class="slider is-fullwidth is-large is-info"
-                   id="interpolation-slider"
-                   step="1" min="0" max="100" value="0" type="range">
-          </div>
-          <div class="column is-3 has-text-centered">
-            <img src="./static/images/interpolate_end.jpg"
-                 class="interpolation-image"
-                 alt="Interpolation end reference image."/>
-            <p class="is-bold">End Frame</p>
-          </div>
-        </div>
-        <br/>
-        <!--/ Interpolating. -->
-
-        <!-- Re-rendering. -->
-        <h3 class="title is-4">Re-rendering the input video</h3>
-        <div class="content has-text-justified">
-          <p>
-            Using <span class="dnerf">Nerfies</span>, you can re-render a video from a novel
-            viewpoint such as a stabilized camera by playing back the training deformations.
-          </p>
-        </div>
-        <div class="content has-text-centered">
-          <video id="replay-video"
-                 controls
-                 muted
-                 preload
-                 playsinline
-                 width="75%">
-            <source src="./static/videos/replay.mp4"
-                    type="video/mp4">
-          </video>
-        </div>
-        <!--/ Re-rendering. -->
-
-      </div>
-    </div>
-    <!--/ Animation. -->
-
-
-    <!-- Concurrent Work. -->
-    <div class="columns is-centered">
-      <div class="column is-full-width">
-        <h2 class="title is-3">Related Links</h2>
-
-        <div class="content has-text-justified">
-          <p>
-            There's a lot of excellent work that was introduced around the same time as ours.
-          </p>
-          <p>
-            <a href="https://arxiv.org/abs/2104.09125" target="_blank">Progressive Encoding for Neural Optimization</a> introduces an idea similar to our windowed position encoding for coarse-to-fine optimization.
-          </p>
-          <p>
-            <a href="https://www.albertpumarola.com/research/D-NeRF/index.html" target="_blank">D-NeRF</a> and <a href="https://gvv.mpi-inf.mpg.de/projects/nonrigid_nerf/" target="_blank">NR-NeRF</a>
-            both use deformation fields to model non-rigid scenes.
-          </p>
-          <p>
-            Some works model videos with a NeRF by directly modulating the density, such as <a href="https://video-nerf.github.io/" target="_blank">Video-NeRF</a>, <a href="https://www.cs.cornell.edu/~zl548/NSFF/" target="_blank">NSFF</a>, and <a href="https://neural-3d-video.github.io/" target="_blank">DyNeRF</a>
-          </p>
-          <p>
-            There are probably many more by the time you are reading this. Check out <a href="https://dellaert.github.io/NeRF/" target="_blank">Frank Dellart's survey on recent NeRF papers</a>, and <a href="https://github.com/yenchenlin/awesome-NeRF" target="_blank">Yen-Chen Lin's curated list of NeRF papers</a>.
-          </p>
-        </div>
-      </div>
-    </div>
-    <!--/ Concurrent Work. -->
-
-  </div>
-</section>
-
-
-<section class="section" id="BibTeX">
-  <div class="container is-max-desktop content">
-    <h2 class="title">BibTeX</h2>
-    <pre><code>@article{park2021nerfies,
-  author    = {Park, Keunhong and Sinha, Utkarsh and Barron, Jonathan T. and Bouaziz, Sofien and Goldman, Dan B and Seitz, Steven M. and Martin-Brualla, Ricardo},
-  title     = {Nerfies: Deformable Neural Radiance Fields},
-  journal   = {ICCV},
-  year      = {2021},
-}</code></pre>
-  </div>
-</section>
-
-
-<footer class="footer">
-  <div class="container">
-    <div class="content has-text-centered">
-      <a class="icon-link" target="_blank"
-         href="./static/videos/nerfies_paper.pdf">
-        <i class="fas fa-file-pdf"></i>
-      </a>
-      <a class="icon-link" href="https://github.com/keunhong" target="_blank" class="external-link" disabled>
-        <i class="fab fa-github"></i>
-      </a>
-    </div>
-    <div class="columns is-centered">
-      <div class="column is-8">
-        <div class="content">
-          <p>
-            This website is licensed under a <a rel="license" target="_blank"
-                                                href="http://creativecommons.org/licenses/by-sa/4.0/">Creative
-            Commons Attribution-ShareAlike 4.0 International License</a>.
-          </p>
-          <p>
-            This means you are free to borrow the <a target="_blank"
-              href="https://github.com/nerfies/nerfies.github.io">source code</a> of this website,
-            we just ask that you link back to this page in the footer.
-            Please remember to remove the analytics code included in the header of the website which
-            you do not want on your website.
-          </p>
-        </div>
-      </div>
-    </div>
-  </div>
-</footer>
-
-</body>
-</html>

rf8.py

@@ -0,0 +1,20 @@
+import torch
+from torch import nn
+
+
+def get_residual(weights):
+    """Get the order of the first significant digit of the tensors"""
+    signs = torch.sign(weights)
+    exps = torch.round(torch.log2(torch.abs(weights)))
+    pow_weights = signs * torch.pow(2, exps)
+    return pow_weights, exps
+
+
+def rf8(model, n=4):
+    """Residual Float-Point 8-bit Model Quantization"""
+    with torch.no_grad():
+        for param in model.parameters():
+            data1, exps1 = get_residual(param.data)
+            data2, exps2 = get_residual(param.data - data1)
+            flags = (exps1-exps2 <= n)
+            param.data = data1 + flags * data2