根據 NeRF 的三維場景重建與渲染技術探討

– 10 分鐘閱讀

神經輻射場（NeRF）技術近年來在三維場景重建和渲染領域取得了顯著的進展。NeRF 利用神經網路表示場景的輻射率和密度，透過輸入空間坐標和視角資訊，預測場景中每一點的光強度和密度，進而生成高品質的新視角影像。相比傳統方法，NeRF 能夠更精確地捕捉場景的幾何和紋理細節，並生成更逼真的渲染效果。NeRF 的核心在於其使用 5D 神經網路來表示場景，輸入 3D 位置和 2D 視角，輸出顏色和密度。透過渲染過程中的光線投射和積分，NeRF 能夠合成新視角的影像，實作視角的自由變化和場景的完整重建。然而，NeRF 的訓練過程需要大量的計算資源和資料，且模型的泛化能力仍有待提升。

什麼是NeRF？

NeRF（Neural Radiance Fields）是一種新的3D場景表示方法，使用神經網路來模擬世界。它的目的是捕捉場景的幾何和紋理資訊，以便生成高質量的影像。

NeRF的工作原理

NeRF使用神經網路來表示場景的輻射率（Radiance）和密度（Density）。輻射率是指場景中某一點的光強度，而密度是指場景中某一點的物體密度。神經網路的輸入是5維的，包括3個空間坐標（x、y、z）和2個視角坐標（θ、φ）。輸出是場景中某一點的輻射率和密度。

NeRF的優點

NeRF具有以下優點：

  • 能夠捕捉場景的複雜幾何和紋理資訊
  • 能夠生成高質量的影像
  • 能夠用於3D重建、影像合成等領域

NeRF的應用

NeRF的應用包括：

  • 3D重建：NeRF可以用於重建3D場景
  • 影像合成：NeRF可以用於生成新視角的影像
  • 渲染：NeRF可以用於渲染3D場景

NeRF的技術要求

NeRF的技術要求包括：

  • 需要強大的計算資源
  • 需要大規模的資料集
  • 需要先進的神經網路架構

NeRF的未來發展

NeRF的未來發展包括：

  • 改進NeRF的精度和效率
  • 擴充套件NeRF的應用領域
  • 開發新的NeRF架構和演算法

128  視覺神經網路的神經輻射場（NeRF）研究

視覺神經網路的神經輻射場（NeRF）是一種用於三維場景渲染的技術。它透過神經網路預測場景中每個點的輻射強度和密度，從而實作對場景的渲染。

NeRF的基本原理

NeRF的基本原理是使用神經網路預測場景中每個點的輻射強度和密度。神經網路接受四個輸入：三維座標（x, y, z）和兩個角度（θ, Φ）。輸出包括預測的輻射強度（r, g, b）和密度（σ）。

NeRF的訓練

NeRF的訓練需要大量的資料，包括場景的三維座標、角度和對應的影像。訓練的目標是使神經網路能夠預測出場景中每個點的輻射強度和密度。

NeRF的應用

NeRF可以應用於各種場景，包括三維場景渲染、虛擬現實和增強現實等。

程式碼實作

以下是NeRF的程式碼實作：

import torch
import matplotlib.pyplot as plt
from pytorch3d.renderer import (
    FoVPerspectiveCameras,
    NDCMultinomialRaysampler,
    MonteCarloRaysampler,
    EmissionAbsorptionRaymarcher,
    ImplicitRenderer,
)

from utils.helper_functions import (
    generate_rotating_nerf,
    huber,
    show_full_render,
    sample_images_at_mc_locs
)

from nerf_model import NeuralRadianceField

# 設定裝置
if torch.cuda.is_available():
    torch.cuda.set_device(device)
else:
    device = torch.device("cpu")

# 匯入資料
target_cameras, target_images, target_silhouettes = \
    generate_cow_renders(num_views=40, azimuth_range=180)
print(f'生成了 {len(target_images)} 張影像/輪廓/相機檢視.')

# 定義取樣器
render_size = target_images.shape[1] * 2

NeRF的訓練過程

NeRF的訓練過程包括以下幾個步驟：

  1. 資料準備：準備場景的三維座標、角度和對應的影像。
  2. 神經網路定義：定義神經網路的結構和引數。
  3. 損函式定義：定義損函式，以衡量神經網路預測的誤差。
  4. 最佳化器選擇：選擇最佳化器，以更新神經網路的引數。
  5. 訓練：訓練神經網路，以使其能夠預測出場景中每個點的輻射強度和密度。

NeRF的優勢

NeRF有以下幾個優勢：

  1. 高質量的渲染：NeRF可以生成高質量的渲染影像。
  2. 快速的渲染：NeRF可以快速渲染場景。
  3. 靈活的渲染：NeRF可以渲染各種場景，包括三維場景、虛擬現實和增強現實等。

