分类： 人工智能

参考：Dasuda​ and Liwen.site

参考代码：Nerf-pl: https://github.com/kwea123/nerf_pl

• 网站： https://www.matthewtancik.com/nerf
• 论文：https://arxiv.org/pdf/2003.08934.pdf
• 代码：https://github.com/bmild/nerf

位置编码

NeRF 的输入是一个五维向量: （物体）空间点的位置x=(x,y,z) 和 （相机）观测方向d=(θ,ϕ)。NeRF 使用了位置编码（positional encoding）把一维的位置坐标，转换为高维的表征。例如 p∈RL, 通过函数γ(⋅) 映射到R2L 空间中，这里L 指的是编码的数量，对于位置坐标，L=10；对于观测角度，L=4。

代码实现

 # 类的定义
class Embedding(nn.Module):
    def __init__(self, in_channels, N_freqs, logscale=True):
        """
        Defines a function that embeds x to (x, sin(2^k x), cos(2^k x), ...)
        in_channels: number of input channels (3 for both xyz and direction)
        """
        super(Embedding, self).__init__()
        self.N_freqs = N_freqs
        self.in_channels = in_channels
        self.funcs = [torch.sin, torch.cos]
        self.out_channels = in_channels*(len(self.funcs)*N_freqs+1)
 
        if logscale:
            self.freq_bands = 2**torch.linspace(0, N_freqs-1, N_freqs)
        else:
            self.freq_bands = torch.linspace(1, 2**(N_freqs-1), N_freqs)
 
    def forward(self, x):
        """
        Embeds x to (x, sin(2^k x), cos(2^k x), ...) 
        Different from the paper, "x" is also in the output
        See https://github.com/bmild/nerf/issues/12
 
        Inputs:
            x: (B, self.in_channels)
 
        Outputs:
            out: (B, self.out_channels)
        """
        out = [x]
        for freq in self.freq_bands:
            for func in self.funcs:
                out += [func(freq*x)]
 
        return torch.cat(out, -1)
 
# 使用
 
class NeRFSystem(LightningModule):
    def __init__(self, hparams):
        ...
        self.embedding_xyz = Embedding(3, 10) # 10 is the default number
        self.embedding_dir = Embedding(3, 4) # 4 is the default number
        self.embeddings = [self.embedding_xyz, self.embedding_dir]
        ...   

解释

• 对于位置坐标 (x,y,z)， 每一个值都使用 10 个 sin 和 10 个cos 频率进行拓展。例如 Embeds x to (x, sin (2^k x), cos (2^k x), …) 。再连接一个本身。因此每一个值都拓展为 10+10+1=21维。对于位置坐标的三个值，总共有 3×21=63 维。
• 对于相机角度 (θ,ϕ)，也是类似，使用 4 个sin 和 4 个 cos 频率进行拓展。这里输入保留了一位，实际输入是(θ,ϕ,1)。再连接一个本身。因此每一个值都拓展为4+4+1=9 维。对于相机角度的三个值，总共有 3×9=27 维。

NeRF 网络

NeRF 网络默认是一个多层的 MLP。中间第四层有 skip connection，构成了一个 ResNet 的结构。网络的宽度默认为 256。

输入：

1. 位置坐标的表征（in_channels_xyz）：63d

输出：

1. 体密度σ：1d
2. RGB 色彩值C: 3d

网络结构：
FC 指的是带 ReLU 的全连接层。Linear 层指的是单纯的线性方程。

代码实现