NeRF的應用場景

NeRF可以應用於各種場景，包括：

  1. 三維場景渲染：NeRF可以用於三維場景的渲染。
  2. 虛擬現實：NeRF可以用於虛擬現實的渲染。
  3. 增強現實：NeRF可以用於增強現實的渲染。
  4. 電影和電視的特效：NeRF可以用於電影和電視的特效。
  5. 遊戲：NeRF可以用於遊戲的渲染。

如何使用 MonteCarloRaysampler 和 EmissionAbsorptionRaymarcher 進行渲染

在這個章節中，我們將探討如何使用 MonteCarloRaysampler 和 EmissionAbsorptionRaymarcher 進行渲染。這兩個類別是用於渲染 3D 場景的重要工具。

MonteCarloRaysampler

MonteCarloRaysampler 是一個用於生成隨機光線的類別。它可以根據給定的引數生成一組隨機的光線，這些光線可以用於渲染 3D 場景。

raysampler_mc = MonteCarloRaysampler(
    min_x=-1.0,
    max_x=1.0,
    min_y=-1.0,
    max_y=1.0,
    n_rays_per_image=750,
    n_pts_per_ray=128,
    min_depth=0.1,
    max_depth=volume_extent_world,
)

在這個例子中，我們建立了一個 MonteCarloRaysampler 例項，並設定了它的引數。這些引數包括了光線的最小和最大 x、y 值，光線的數量，光線上點的數量，光線的最小和最大深度等。

EmissionAbsorptionRaymarcher

EmissionAbsorptionRaymarcher 是一個用於渲染光線的類別。它可以根據給定的光線和場景引數渲染出最終的影像。

raymarcher = EmissionAbsorptionRaymarcher()

在這個例子中，我們建立了一個 EmissionAbsorptionRaymarcher 例項。

ImplicitRenderer

ImplicitRenderer 是一個用於組合光線生成和渲染的類別。它可以根據給定的光線生成和渲染引數渲染出最終的影像。

renderer_mc = ImplicitRenderer(raysampler=raysampler_mc, raymarcher=raymarcher)

在這個例子中，我們建立了一個 ImplicitRenderer 例項，並設定了它的引數。這些引數包括了光線生成和渲染的例項。

圖表翻譯：

  graph LR
    A[MonteCarloRaysampler] --> B[EmissionAbsorptionRaymarcher]
    B --> C[ImplicitRenderer]
    C --> D[渲染影像]

這個圖表展示了 MonteCarloRaysampler、EmissionAbsorptionRaymarcher 和 ImplicitRenderer 之間的關係。

NeRF 模型訓練與視覺化

在訓練 NeRF 模型的過程中，瞭解模型的輸出結果至關重要。這有助於我們在訓練過程中觀察模型的表現，並對模型進行調整。

讀取目標影像

首先，我們需要讀取目標影像。假設 target_images 是一個張量，代表我們要訓練的影像集。影像的維度可以透過 target_images.shape 獲取，其中 -1 代表影像的通道數（例如 RGB 通道）。

dim = target_images.shape[-1]

空間大小計算

接下來，我們需要計算空間大小。假設 sampled_rays_xy 是一個張量，代表取樣的光線坐標。空間大小可以透過 sampled_rays_xy.shape[1:-1] 獲取。

spatial_size = sampled_rays_xy.shape[1:-1]

影像取樣

我們使用 PyTorch 的 grid_sample 函式對影像進行取樣。這個函式可以對影像進行變換和取樣。

images_sampled = torch.nn.functional.grid_sample(
    target_images.permute(0, 3, 1, 2),
    -sampled_rays_xy.view(ba, -1, 1, 2),
    align_corners=True
)

資料預處理

最後，我們需要對取樣的影像進行預處理，包括維度變換和型別轉換。

return images_sampled.permute(0, 2, 3, 1).view(ba, *spatial_size, dim)

NeRF 模型視覺化

在訓練 NeRF 模型的過程中，視覺化模型的輸出結果至關重要。這有助於我們觀察模型的表現，並對模型進行調整。

Monte Carlo 光線取樣器

在訓練模型時，我們使用 Monte Carlo 光線取樣器 (MonteCarloRaysampler)。這個取樣器可以對光線進行隨機取樣，但是它不適合用於視覺化完整的影像。

NDC 多項式光線取樣器

為了視覺化完整的影像，我們使用 NDC 多項式光線取樣器 (NDCMultinomialRaysampler)。這個取樣器可以系統地對所有畫素進行取樣。

render_size = target_images.shape[1] * 2
volume_extent_world = 3.0

raysampler_grid = NDCMultinomialRaysampler(
    image_height=render_size,
    image_width=render_size,
    n_pts_per_ray=128,
    min_depth=0.1,
    max_depth=volume_extent_world
)