class NeRF(nn.Module):
    def __init__(self,
                 D=8, W=256,
                 in_channels_xyz=63, in_channels_dir=27, 
                 skips=[4]):
        """
        D: number of layers for density (sigma) encoder
        W: number of hidden units in each layer
        in_channels_xyz: number of input channels for xyz (3+3*10*2=63 by default)
        in_channels_dir: number of input channels for direction (3+3*4*2=27 by default)
        skips: add skip connection in the Dth layer
        """
        super(NeRF, self).__init__()
        self.D = D
        self.W = W
        self.in_channels_xyz = in_channels_xyz
        self.in_channels_dir = in_channels_dir
        self.skips = skips
 
        # xyz encoding layers
        for i in range(D):
            if i == 0:
                layer = nn.Linear(in_channels_xyz, W)
            elif i in skips:
                layer = nn.Linear(W+in_channels_xyz, W)
            else:
                layer = nn.Linear(W, W)
            layer = nn.Sequential(layer, nn.ReLU(True))
            setattr(self, f"xyz_encoding_{i+1}", layer)
        self.xyz_encoding_final = nn.Linear(W, W)
 
        # direction encoding layers
        self.dir_encoding = nn.Sequential(
                                nn.Linear(W+in_channels_dir, W//2),
                                nn.ReLU(True))
 
        # output layers
        self.sigma = nn.Linear(W, 1)
        self.rgb = nn.Sequential(
                        nn.Linear(W//2, 3),
                        nn.Sigmoid())
 
    def forward(self, x, sigma_only=False):
        """
        Encodes input (xyz+dir) to rgb+sigma (not ready to render yet).
        For rendering this ray, please see rendering.py
 
        Inputs:
            x: (B, self.in_channels_xyz(+self.in_channels_dir))
               the embedded vector of position and direction
            sigma_only: whether to infer sigma only. If True,
                        x is of shape (B, self.in_channels_xyz)
 
        Outputs:
            if sigma_ony:
                sigma: (B, 1) sigma
            else:
                out: (B, 4), rgb and sigma
        """
        if not sigma_only:
            input_xyz, input_dir = \
                torch.split(x, [self.in_channels_xyz, self.in_channels_dir], dim=-1)
        else:
            input_xyz = x
 
        xyz_ = input_xyz
        for i in range(self.D):
            if i in self.skips:
                xyz_ = torch.cat([input_xyz, xyz_], -1)
            xyz_ = getattr(self, f"xyz_encoding_{i+1}")(xyz_)
 
        sigma = self.sigma(xyz_)
        if sigma_only:
            return sigma
 
        xyz_encoding_final = self.xyz_encoding_final(xyz_)
 
        dir_encoding_input = torch.cat([xyz_encoding_final, input_dir], -1)
        dir_encoding = self.dir_encoding(dir_encoding_input)
        rgb = self.rgb(dir_encoding)
 
        out = torch.cat([rgb, sigma], -1)
 
        return out

体素渲染

假设我们已经得到了一束光线上所有的位置对应的色彩和体密度。我们需要对这束光线进行后处理（体素渲染），得到最终在图片上的像素值。

# z_vals: (N_rays, N_samples_) depths of the sampled positions
# noise_std: factor to perturb the model's prediction of sigma（提升模型鲁棒性？？）
 
# Convert these values using volume rendering (Section 4)
deltas = z_vals[:, 1:] - z_vals[:, :-1] # (N_rays, N_samples_-1)
delta_inf = 1e10 * torch.ones_like(deltas[:, :1]) # (N_rays, 1) the last delta is infinity
deltas = torch.cat([deltas, delta_inf], -1)  # (N_rays, N_samples_)
 
# Multiply each distance by the norm of its corresponding direction ray
# to convert to real world distance (accounts for non-unit directions).
deltas = deltas * torch.norm(dir_.unsqueeze(1), dim=-1)
 
noise = torch.randn(sigmas.shape, device=sigmas.device) * noise_std
 
# compute alpha by the formula (3)
alphas = 1-torch.exp(-deltas*torch.relu(sigmas+noise)) # (N_rays, N_samples_)
alphas_shifted = \
    torch.cat([torch.ones_like(alphas[:, :1]), 1-alphas+1e-10], -1) # [1, a1, a2, ...]
weights = \
    alphas * torch.cumprod(alphas_shifted, -1)[:, :-1] # (N_rays, N_samples_)
weights_sum = weights.sum(1) # (N_rays), the accumulated opacity along the rays
                                # equals "1 - (1-a1)(1-a2)...(1-an)" mathematically
if weights_only:
    return weights
 
# compute final weighted outputs
rgb_final = torch.sum(weights.unsqueeze(-1)*rgbs, -2) # (N_rays, 3)
depth_final = torch.sum(weights*z_vals, -1) # (N_rays)

第二轮渲染

对于渲染的结果，会根据 对应的权重，使用 pdf 抽样，得到新的渲染点。例如默认第一轮粗渲染每束光线是 64 个样本点，第二轮再增加 128 个抽样点。

然后使用 finemodel 进行预测，后对所有的样本点（64+128）进行体素渲染。

def sample_pdf(bins, weights, N_importance, det=False, eps=1e-5):
    """
    Sample @N_importance samples from @bins with distribution defined by @weights.
 
    Inputs:
        bins: (N_rays, N_samples_+1) where N_samples_ is "the number of coarse samples per ray - 2"
        weights: (N_rays, N_samples_)
        N_importance: the number of samples to draw from the distribution
        det: deterministic or not
        eps: a small number to prevent division by zero
 
    Outputs:
        samples: the sampled samples
    """
    N_rays, N_samples_ = weights.shape
    weights = weights + eps # prevent division by zero (don't do inplace op!)
    pdf = weights / torch.sum(weights, -1, keepdim=True) # (N_rays, N_samples_)
    cdf = torch.cumsum(pdf, -1) # (N_rays, N_samples), cumulative distribution function
    cdf = torch.cat([torch.zeros_like(cdf[: ,:1]), cdf], -1)  # (N_rays, N_samples_+1) 
                                                               # padded to 0~1 inclusive
 
    if det:
        u = torch.linspace(0, 1, N_importance, device=bins.device)
        u = u.expand(N_rays, N_importance)
    else:
        u = torch.rand(N_rays, N_importance, device=bins.device)
    u = u.contiguous()
 
    inds = searchsorted(cdf, u, side='right')
    below = torch.clamp_min(inds-1, 0)
    above = torch.clamp_max(inds, N_samples_)
 
    inds_sampled = torch.stack([below, above], -1).view(N_rays, 2*N_importance)
    cdf_g = torch.gather(cdf, 1, inds_sampled).view(N_rays, N_importance, 2)
    bins_g = torch.gather(bins, 1, inds_sampled).view(N_rays, N_importance, 2)
 
    denom = cdf_g[...,1]-cdf_g[...,0]
    denom[denom<eps] = 1 # denom equals 0 means a bin has weight 0, in which case it will not be sampled
                         # anyway, therefore any value for it is fine (set to 1 here)
 
    samples = bins_g[...,0] + (u-cdf_g[...,0])/denom * (bins_g[...,1]-bins_g[...,0])
    return samples

Loss

这里直接使用的 MSE loss，对输出的像素值和 ground truth 计算 L2-norm loss.

训练数据

训练数据

根据前面的介绍，NeRF 实现的，是从 【位置坐标 katex 和 拍摄角度(θ,ϕ)】 到 【体密度 (σ) 和 RGB 色彩值 (C)】的映射。根据体素渲染理论，图片中的每一个像素，实质上都是从相机发射出的一条光线渲染得到的。 因此，我们首先，需要得到每一个像素对应的光线（ray）, 然后，计算光线上每一个点的【体密度σ) 和 RGB 色彩值 (C)】，最后再渲染得到对应的像素值。

对于训练数据，我们需要拍摄一系列的图片（如 100 张）图片和他们的拍摄相机角度、内参、场景边界（可以使用 COLMAP 获得）。我们需要准备每一个像素对应的光线（ray）信息，这样可以组成成对的训练数据【光线信息 <==> 像素值】。

下面以 LLFFDataset （”datasets/llff.py”） 为例，进行分析：

读取的数据（以一张图片为例）：

• 图片：尺寸是 N_img​×C×H×W。 其中 C=3 代表了这是 RGB 三通道图片
• 拍摄角度信息（从 COLMAP 生成）：Nimg​×17。前 15 维可以变形为 3×5，代表了相机的 pose，后 2 维是最近和最远的深度。解释： 3×5 pose matrices and 2 depth bounds for each image. Each pose has [R T] as the left 3×4 matrix and [H W F] as the right 3×1 matrix. R matrix is in the form [down right back] instead of [right up back] . （https://github.com/bmild/nerf/issues/34）

拍摄角度预处理

第一步：根据拍摄的尺寸和处理尺寸的关系，缩放相机的焦距。例如：Himg​=3024,Wimg​=4032,Fimg​=3260, 如果我们想处理的尺寸是H=378,W=504 (为了提升训练的速度)，我们需要缩放焦距 F:

# "datasets/llff.py", line：188
    # Step 1: rescale focal length according to training resolution
    H, W, self.focal = poses[0, :, -1] # original intrinsics, same for all images
    assert H*self.img_wh[0] == W*self.img_wh[1], \
        f'You must set @img_wh to have the same aspect ratio as ({W}, {H}) !'
 
    self.focal *= self.img_wh[0]/W

第二步：调整 pose 的方向。在 “poses_bounds.npy” 中，pose 的方向是 “下右后”，我们调整到 “右上后”。同时使用 “center_poses(poses)” 函数，对整个 dataset 的坐标轴进行标准化（？？）。
解释：“poses_avg computes a “central” pose for the dataset, based on using the mean translation, the mean z axis, and adopting the mean y axis as an “up” direction (so that Up x Z = X and then Z x X = Y). recenter_poses very simply applies the inverse of this average pose to the dataset (a rigid rotation/translation) so that the identity extrinsic matrix is looking at the scene, which is nice because normalizes the orientation of the scene for later rendering from the learned NeRF. This is also important for using NDC (Normalized device coordinates) coordinates, since we assume the scene is centered there too.”（https://github.com/bmild/nerf/issues/34）

# "datasets/llff.py", line：195
    # Step 2: correct poses
    # Original poses has rotation in form "down right back", change to "right up back"
    # See https://github.com/bmild/nerf/issues/34
    poses = np.concatenate([poses[..., 1:2], -poses[..., :1], poses[..., 2:4]], -1)
            # (N_images, 3, 4) exclude H, W, focal
    self.poses, self.pose_avg = center_poses(poses)

第三步：令最近的距离约为 1。 解释：“The NDC code takes in a “near” bound and assumes the far bound is infinity (this doesn’t matter too much since NDC space samples in 1/depth so moving from “far” to infinity is only slightly less sample-efficient). You can see here that the “near” bound is hardcoded to 1”。For more details on how to use NDC space see https://github.com/bmild/nerf/files/4451808/ndc_derivation.pdf

# "datasets/llff.py", line：205    # Step 3: correct scale so that the nearest depth is at a little more than 1.0    # See https://github.com/bmild/nerf/issues/34    near_original = self.bounds.min()    scale_factor = near_original*0.75 # 0.75 is the default parameter                                        # the nearest depth is at 1/0.75=1.33    self.bounds /= scale_factor    self.poses[..., 3] /= scale_factor

计算光线角度

接下来就是对每一个像素，使用 “get_ray_directions()” 函数计算所对应的光线。这里只需要使用图像的长宽和焦距即可计算

self.directions = get_ray_directions(self.img_wh[1], self.img_wh[0], self.focal) # (H, W, 3)

调用函数：

def get_ray_directions(H, W, focal):
    """
    Get ray directions for all pixels in camera coordinate.
    Reference: https://www.scratchapixel.com/lessons/3d-basic-rendering/
               ray-tracing-generating-camera-rays/standard-coordinate-systems
 
    Inputs:
        H, W, focal: image height, width and focal length
 
    Outputs:
        directions: (H, W, 3), the direction of the rays in camera coordinate
    """
    grid = create_meshgrid(H, W, normalized_coordinates=False)[0]
    i, j = grid.unbind(-1)
    # the direction here is without +0.5 pixel centering as calibration is not so accurate
    # see https://github.com/bmild/nerf/issues/24
    directions = \
        torch.stack([(i-W/2)/focal, -(j-H/2)/focal, -torch.ones_like(i)], -1) # (H, W, 3)
 
    return directions

世界坐标系下的光线
在拿到每一个像素对应的光线角度后，我们需要得到具体的光线信息。首先，先计算在世界坐标系下的光线信息。主要是一个归一化的操作。

Get ray origin and normalized directions in world coordinate for all pixels in one image. Reference: https://www.scratchapixel.com/lessons/3d-basic-rendering/ray-tracing-generating-camera-rays/standard-coordinate-systems

输入：

图像上每一点所对应的光线角度：(H, W, 3) precomputed ray directions in camera coordinate。
相机映射矩阵 c2w：(3, 4) transformation matrix from camera coordinate to world coordinate
输出：

光线原点在世界坐标系中的坐标：(HW, 3), the origin of the rays in world coordinate 在世界坐标系中，归一化的光线角度：(HW, 3), the normalized direction of the rays in world

def get_rays(directions, c2w):
    """
    Get ray origin and normalized directions in world coordinate for all pixels in one image.
    Reference: https://www.scratchapixel.com/lessons/3d-basic-rendering/
               ray-tracing-generating-camera-rays/standard-coordinate-systems
 
    Inputs:
        directions: (H, W, 3) precomputed ray directions in camera coordinate
        c2w: (3, 4) transformation matrix from camera coordinate to world coordinate
 
    Outputs:
        rays_o: (H*W, 3), the origin of the rays in world coordinate
        rays_d: (H*W, 3), the normalized direction of the rays in world coordinate
    """
    # Rotate ray directions from camera coordinate to the world coordinate
    rays_d = directions @ c2w[:, :3].T # (H, W, 3)
    rays_d = rays_d / torch.norm(rays_d, dim=-1, keepdim=True)
    # The origin of all rays is the camera origin in world coordinate
    rays_o = c2w[:, 3].expand(rays_d.shape) # (H, W, 3)
 
    rays_d = rays_d.view(-1, 3)
    rays_o = rays_o.view(-1, 3)
 
    return rays_o, rays_d

NDC 下的光线

NDC (Normalized device coordinates) 归一化的设备坐标系。

首先对光线的边界进行限定：

near, far = 0, 1

然后对坐标进行平移和映射。

def get_ndc_rays(H, W, focal, near, rays_o, rays_d):
    """
    Transform rays from world coordinate to NDC.
    NDC: Space such that the canvas is a cube with sides [-1, 1] in each axis.
    For detailed derivation, please see:
    http://www.songho.ca/opengl/gl_projectionmatrix.html
    https://github.com/bmild/nerf/files/4451808/ndc_derivation.pdf
 
    In practice, use NDC "if and only if" the scene is unbounded (has a large depth).
    See https://github.com/bmild/nerf/issues/18
 
    Inputs:
        H, W, focal: image height, width and focal length
        near: (N_rays) or float, the depths of the near plane
        rays_o: (N_rays, 3), the origin of the rays in world coordinate
        rays_d: (N_rays, 3), the direction of the rays in world coordinate
 
    Outputs:
        rays_o: (N_rays, 3), the origin of the rays in NDC
        rays_d: (N_rays, 3), the direction of the rays in NDC
    """
    # Shift ray origins to near plane
    t = -(near + rays_o[...,2]) / rays_d[...,2]
    rays_o = rays_o + t[...,None] * rays_d
 
    # Store some intermediate homogeneous results
    ox_oz = rays_o[...,0] / rays_o[...,2]
    oy_oz = rays_o[...,1] / rays_o[...,2]
 
    # Projection
    o0 = -1./(W/(2.*focal)) * ox_oz
    o1 = -1./(H/(2.*focal)) * oy_oz
    o2 = 1. + 2. * near / rays_o[...,2]
 
    d0 = -1./(W/(2.*focal)) * (rays_d[...,0]/rays_d[...,2] - ox_oz)
    d1 = -1./(H/(2.*focal)) * (rays_d[...,1]/rays_d[...,2] - oy_oz)
    d2 = 1 - o2
 
    rays_o = torch.stack([o0, o1, o2], -1) # (B, 3)
    rays_d = torch.stack([d0, d1, d2], -1) # (B, 3)
 
    return rays_o, rays_d

训练数据的生成

输出分为两部分：光线的信息，和对应的图片像素值

• 对于每一束光线，按照 【光线原点 (3d), 光线角度 (3d), 最近的边界 (1d), 最远的边界 (1d)】= 8d 的格式存储。
• 光线对应的像素，RGB=3d 的格式存储。

self.all_rays += [torch.cat([rays_o, rays_d,                                              near*torch.ones_like(rays_o[:, :1]),                                             far*torch.ones_like(rays_o[:, :1])],                                             1)] # (h*w, 8)

转自：Leviosa

1 引言

NeRF是2020年ECCV论文。仅仅过去不到2年，关于NeRF的论文数量已经十分可观。相比于计算机视觉，尤其是相比于基于深度学习的计算机视觉，计算机图形学是比较困难、比较晦涩的。被深度学习席卷的计算机视觉任务数不胜数，但被深度学习席卷的计算机图形学任务仍然尚少。

由于NeRF及其众多follow-up工作在图形学中非常重要的渲染任务上给出了优秀的结果，可以预见未来用深度学习完成图形学任务的工作会快速增长。今年的GIRAFFE是NeRF的后续工作之一，它摘下2021CVPR的最佳论文奖对整个方向的繁荣都起到积极的推动作用。

本文希望讨论以下问题：

• NeRF被提出的基础（2 前NeRF时代）；
• NeRF是什么（3 NeRF！）；
• NeRF的代表性follow-up工作（4 后NeRF时代）；
• 包含NeRF的更宽泛的研究方向Neural Rendering的简介（5 不止是NeRF）。

2 前NeRF时代

2.1 传统图形学的渲染

本质上，NeRF做的事情就是用深度学习完成了图形学中的3D渲染任务。那么我们提两个问题。

• 问题1：3D渲染是要干什么？

看2个比较官方的定义。

MIT计算机图形学课程EECS 6.837对渲染（Rendering）的定义：

“Rendering” refers to the entire process that produces color values for pixels, given a 3D representation of the scene.

综述State of the Art on Neural Rendering对渲染（Rendering）的定义：

The process of transforming a scene definition including cameras, lights, surface geometry and material into a simulated camera image is known as rendering.

也就是说，渲染就是用计算机模拟照相机拍照，它们的结果都是生成一张照片。

用照相机拍照是一个现实世界的物理过程，主要是光学过程，拍照对象是现实世界中真实的万事万物，形成照片的机制主要就是：光经过镜头，到达传感器，被记录下来。

而渲染就是用计算机模拟这一过程，模拟“拍照”的对象是已存在的某种三维场景表示（3D representation of the scene），模拟生成照片的机制是图形学研究人员精心设计的算法。

关键前提：渲染的前提是某种三维场景表示已经存在。渲染一词本身不包办生成三维场景表示。不过，渲染的确与三维场景表示的形式息息相关；因此研究渲染的工作通常包含对三维场景表示的探讨。

• 问题2：3D渲染是图形学问题，那么原先大家是用什么传统图形学方法实现3D渲染的呢？

主要有两种算法：光栅化（rasterization），光线追踪（ray tracing）；都是对照相机拍照的光学过程进行数学物理建模来实现的。

传统渲染的详细原理参阅此教材。

光栅化是一种前馈过程，几何体被转换为图像域，是上世纪比较早的算法。光线追踪则是将光线从图像像素向后投射到虚拟三维场景中，并通过从与几何体的交点递归投射新光线来模拟反射和折射，有全局光照的优势（能模拟光线的多次反射或折射）。

当下，在学术界，还在研究传统图形学的渲染算法的人应该大部分在搞优化加速，怎么用GPU实时渲染更复杂的场景之类的事儿。在工业界，不少游戏重度依赖渲染技术，所以应该也有不少游戏公司在研究更逼真、更快速、更省算力的渲染算法。去年虚幻引擎出的新款“虚幻引擎5”效果很是震撼，光照、纹理、流体的实时渲染模拟都逼真到了前所未有的新高度，可以看下虚幻引擎官方的宣传视频，真的很不错。

2.2 神经网络侵略3D渲染任务：NeRF呼之欲出

隐式场景表示（implicit scene representation）

基于深度学习的渲染的先驱是使用神经网络隐式表示三维场景。 许多3D-aware的图像生成方法使用体素、网格、点云等形式表示三维场景，通常基于卷积架构。 而在CVPR 2019上，开始出现 使用神经网络拟合标量函数 来表示三维场景的工作。

DeepSDF

2019年CVPR的DeepSDF或许是最接近NeRF的先驱工作。

SDF是Signed Distance Function的缩写。DeepSDF通过回归（regress）一个分布来表达三维表面的。如下图所示，SDF>0的地方，表示该点在三维表面外面；SDF<0的地方，表示该点在三维表面里面。回归这一分布的神经网络是多层感知机（Multi-Layer Perceptron，MLP），非常简单原始的神经网络结构。

NeRF比DeepSDF进步的地方就在于，NeRF用RGBσ代替了SDF，所以除了能推理一个点离物体表面的距离，还能推理RGB颜色和透明度，且颜色是view-dependent的（观察视角不同，同一物点的颜色不同），从而实现功能更强大的渲染。

3 NeRF！

建议前往NeRF项目网站查看视频效果图。

3.1 Radiance Fields（RF）

NeRF是Neural Radiance Fields的缩写。其中的Radiance Fields是指一个函数、或者说映射gθ 。

(σ,c)=gθ(x,d)

映射的输入是 x 和d 。 x∈R3是三维空间点的坐标， d∈S2 是观察角度。

映射的输出是 σ 和 c 。 σ∈R+ 是volume density（可以简单理解为不透明度）， c∈R3 是color，即RGB颜色值。

Radiance Fields，或者说映射 gθ ，能对三维场景进行隐式表示（implicit scene representation）。在上一节，我们说过某种三维场景表示正是渲染的前提。实现渲染也是 作者提出Radiance Fields这一新型三维场景表示方法 的目的所在。

3.2 Neural Radiance Fields（NeRF）

Radiance Fields是映射gθ 。那么Neural Radiance Fields则是指用神经网络拟合Radiance Fields gθ 。论文中，该神经网络具体是多层感知机（与DeepSDF一样）。

3.3 NeRF的体积渲染

NeRF（Neural Radiance Fields）其实是一种三维场景表示（scene representation），而且是一种隐式的场景表示（implicit scene representation），因为不能像point cloud、mesh、voxel一样直接看见一个三维模型。

NeRF将场景表示为空间中任何点的volume density σ 和颜色值 c 。 有了以NeRF形式存在的场景表示后，可以对该场景进行渲染，生成新视角的模拟图片。论文使用经典体积渲染（volume rendering）的原理，求解穿过场景的任何光线的颜色，从而渲染合成新的图像。

3.4 NeRF的训练

训练NeRF的输入数据是：从不同位置拍摄同一场景的图片，拍摄这些图片的相机位姿、相机内参，以及场景的范围。若图像数据集缺少相机参数真值，作者便使用经典SfM重建解决方案COLMAP估计了需要的参数，当作真值使用。

在训练使用NeRF渲染新图片的过程中，

• 先将这些位置输入MLP以产生volume density和RGB颜色值；
• 取不同的位置，使用体积渲染技术将这些值合成为一张完整的图像；
• 因为体积渲染函数是可微的，所以可以通过最小化上一步渲染合成的、真实图像之间的差来训练优化NeRF场景表示。

这样的一个NeRF训练完成后，就得到一个 以多层感知机的权重表示的 模型。一个模型只含有该场景的信息，不具有生成别的场景的图片的能力。

除此之外，NeRF还有两个优化的trick：

• 位置编码（positional encoding），类似于傅里叶变换，将低维输入映射到高维空间，提升网络捕捉高频信息的能力；
• 体积渲染的分层采样（hierarchical volume sampling），通过更高效的采样策略减小估算积分式的计算开销，加快训练速度。

4 后NeRF时代

GIRAFFE：composition方向的代表作

2021CVPR的最佳论文奖得主GIRAFFE是NeRF、GRAF工作的延申。

在NeRF之后，有人提出了GRAF（Generative Radiance Fields），关键点在于引入了GAN来实现Neural Radiance Fields；并使用conditional GAN实现对渲染内容的可控性。

在GRAF之后，GIRAFFE实现了composition。在NeRF、GRAF中，一个Neural Radiance Fields表示一个场景，one model per scene。而在GIRAFFE中，一个Neural Radiance Fields只表示一个物体，one object per scene（背景也算一个物体）。这样做的妙处在于可以随意组合不同场景的物体，可以改变同一场景中不同物体间的相对位置，渲染生成更多训练数据中没有的全新图像。

如图所示，GIRAFFE可以平移、旋转场景中的物体，还可以在场景中增添原本没有的新物体。

另外，GIRAFFE还可以改变物体的形状和外观，因为网络中加入了形状编码、外观编码变量（shape codes zsi , appearance codes zai ）。

其他最新相关工作

2021年CVPR还有许多相关的精彩工作发表。例如，提升网络的泛化性：

• pixelNeRF：将每个像素的特征向量而非像素本身作为输入，允许网络在不同场景的多视图图像上进行训练，学习场景先验，然后测试时直接接收一个或几个视图为输入合成新视图。
• IBRNet：学习一个适用于多种场景的通用视图插值函数，从而不用为每个新的场景都新学习一个模型才能渲染；且网络结构上用了另一个时髦的东西 Transformer。
• MVSNeRF：训练一个具有泛化性能的先验网络，在推理的时候只用3张输入图片就重建一个新的场景。

针对动态场景的NeRF:

• Nerfies：多使用了一个多层感知机来拟合形变的SE(3) field，从而建模帧间场景形变。
• D-NeRF：多使用了一个多层感知机来拟合场景形变的displacement。
• Neural Scene Flow Fields：多提出了一个scene flow fields来描述时序的场景形变。

其他创新点：

• PhySG：用球状高斯函数模拟BRDF（高级着色的上古神器）和环境光照，针对更复杂的光照环境，能处理非朗伯表面的反射。
• NeX：用MPI（Multi-Plane Image ）代替NeRF的RGBσ作为网络的输出。

5 不止是NeRF：Neural Rendering

Neural Radiance Fields的外面是Neural Rendering；换句话说，NeRF（Neural Radiance Fields）是Neural Rendering方向的子集。

在针对这个更宽泛的概念的综述State of the Art on Neural Rendering中，Neural Rendering的主要研究方向被分为5类，NeRF在其中应属于第2类“Novel View Synthesis”（不过这篇综述早于NeRF发表,表中没有NeRF条目）。

表中彩色字母缩写的含义：

在这篇综述中，Neural Rendering被定义为：

Deep image or video generation approaches that enable explicit or implicit control of scene properties such as illumination, camera parameters, pose, geometry, appearance, and semantic structure.

Neural Rendering包含所有使用神经网络生成可控（且photo-realistic）的新图片的方法。“可控”指人可以显式或隐式地控制生成新图片的属性，常见的属性包括：光照，相机内参，相机位姿（外参），几何关系，外观，语义分割结构。在这个大框架下，NeRF是一种比较受欢迎的可控相机位姿的Neural Rendering算法。但Neural Rendering这个方向不止于此。

在目前的Neural Rendering方向，最火的子方向就是“Novel View Synthesis”，这与NeRF的强势蹿红密不可分；第二火的子方向是“Semantic Photo Synthesis”，这主要归功于语义分割以及相关的GAN领域的成熟度。“Semantic Photo Synthesis”方向也是成果颇丰，例如2019年CVPR的Semantic Image Synthesis with Spatially-Adaptive Normalization，其效果图如下。

相关资源

Github论文收集仓库

小仓库（仅限于NeRF）：

https://github.com/yenchenlin/awesome-NeRF

大仓库（neural rendering）：

https://github.com/weihaox/awesome-neural-rendering

综述论文

可以说是官方综述，作者列表是目前在Neural Rendering领域最活跃的一群人。两篇分别是2021、2020年的SIGGRAPH、CVPR讲座用到的综述，很全面很有条理，值得每位从业者一读！

SIGGRAPH 2021 Course：　Advances in Neural Rendering

CVPR 2020 Tutorial：　State of the Art on Neural Rendering

范围限定为可微渲染方法的综述：

Differentiable Rendering: A Survey

上面小仓库的库主（MIT博士生Yen-Chen Lin）写的综述：

Neural Volume Rendering: NeRF And Beyond

论文

列论文实在挂一漏万，象征性地放上本文提到的2篇很重要的论文吧。

NeRF项目主页：

NeRF: Representing Scenes as Neural Radiance Fields for View Synthesis

GIRAFFE项目主页：

GIRAFFE: Representing Scenes as Compositional Generative Neural Feature Fields

教材

传统图形学渲染技术：

Real-Time Rendering 3rd

计算机视觉经典教材，含有image-based rendering章节：

Computer Vision: Algorithms and Applications

三篇Georgia Tech老师写的博客

NeRF at CVPR 2022 – Frank Dellaert

NeRF at ICCV 2021 – Frank Dellaert

NeRF Explosion 2020 – Frank Dellaert

离散形式

推导一下连续形式变为离散形式的运算。

计算机求解积分式的办法一般是化为黎曼和。在这里，如果我们每次都将积分区间划分为固定的、等间距的窄长方形面积和，其实就失去了NeRF是连续场景表示的优势：因为虽然每个点的RGBσ都可以访问，但是实际上你还是只用了固定点的值求积分。