隱式渲染器

最後，我們建立一個隱式渲染器 (ImplicitRenderer) 例項。

renderer_grid = ImplicitRenderer(
    raysampler=raysampler_grid,
    raymarcher=raymarcher
)

這樣，我們就可以使用這個渲染器對 NeRF 模型進行視覺化了。

NeRF模型訓練流程

為了視覺化神經輻射場（NeRF）模型的訓練過程，我們需要定義一個輔助函式，該函式可以比較模型的輸出與目標影像和對應的輪廓。由於渲染的影像可能非常大，因此我們需要將其分割成小塊，並執行多次直接渲染以獲得最終結果。

輔助函式定義

我們可以定義一個輔助函式show_full_render，該函式可以接收模型的引數和相機引數，然後比較其輸出與目標影像和對應的輪廓。該函式的實作細節可以參考GitHub上的程式碼倉庫。

NeRF模型例項化

接下來，我們需要建立一個NeRF模型的例項。為了簡化程式碼，我們不在此處提供模型類的定義，該定義可以在GitHub上的程式碼倉庫中找到。模型的結構對於NeRF演算法的實作至關重要，我們將在後續章節中進行詳細的討論。

from nerf_model import NeuralRadianceField

neural_radiance_field = NeuralRadianceField()

訓練準備

為了確保訓練的可復現性，我們需要設定一個固定的隨機種子。然後，我們需要將所有變數移到指定的裝置（例如GPU）上，以便進行加速計算。

torch.manual_seed(1)

renderer_grid = renderer_grid.to(device)
renderer_mc = renderer_mc.to(device)
target_cameras = target_cameras.to(device)
target_images = target_images.to(device)
target_silhouettes = target_silhouettes.to(device)
neural_radiance_field = neural_radiance_field.to(device)

超引數定義

最後，我們需要定義訓練過程中使用的超引數，包括學習率（lr）、訓練迭代次數（n_iter）和批次大小（batch_size）。批次大小的選擇應根據可用的GPU記憶體進行調整，如果發現GPU記憶體不足，則應減小批次大小。

lr = 1e-3
n_iter = 1000
batch_size = 32

圖表翻譯：

  flowchart TD
    A[定義輔助函式] --> B[例項化NeRF模型]
    B --> C[設定隨機種子]
    C --> D[移動變數到裝置]
    D --> E[定義超引數]
    E --> F[開始訓練]

在這個流程圖中，我們展示了NeRF模型訓練過程中的各個步驟，從定義輔助函式到開始訓練。每個步驟都對應到上述程式碼中的特定部分。

訓練Neural Radiance Field模型

初始化最佳化器和訓練引數

optimizer = torch.optim.Adam(
    neural_radiance_field.parameters(),
    lr=lr
)
batch_size = 6
n_iter = 3000
loss_history_color, loss_history_sil = [], []

訓練迴圈

for iteration in range(n_iter):
    if iteration == round(n_iter * 0.75):
        print('將學習率減少10倍...')
        optimizer = torch.optim.Adam(
            neural_radiance_field.parameters(), 
            lr=lr * 0.1
        )
        
    optimizer.zero_grad()
    batch_idx = torch.randperm(len(target_cameras))[:batch_size]
    batch_cameras = FoVPerspectiveCameras(
        R = target_cameras.R[batch_idx],
        T = target_cameras.T[batch_idx],
        znear = target_cameras.znear[batch_idx],
        zfar = target_cameras.zfar[batch_idx],
        aspect_ratio = target_cameras.aspect_ratio[batch_idx],
        fov = target_cameras.fov[batch_idx],
        device = device
    )

內容解密：

在這個程式碼中，我們首先初始化了最佳化器和訓練引數。然後，在訓練迴圈中，我們隨機選擇了一批攝像機，並根據這批攝像機建立了新的攝像機物件。這個過程是為了隨機選擇攝像機以避免過度擬合。

圖表翻譯：

  flowchart TD
    A[初始化最佳化器和訓練引數] --> B[訓練迴圈]
    B --> C[隨機選擇攝像機]
    C --> D[建立新的攝像機物件]
    D --> E[計算損失]
    E --> F[更新模型引數]

這個圖表展示了訓練Neural Radiance Field模型的過程。首先，我們初始化了最佳化器和訓練引數。然後，在訓練迴圈中，我們隨機選擇了一批攝像機，並根據這批攝像機建立了新的攝像機物件。接下來，我們計算了損失，並根據損失更新了模型引數。

NeRF 訓練過程中的損失計算與最佳化

在 NeRF 訓練過程中，首先需要使用 NeRF 模型對隨機選取的相機進行渲染，獲得預測的畫素值和預測的輪廓。這些預測值是透過模型的前向傳播獲得的。接下來，需要將這些預測值與真實資料進行比較，以計算損失。損失是由兩個函式組成：A，預測輪廓和真實輪廓之間的 Huber 損失；B，預測顏色和真實顏色之間的 Huber 損失。

渲染和損失計算

# 獲取渲染的影像和輪廓
rendered_images_silhouettes, sampled_rays = renderer_mc(
    cameras=batch_cameras,
    volumetric_function=neural_radiance_field
)

# 分離渲染的影像和輪廓
rendered_images, rendered_silhouettes = rendered_images_silhouettes.split([3, 1], dim=-1)

# 對真實輪廓進行取樣
silhouettes_at_rays = sample_images_at_mc_locs(
    target_silhouettes[batch_idx, ..., None],
    sampled_rays.xys
)

# 計算輪廓損失
sil_err = huber(rendered_silhouettes, silhouettes_at_rays).abs().mean()

# 對真實顏色進行取樣
colors_at_rays = sample_images_at_mc_locs(
    target_images[batch_idx],
    sampled_rays.xys
)

# 計算顏色損失
color_err = huber(rendered_images, colors_at_rays).abs().mean()

最佳化模型

損失計算完成後，需要透過反向傳播將損失傳遞到模型中，並使用最佳化器對模型進行最佳化。這個過程可以使用 PyTorch 的 backward() 和 step() 方法實作。

# 計算總損失
total_loss = sil_err + color_err

# 反向傳播
total_loss.backward()

# 最佳化模型
optimizer.step()

透過這個過程，NeRF 模型可以學習到從隨機相機位置渲染出高質量的影像和輪廓。

使用NeRF模型進行3D重建和渲染

在上述程式碼中，我們可以看到NeRF（神經輻射場）模型的訓練過程。NeRF是一種使用神經網路對3D場景進行渲染的技術，能夠生成高品質的影像。

訓練NeRF模型

首先，我們需要定義損失函式和最佳化器。損失函式是用來評估模型預測值與真實值之間的差異，最佳化器則是用來更新模型引數以最小化損失函式。

loss = color_err + sil_err
loss.backward()
optimizer.step()

紀錄損失歷史

我們需要紀錄損失函式的變化，以便於觀察模型的訓練過程。

loss_history_color.append(float(color_err))
loss_history_sil.append(float(sil_err))

渲染中間結果

每100次迭代，我們就會渲染出中間結果，以便於觀察模型的訓練過程。

if iteration % 100 == 0:
    show_idx = torch.randperm(len(target_cameras))[:1]
    fig = show_full_render(
        neural_radiance_field,
        FoVPerspectiveCameras(
            R = target_cameras.R[show_idx],
            T = target_cameras.T[show_idx],
            znear = target_cameras.znear[show_idx],
            zfar = target_cameras.zfar[show_idx],
            aspect_ratio = target_cameras.aspect_ratio[show_idx],
            fov = target_cameras.fov[show_idx],
            device = device,
        ),
        target_images[show_idx][0],
        target_silhouettes[show_idx][0],
        renderer_grid,
        loss_history_color,
        loss_history_sil,
    )
    fig.savefig(f'intermediate_{iteration}')

渲染最終結果

在訓練完成後，我們可以使用訓練好的NeRF模型對3D場景進行渲染，生成高品質的影像。

圖表翻譯：

  graph LR
    A[訓練NeRF模型] --> B[渲染中間結果]
    B --> C[渲染最終結果]
    C --> D[生成高品質影像]

在這個過程中，我們可以看到NeRF模型的訓練過程和渲染結果，從而評估模型的效能和效果。

從技術架構視角來看，NeRF 利用神經網路巧妙地表示 3D 場景的輻射率和密度，成功克服了傳統渲染方法在複雜場景和視角變化上的限制。深入剖析其核心架構可以發現，NeRF 的成功關鍵在於將 5D 座標輸入轉換為場景資訊的過程，並透過體積渲染技術生成逼真的影像。然而，NeRF 的高計算複雜度和對大量訓練資料的需求仍然是其目前應用的主要瓶頸。多維比較分析顯示，雖然 NeRF 在影像品質上超越了傳統方法，但在實務部署上仍需考量硬體資源的限制。展望未來，隨著硬體效能提升和訓練演算法的最佳化，玄貓認為 NeRF 將在 3D 建模、虛擬實境和擴增實境等領域扮演更重要的角色，並可能催生更多創新的應用場景，例如更精確的場景重建和更沉浸式的互動體驗。技術團隊應著重於降低計算成本和提升訓練效率，才能充分釋放 NeRF 的技術潛力。

玄貓

玄貓

技術愛好者，專注於分享程式開發、雲端技術與 AI 應用的心得體會。