FSR 4 神经网络模型架构深度分析

文档概述

本文档深入分析 AMD FidelityFX Super Resolution 4.0（FSR4）的神经网络架构设计、推理机制和实现细节。FSR4 是AMD基于深度学习的实时图像超分辨率技术，采用循环神经网络（RNN）架构，结合时间累积和智能自适应滤波，实现了前所未有的超分辨率质量。

技术规格概览

核心参数

• 模型版本: fsr4_model_v07 (Version 0.7 Int8量化)
• 神经网络类型: 循环神经网络（Recurrent Neural Network）
• 架构模式: U-Net风格的编码器-解码器
• 量化策略: Int8/FP8 混合量化
• 目标平台: AMD RDNA 3+ (Navi48+)
• 计算单元: DirectX 12 Compute Shader 6.6
• 内存要求: 约20MB权重 + 79.1MB暂存缓冲区

质量预设与缩放比例

质量预设	渲染比例	上采样比例	性能增益	神经网络模型路径
Quality	66.7%	1.5x	≈ 1.5x FPS	fsr4_model_v07_i8_quality/
Balanced	58.8%	1.7x	≈ 1.9x FPS	fsr4_model_v07_i8_balanced/
Performance	50.0%	2.0x	≈ 2.5x FPS	fsr4_model_v07_i8_performance/
Ultra Performance	33.3%	3.0x	≈ 4.0x FPS	fsr4_model_v07_i8_ultraperf/

硬件加速支持

• WMMA指令: AMD Wave Matrix Multiply Accumulate
• INT8 DP4A: 4路并行点积运算
• GPU架构: RDNA 3+ (RDNA 2有限支持)
• 内存带宽: 高带宽内存优化（HBM/GDDR6X）
• Shader模型: 6.6 (支持机器学习原语)

FSR4 循环神经网络架构

核心创新：时间感知的RNN设计

FSR4的革命性设计在于其循环神经网络（RNN）架构，这是业界首个实时游戏超分辨率的RNN实现：

graph LR
    A[当前帧RGBCurrent Frame RGB] --> E[YCbCr转换Color Space Conv.]
    B[历史帧RGBHistorical Frame RGB] --> F[YCbCr转换Color Space Conv.]
    C[循环状态Recurrent State 4ch] --> G[7通道输入Neural Network Input]
    D[运动矢量Motion Vectors] --> H[历史帧重投影History Reprojection]

    E --> I[当前帧亮度YCh0]
    F --> J[历史帧亮度YCh1]
    E --> K[色度距离计算Ch2]
    F --> K
    H --> F
    C --> L[循环状态4通道Ch3-6]

    I --> G
    J --> G
    K --> G
    L --> G

    G --> M[14-Pass神经网络推理]
    M --> N[8通道滤波参数Filter Parameters]
    M --> O[新循环状态New Recurrent State]
    N --> P[自适应滤波Adaptive Filtering]
    P --> Q[最终输出Final Output]
    O --> |下一帧| C

网络拓扑结构

FSR4采用U-Net风格的编码器-解码器架构，具有跳跃连接和残差连接：

输入张量: (3840×2160×7) ──┐
                         │
    ┌─── Encoder 1 ──────┤ (下采样 2×)
    │    1920×1080×16    │
    │                    │
    ├─── Encoder 2 ──────┤ (下采样 2×)
    │    960×540×16      │
    │                    │
    ├─── Encoder 3 ──────┤ (下采样 2×)
    │    480×270×32      │
    │                    │
    │── Bottleneck ──────┤ (特征处理)
    │    480×270×32      │
    │                    │
    ├─── Decoder 3 ──────┤ (上采样 2×)
    │    960×540→1920×1080×8
    │                    │
    └─── Decoder 2 ──────┘ (上采样 2×)
         3840×2160×8

跳跃连接：Encoder → 对应Decoder层
残差连接：每个层内部的ResBlock结构

14-Pass 推理流水线

Pass	阶段	操作	输入分辨率	输出分辨率	通道变化	主要功能
Pass 0	Encoder1	初始下采样卷积	3840×2160×7	1920×1080×16	7→16	特征提取与降维
Pass 1	Encoder2	残差块1（DW+PW）	1920×1080×16	1920×1080×16	16→16	中层特征学习
Pass 2	Encoder2	残差块2+下采样	1920×1080×16	960×540×16	16→16	空间降维
Pass 3	Encoder3	残差块1（空间混合）	960×540×16	960×540×16	16→16	高级特征提取
Pass 4	Encoder3	残差块2+下采样	960×540×16	480×270×32	16→32	语义特征编码
Pass 5	Bottleneck	残差块1（深层处理）	480×270×32	480×270×32	32→32	深层语义理解
Pass 6	Bottleneck	残差块2（深层处理）	480×270×32	480×270×32	32→32	特征增强
Pass 7	Bottleneck	残差块3（深层处理）	480×270×32	480×270×32	32→32	特征融合
Pass 8	Bottleneck	上采样开始	480×270×32	960×540×16	32→16	重建开始
Pass 9	Decoder3	残差块1（特征重建）	960×540×16	960×540×16	16→16	中分辨率重建
Pass 10	Decoder3	残差块2+上采样	960×540×16	1920×1080×8	16→8	高分辨率重建
Pass 11	Decoder2	残差块1（细节恢复）	1920×1080×8	1920×1080×8	8→8	细节恢复
Pass 12	Decoder2	残差块2（细节恢复）	1920×1080×8	1920×1080×8	8→8	细节增强
Pass 13	Decoder2	最终上采样+融合	1920×1080×8	3840×2160×8	8→8	滤波参数输出

FSR4 神经网络输入输出分析

输入：7通道循环神经网络张量 (pre_wmma.hlsl)

FSR4采用创新的多模态时间输入设计，同时处理空间信息、时间信息和循环状态：

7通道输入构成详解（基于pre_wmma.hlsl:183-203行）

重要澄清：FSR4模型的7通道输入构成为：当前帧亮度、历史帧亮度、色度距离，以及4个通道的循环状态。之前关于"current color、history color 与motion vector组成了7通道"的说法是错误的。运动矢量用于历史帧的重投影，但不直接作为神经网络输入通道。

通道	内容	数据格式	来源计算	代码位置	技术作用
Ch 0	当前帧亮度Y	FP16	input_ycbcr.x = RGBtoYCbCr(upscale_input.xyz).x	第189行	当前帧主要结构信息
Ch 1	历史帧亮度Y	FP16	history_ycbcr.x = RGBtoYCbCr(history).x	第190行	运动补偿后的历史参考
Ch 2	色度距离	FP16	sqrt((Cb_diff)² + (Cr_diff)² + 1e-6)	第191行	材质/光照变化检测
Ch 3	循环状态R	FP16	recurrent[0]	第197行	上一帧的红色特征记忆
Ch 4	循环状态G	FP16	recurrent[1]	第198行	上一帧的绿色特征记忆
Ch 5	循环状态B	FP16	recurrent[2]	第199行	上一帧的蓝色特征记忆
Ch 6	循环状态α	FP16	recurrent[3]	第200行	上一帧的权重/置信度记忆

关键输入预处理技术

1. Catmull-Rom高质量运动补偿 (pre_wmma.hlsl:158-170):

// 子像素精度的历史帧重投影
const float2 history_xy = float2(dtid) + velocity * dstSize;
const float2 history_uv = (history_xy + 0.5f) / tex_size;

// Catmull-Rom 4-tap双三次采样，保持锐度
if (onscreen) {
    SampleTextureCatmullRom(history_uv, tex_size, history);
    recurrent = r_recurrent_0.SampleLevel(g_history_sampler, history_uv, 0);
}

2. 智能时间混合策略 (pre_wmma.hlsl:144-146):

// 基于alpha通道的时间权重调制
const float history_rect_alpha = 0.1f;  // 基础混合因子
float temporal_sample_weight = upscale_input.a * history_rect_alpha;

// 自适应历史帧融合
history = temporal_sample_weight * upscale_input.rgb +
          (1.0 - temporal_sample_weight) * history;

3. YCbCr色彩空间的材质变化检测 (pre_wmma.hlsl:185-195):

// 分离亮度和色度信息
float3 input_ycbcr = RGBtoYCbCr(upscale_input.xyz);    // 当前帧YCbCr
float3 history_ycbcr = RGBtoYCbCr(history);            // 历史帧YCbCr

// 专注于色度差异，检测材质/光照变化
const float color_distance = sqrt(
    pow(input_ycbcr.y - history_ycbcr.y, 2) +   // Cb分量差异
    pow(input_ycbcr.z - history_ycbcr.z, 2) +   // Cr分量差异
    1e-6f);  // 数值稳定性

// 打包为神经网络输入（实际代码第189-191行）
downscaleInputs[0].x = MODEL_COLOR_NORMALIZE(NETWORK_DATA_TYPE(input_ycbcr.x));   // Ch0: 当前亮度
downscaleInputs[0].y = MODEL_COLOR_NORMALIZE(NETWORK_DATA_TYPE(history_ycbcr.x)); // Ch1: 历史亮度
downscaleInputs[0].z = NETWORK_DATA_TYPE(color_distance);                         // Ch2: 色度距离

输出：8通道自适应滤波参数系统 (post_wmma.hlsl)

FSR4的核心创新：神经网络不直接生成像素颜色，而是为每个像素预测最优的滤波器参数

8通道输出参数解析

通道	参数类型	激活函数	用途描述	后处理应用
Ch 0	相关性因子	tanh(x)	高斯滤波核的对角相关性	控制滤波方向性
Ch 1	X轴缩放	2/(1+exp(-x))	X方向滤波核缩放	横向特征适应
Ch 2	Y轴缩放	2/(1+exp(-x))	Y方向滤波核缩放	纵向特征适应
Ch 3	时间混合	1/(1+exp(-x))	当前帧vs历史帧权重	时间稳定性控制
Ch 4	循环状态R	线性	传递给下一帧的红色记忆	跨帧特征传递
Ch 5	循环状态G	线性	传递给下一帧的绿色记忆	跨帧特征传递
Ch 6	循环状态B	线性	传递给下一帧的蓝色记忆	跨帧特征传递
Ch 7	循环状态α	线性	传递给下一帧的权重记忆	跨帧置信度传递

智能自适应滤波算法 (post_wmma.hlsl:9-55)

FSR4的核心创新在于每像素预测滤波器参数的自适应高斯滤波：

float3 apply_model_filter(uint x, uint y, const float4 filter, float exposureValue)
{
    // 1. 解码神经网络预测的滤波参数
    const float correlation_factor = tanh(filter[0]);            // 对角相关性 [-1,1]
    const float scale_factor_x = 2.0 / (1.0 + exp(-filter[1])); // X缩放 (0,2]
    const float scale_factor_y = 2.0 / (1.0 + exp(-filter[2])); // Y缩放 (0,2]

    // 2. 构建各向异性自适应高斯核
    const float x_dist2 = x_dist * x_dist * scale_factor_x * scale_factor_x;
    const float y_dist2 = y_dist * y_dist * scale_factor_y * scale_factor_y;
    const float xy_corr = 2 * correlation_factor * x_dist * y_dist *
                         scale_factor_x * scale_factor_y;

    // 3. 计算高斯权重 (σ = 0.47是经验最优值)
    const float gauss_weight = exp((-0.5 / (0.47 * 0.47)) *
                                  (x_dist2 + xy_corr + y_dist2));

    // 4. 应用μ-law编码感知的颜色采样
    upscaled_color += ApplyMuLaw(LoadInputColor(uint2(x_in, y_in)) * exposureValue)
                      * gauss_weight;

    // 5. 智能时间混合
    const float blending_factor = 1.0 / (1.0 + exp(-filter[3])); // [0,1]
    float3 result = upscaled_color * (1.0 - blending_factor) +    // 当前帧
                    r_reprojected_color[uint2(x, y)] * blending_factor; // 历史帧

    return result;
}

滤波参数的技术优势

1. 各向异性处理：

• X/Y独立缩放：处理不同方向的几何特征
• 相关性因子：处理对角线方向的边缘和纹理
• 自适应核形状：每个像素使用最优的滤波策略

2. 内容感知混合：

• 神经网络预测的混合权重：基于局部内容特性
• 动态时间权重：运动区域减少历史帧依赖
• 稳定区域优化：静态区域使用更多历史信息

3. 感知优化设计：

• μ-law编码：保护视觉敏感区域
• HDR感知：适应高动态范围内容
• 曝光补偿：适应不同曝光条件

核心技术特性与硬件优化

量化技术深度分析

Int8量化策略： FSR4采用先进的混合精度量化方案，平衡性能与质量：

// 量化参数示例 (来自passes_*.hlsl权重定义)
#define QUANT_SCALE_FACTOR 0.014884727075695992f  // 量化缩放因子
#define DEQUANT_ZERO_POINT 128                    // 零点偏移

// Int8量化公式
int8_weight = clamp(round(float_weight / QUANT_SCALE_FACTOR) + ZERO_POINT, -128, 127);
float_weight = (int8_weight - ZERO_POINT) * QUANT_SCALE_FACTOR;

量化优势：

• 内存效率: 权重压缩8倍，从FP32→Int8
• 带宽优化: 减少GPU内存访问压力
• WMMA加速: 利用AMD硬件的Int8矩阵指令
• 精度保持: 保持FP16中间计算精度

AMD WMMA硬件加速架构

Wave Matrix Multiply Accumulate优化： FSR4针对AMD RDNA 3+架构专门优化，充分利用WMMA指令：

// WMMA矩阵乘法示例 (from *_wmma.hlsl)
// 16x16 Int8 矩阵乘法，累积到FP32
[numthreads(64, 1, 1)]
void CSMain(uint3 dtid : SV_DispatchThreadID)
{
    // 使用WMMA指令加速卷积运算
    uint wave_id = WaveGetLaneIndex();

    // 加载量化权重 (16x16 Int8)
    int4 weight_quad = LoadQuantizedWeights(base_offset + wave_id);

    // 加载输入特征 (16x16 Int8)
    int4 input_quad = LoadQuantizedInputs(input_offset + wave_id);

    // WMMA矩阵乘法：C = A * B + C
    float4 output = WMMMultiplyAccumulate(weight_quad, input_quad, accumulator);

    // 反量化并应用激活函数
    output = DequantizeAndActivate(output, scale_factor);
}

硬件优势：

• 并行度: 64个lane同时执行16x16矩阵乘法
• 吞吐量: 每周期执行256个Int8乘法累加操作
• 效率: 相比标量操作提升10x+性能
• 功耗: Int8运算功耗远低于FP32

循环神经网络的时间建模

跨帧状态传递机制： FSR4的循环架构实现了真正的时间记忆：

// 循环状态的生命周期管理 (pre_wmma.hlsl)
struct RecurrentState {
    float4 color_memory;    // 颜色特征记忆
    float4 confidence;      // 置信度记忆
};

// 帧N: 读取上一帧的循环状态
RecurrentState prev_state = r_recurrent_buffer[pixel_coord];

// 神经网络处理：融合当前帧与历史记忆
float7 network_input = PackNetworkInputs(
    current_frame,        // Ch 0-2: 当前帧信息
    history_frame,        // Ch 1-2: 历史帧信息
    prev_state           // Ch 3-6: 循环状态
);

// 14-Pass推理
float8 network_output = Neural_Network_Inference(network_input);

// 帧N: 写入新的循环状态供下一帧使用
RecurrentState new_state = ExtractRecurrentState(network_output.ch4567);
rw_recurrent_buffer[pixel_coord] = new_state;

时间建模优势：

• 长期记忆: 保持跨多帧的特征连续性
• 运动感知: 结合运动矢量的时空建模
• 自适应遗忘: 场景变化时自动调整记忆权重
• 稳定性: 减少时间闪烁和artifacts

透明物体和运动矢量缺失处理：

FSR4设计了一套完整的多层级检测和处理机制来应对透明物体和无效运动矢量：

1. 双重遮罩系统

Reactive Mask 自动生成 (fsrapirendermodule.cpp:1667-1700):

// 透明物体检测通过颜色差异
ffx::DispatchDescUpscaleGenerateReactiveMask dispatchDesc{};
dispatchDesc.colorOpaqueOnly = m_pOpaqueTexture;      // 不透明物体渲染
dispatchDesc.colorPreUpscale = m_pColorTarget;        // 包含透明物体完整渲染
dispatchDesc.cutoffThreshold = 0.2f;         // 差异检测阈值
dispatchDesc.binaryValue = 0.9f;             // 高反应区域标记值

Composition Mask 结合 (fsrapirendermodule.cpp:91-103):

// 透明渲染时的额外Alpha输出
transOptions.OptionalAdditionalExports =
    L"output.CompositionTarget = max(Alpha, hasAnimatedTexture);";

2. 运动矢量稀释算法

深度导向的矢量替换 (mlsr_optimized_includes.hlsli:115-169):

int2 dilate_motion_vector(uint2 pixel_coord, Texture2D<float> depth_buffer)
{
    float closest_depth = 1.0f;
    int2 best_mv_coord = pixel_coord;

    // 检查8邻域，寻找最近的有效几何体
    for (uint i = 0; i < 8; i++) {
        int2 neighbor_coord = pixel_coord + depth_offsets[i];
        float neighbor_depth = depth_buffer[neighbor_coord];

        if (neighbor_depth < closest_depth) {
            closest_depth = neighbor_depth;
            best_mv_coord = neighbor_coord;  // 使用最近物体的运动矢量
        }
    }

    return best_mv_coord;
}

3. 无效运动矢量检测

异常值自动检测 (mlsr_optimized_includes.hlsli:171-181):

bool detect_invalid_motion_vector(uint2 tid, inout float2 velocity)
{
    // 多重异常检查
    if (any(isnan(velocity)) ||           // NaN检查
        any(isinf(velocity)) ||           // 无限大检查
        any(abs(velocity) > 1000.0f))     // 异常大值检查
    {
        velocity = float2(0, 0);          // 重置为零运动
        return true;                      // 标记为disocclusion
    }
    return false;
}

性能优化和实时特性

GPU计算资源利用

并行推理优化：

• 线程组配置: 8×8×1 或 64×1×1 线程组
• 内存访问优化: Coalesced访问模式
• Wavefront利用率: >90% occupancy
• 寄存器利用: 精确的寄存器分配

内存层级优化：

// 智能缓存利用
groupshared float4 tile_cache[8][8];    // 共享内存缓存
Texture2D<float4> input_cache : register(t0);  // L1缓存优化读取
RWTexture2D<float4> output : register(u0);     // 写入合并

// 预取策略
[unroll] for (uint i = 0; i < 4; i++) {
    tile_cache[tid.x][tid.y + i] = input_cache[coord + offset[i]];
}
GroupMemoryBarrierWithGroupSync();  // 同步后使用

质量预设的计算权衡

动态质量调整：

// fsrapirendermodule.cpp 性能适应策略
if (current_frametime > target_frametime * 1.1f) {
    // 降低质量以保持帧率
    DowngradeQualityPreset();
} else if (gpu_utilization < 0.8f) {
    // GPU有余力时提升质量
    UpgradeQualityPreset();
}

预设	神经网络Pass	滤波复杂度	GPU利用率	内存带宽
Ultra Perf	简化版14-Pass	基础3x3核	~60%	~80%
Performance	标准14-Pass	标准5x5核	~75%	~90%
Balanced	增强14-Pass	自适应5x7核	~85%	~95%
Quality	完整14-Pass	完整7x7核	~95%	~98%

循环状态的输入打包

循环状态打包代码 (pre_wmma.hlsl:197-201):

// 循环状态：来自上一帧的网络输出，构成输入通道3-6
downscaleInputs[0].w = MODEL_RFM_NORMALIZE(NETWORK_DATA_TYPE(recurrent[0])); // Ch3: R通道
downscaleInputs[1].x = MODEL_RFM_NORMALIZE(NETWORK_DATA_TYPE(recurrent[1])); // Ch4: G通道
downscaleInputs[1].y = MODEL_RFM_NORMALIZE(NETWORK_DATA_TYPE(recurrent[2])); // Ch5: B通道
downscaleInputs[1].z = MODEL_RFM_NORMALIZE(NETWORK_DATA_TYPE(recurrent[3])); // Ch6: A通道

循环状态的生命周期

Frame N-1: 神经网络输出 → rw_recurrent_0/1 (写入)
           ↓
Frame N:   r_recurrent_0/1 (读取) → 神经网络输入通道3-6
           ↓
Frame N:   神经网络处理 → 新的循环状态输出
           ↓
Frame N:   rw_recurrent_0/1 (写入) → 用于Frame N+1

循环神经网络架构优势:

1. 时间一致性: 循环状态保持跨帧的特征连续性，减少时间闪烁
2. 运动感知: 结合运动矢量和历史信息，处理复杂运动场景
3. 细节保持: 通过时间累积保持和增强高频细节信息
4. 自适应处理: 根据场景变化动态调整时间混合策略

输出 - FSR4神经网络的8通道自适应滤波参数输出

关键发现: FSR4神经网络的输出不是直接的RGB颜色，而是智能滤波器的参数，用于后续的自适应图像重建。

8通道输出结构 (NHWC格式: 3840×2160×8)

基于post_wmma.hlsl和相关后处理分析：

通道索引	参数名称	格式	功能描述	后处理用法
通道 0	滤波器参数α	R16_FLOAT	自适应高斯滤波的相关性因子	correlation_factor = tanh(ch0)
通道 1	X轴缩放因子	R16_FLOAT	控制滤波核在X方向的形状	scale_factor_x = 2.0/(1.0+exp(-ch1))
通道 2	Y轴缩放因子	R16_FLOAT	控制滤波核在Y方向的形状	scale_factor_y = 2.0/(1.0+exp(-ch2))
通道 3	时间混合权重	R16_FLOAT	当前帧与重投影历史帧的混合比例	blending_factor = 1.0/(1.0+exp(-ch3))
通道 4	循环状态R	R16_FLOAT	传递给下一帧的记忆状态	直接存储至rw_recurrent_0.r
通道 5	循环状态G	R16_FLOAT	传递给下一帧的记忆状态	直接存储至rw_recurrent_0.g
通道 6	循环状态B	R16_FLOAT	传递给下一帧的记忆状态	直接存储至rw_recurrent_0.b
通道 7	循环状态A	R16_FLOAT	传递给下一帧的记忆状态	直接存储至rw_recurrent_0.a

智能滤波工作原理 (post_wmma.hlsl:9-55)

FSR4的核心创新在于使用神经网络为每个像素预测最优的滤波器参数：

float3 apply_model_filter(uint x, uint y, const float4 filter, const float exposureValue)
{
    // 1. 提取神经网络预测的滤波参数
    const float correlation_factor = tanh(filter[0]);  // 相关性因子
    const float scale_factor_x = 2.0 / (1.0 + exp(-filter[1]));  // X轴缩放
    const float scale_factor_y = 2.0 / (1.0 + exp(-filter[2]));  // Y轴缩放

    // 2. 构建自适应高斯滤波核
    const float gauss_weight = exp((-0.5 / (0.47 * 0.47)) *
        (x_dist2 * scale_factor_x2 +
         2 * correlation_factor * (x_dist * y_dist) * scale_factor_xy +
         y_dist2 * scale_factor_y2));

    // 3. 应用智能滤波
    upscaled_color += ApplyMuLaw(LoadInputColor(uint2(x_in, y_in)) * exposureValue) * gauss_weight;

    // 4. 时间混合
    const float blending_factor = 1.0 / (1.0 + exp(-filter[3]));
    float3 res = upscaled_color * (1.0 - blending_factor) +
                 r_reprojected_color[uint2(x, y)] * blending_factor;

    return res;
}

智能滤波的技术优势:

1. 像素级自适应: 每个像素使用不同的滤波参数，精确处理各种内容类型
2. 各向异性滤波: 通过X/Y缩放因子实现方向性感知的滤波
3. 相关性控制: correlation_factor参数处理对角线方向的特征
4. 时间智能混合: 基于内容自适应调整当前帧与历史帧的权重
5. 内容感知: 神经网络根据局部特征预测最优滤波策略

输出处理流程:

1. 颜色通道 (0-2): 直接作为最终渲染结果
2. 置信度通道 (3): 用于判断上采样质量，低置信度区域可能需要额外处理
3. 运动矢量 (4-5): 为下一帧提供更精确的运动信息
4. 累积权重 (6): 控制时间抗锯齿的强度
5. 细节增强 (7): 应用自适应锐化，恢复高频细节

技术特性

1. 量化技术

• Int8量化: 所有权重使用8位整数量化
• 量化缩放因子: 每层都有独立的量化缩放因子（如 0.014884727075695992）
• FP8支持: 针对特定GPU的FP8优化版本

2. 硬件优化

• WMMA指令: 使用AMD Wave Matrix Multiply Accumulate指令加速
• DOT4指令: 支持4元素点积指令
• Shader Model 6.6: 需要最新的DirectX 12 Ultimate支持

3. 内存布局

• NHWC格式: 使用 Batch-Height-Width-Channel 内存布局
• 线程组织: 8×8×1 或 32×1×1 线程组配置
• 暂存缓冲区: 79.1MB用于中间结果存储

4. 残差连接设计

• 深度可分离卷积: 在编码器和部分解码器中使用
• 空间混合卷积: 在编码器后期和解码器中使用，可能包含注意力机制
• 逐点卷积: 用于通道维度的信息融合

数据流和纹理绑定

运行时输入绑定

// fsrapirendermodule.cpp 1376-1398
dispatchUpscale.color = m_pTempTexture;              // 渲染颜色 (RGB)
dispatchUpscale.depth = m_pDepthTarget;              // 深度缓冲 (R32F)
dispatchUpscale.motionVectors = m_pMotionVectors;    // 运动矢量 (RG16F)
dispatchUpscale.reactive = m_pReactiveMask;          // 响应遮罩 (R8)
dispatchUpscale.transparencyAndComposition = m_pCompositionMask; // 合成遮罩 (R8)
dispatchUpscale.output = m_pColorTarget;             // 输出缓冲 (RGBA16F)

神经网络输入打包

在预处理阶段，多个纹理被打包成7通道张量：

• 纹理采样: 使用双线性或Catmull-Rom重采样
• 格式转换: 从纹理格式转换为半精度浮点
• 归一化: 深度和运动矢量进行适当的缩放
• 遮罩融合: 将Reactive和Composition遮罩合并到第7通道

输出解包和后处理

神经网络的8通道输出被分解为：

• HDR颜色: 应用色调映射前的线性颜色空间
• 时间信息: 用于下一帧的时间累积
• 质量控制: 基于置信度进行自适应处理
• 锐化控制: 应用RCAS (Robust Contrast Adaptive Sharpening)

FSR4 整体工作流程

渲染管线集成概览

graph TD
    A[渲染管线开始] --> B[几何渲染]
    B --> C[G-Buffer生成]
    C --> D[光照计算]
    D --> E[半透明渲染]
    E --> F[粒子系统]
    F --> G[FSR4预处理]
    G --> H[神经网络推理]
    H --> I[FSR4后处理]
    I --> J[色调映射]
    J --> K[最终输出]

完整工作流程详解

阶段1: 渲染管线准备 (Pre-FSR4)

1.1 几何和光照渲染

RasterShadowRenderModule → GBufferRenderModule → LightingRenderModule

• 阴影渲染: 生成shadowmap用于光照计算
• G-Buffer: 生成法线、材质、运动矢量等信息
• 光照计算: PBR材质计算，生成HDR颜色

1.2 特殊效果渲染

SkyDomeRenderModule → TranslucencyRenderModule → GPUParticleRenderModule

• 天空盒: 环境光照和背景
• 半透明: 玻璃、水面等半透明材质
• 粒子系统: 烟雾、火花等特效，同时生成Reactive Mask

1.3 遮罩生成

• Reactive Mask: 标记粒子、特效区域 (R8格式)
• Composition Mask: 标记UI元素、半透明合成区域 (R8格式)

阶段2: FSR4预处理 (Pre-Processing)

2.1 输入验证和状态管理

// fsrapirendermodule.cpp:1406
dispatchUpscale.reset = m_ResetUpscale || GetScene()->GetCurrentCamera()->WasCameraReset();

• 重置检测: 检查相机是否发生突然变化
• 资源状态: 确保所有输入纹理处于正确状态
• Jitter计算: 计算子像素偏移用于时间抗锯齿

2.2 输入纹理预处理

Color Texture (HDR) + Depth Buffer + Motion Vectors + Masks → 7-Channel Tensor

• 格式转换: 各种纹理格式→半精度浮点
• 归一化处理:
• 颜色: 线性空间HDR → 网络输入范围
• 深度: Z-Buffer值 → 归一化深度
• 运动矢量: 像素空间 → 归一化坐标
• 遮罩: R8 → 浮点权重

2.3 Catmull-Rom重采样 (pre.hlsl)

• 高质量下采样: 从显示分辨率到渲染分辨率
• 抗锯齿: 减少下采样引入的锯齿
• 特征保持: 保持细节信息用于神经网络处理

阶段3: 神经网络推理 (14-Pass Inference)

3.1 编码阶段 (Pass 0-4)

Input(3840×2160×7) → Encoder1 → Encoder2 → Encoder3 → Feature(480×270×32)

Pass 0: 初始下采样

• 下采样卷积: 2×2步长，7→16通道
• 分辨率: 3840×2160×7 → 1920×1080×16
• 作用: 初步特征提取和分辨率缩减

Pass 1-2: Encoder2处理

• 残差块1: 深度可分离卷积，通道保持16
• 残差块2+下采样: 1920×1080×16 → 960×540×16
• 作用: 中层特征学习和空间降维

Pass 3-4: Encoder3处理

• 残差块1: 空间混合卷积，16通道
• 残差块2+下采样: 960×540×16 → 480×270×32
• 作用: 高级语义特征提取

3.2 瓶颈阶段 (Pass 5-8)

Bottleneck: 3×ResidualBlock + Upscale → Feature Enhancement

Pass 5-7: 深层特征处理

• 残差块×3: 480×270×32，深层特征学习
• 通道扩展: 16→32→64→32通道的扩张-收缩
• 作用: 最深层的语义理解和特征增强

Pass 8: 开始上采样

• 转置卷积: 480×270×32 → 960×540×16
• 作用: 开始重建高分辨率特征

3.3 解码阶段 (Pass 9-13)

Decoder3 → Decoder2 → Output(3840×2160×8)

Pass 9-10: Decoder3重建

• 残差块1: 空间混合，960×540×16
• 残差块2+上采样: 960×540×16 → 1920×1080×8
• 作用: 中等分辨率特征重建

Pass 11-12: Decoder2精细化

• 残差块×2: 1920×1080×8，精细特征重建
• 深度可分离卷积: 高效的细节恢复
• 作用: 高分辨率细节恢复

Pass 13: 最终上采样

• 转置卷积: 1920×1080×8 → 3840×2160×8
• 融合处理: 结合skip连接的多尺度特征
• 作用: 生成最终的8通道输出

阶段4: FSR4后处理 (Post-Processing)

4.1 神经网络输出解析 神经网络Pass 13的8通道输出需要特殊的后处理来生成最终图像：

// 从post.hlsl第437-438行的融合操作
FusedConv2D_DW_Conv2D_PW_Relu_Conv2D_Add_ConvTranspose2D(
    16.584852442729886, 0.06029598414897919, 22.7801944733756,
    0.043897781521081924, 0.06884194910526276,
    // 输入: (16, 1080, 1920) → 输出: (8, 2160, 3840)
    ...
);

神经网络8通道输出分解:

• 通道0-2: 基础上采样颜色 (Base upscaled color)
• 通道3: 滤波器相关参数 (correlation_factor)
• 通道4-5: X/Y轴缩放因子 (scale_factor_x/y)
• 通道6: 混合因子 (blending_factor)
• 通道7: 其他滤波参数

4.2 自适应滤波处理 (post_wmma.hlsl:9-55) FSR4使用神经网络输出的参数进行自适应高斯滤波：

float3 apply_model_filter(uint x, uint y, const float4 filter, const float exposureValue)
{
    // 1. 提取神经网络预测的滤波参数
    const float correlation_factor = ((exp(filter[0]) - exp(-filter[0])) / (exp(filter[0]) + exp(-filter[0])));
    const float scale_factor_x = 2.0 / (1.0 + exp(-filter[1]));
    const float scale_factor_y = 2.0 / (1.0 + exp(-filter[2]));

    // 2. 计算自适应高斯核
    const float gauss_weight = exp((-0.5 / (0.47 * 0.47)) *
        (x_dist2 * scale_factor_x2 + 2 * correlation_factor * (x_dist * y_dist) * scale_factor_xy + y_dist2 * scale_factor_y2));

    // 3. 应用滤波并累积
    upscaled_color += ApplyMuLaw(LoadInputColor(uint2(x_in, y_in)) * exposureValue) * gauss_weight;

    // 4. 与重投影颜色混合
    const float blending_factor = (1.0 / (1.0 + exp(-filter[3])));
    float3 res = upscaled_color * (1.0 - blending_factor) + r_reprojected_color[uint2(x, y)] * blending_factor;

    return res;
}

关键创新:

• 自适应核: 每个像素使用不同的高斯滤波核
• 智能混合: 基于神经网络预测的置信度进行时间混合
• 高频保持: 滤波参数保护重要的细节信息

4.3 资源管理和数据流 (ffx_fsr4_upscale_resources.h)

// 神经网络输出存储
StructuredBuffer<NETWORK_DATA_TYPE> r_network_output_rfm    : register(t10); // RFM输出
StructuredBuffer<NETWORK_DATA_TYPE> r_network_output_other  : register(t11); // 其他输出

// 后处理缓冲区
RWTexture2D<DATA_TYPE3>   rw_output_color_for_rcas : register(u10); // RCAS输入
RWTexture2D<float3>       rw_rcas_output           : register(u11); // 最终输出
RWTexture2D<float3>       rw_mlsr_output_color     : register(u2);  // 游戏最终输出

4.4 时间累积和稳定性

Current Frame + Historical Frames + Neural Weights → Temporal Result

• 运动补偿: 使用精细化运动矢量对齐历史帧
• 权重分配: 神经网络预测的时间混合权重
• 一致性检查: 检测和处理时间不一致性
• 鬼影抑制: 自动检测并减少temporal ghosting

4.5 自适应锐化 (RCAS) (rcas.hlsl) 最终的RCAS锐化处理：

void CurrFilter(FFX_MIN16_U2 pos)
{
    FfxFloat32x3 c;
    FsrRcasF(c.r, c.g, c.b, pos, rcasConfig); // 应用RCAS锐化

    c = RemoveMuLaw(c.rgb) / LoadExposureValue(); // 去除μ-law编码和曝光校正

    rw_rcas_output[pos] = FfxFloat32x4(c.rgb, 1.f); // 输出最终RGB
}

RCAS特性:

• 对比度自适应: 根据局部对比度调整锐化强度
• 边缘保护: 避免过度锐化导致的振铃效应
• 高效实现: 使用64×1×1线程组优化内存访问

从神经网络输出到最终图像的完整流程

数据变换过程

graph TD
    A[神经网络8通道输出3840×2160×8] --> B[通道分离]
    B --> C[滤波参数提取Channels 3-7]
    B --> D[基础颜色提取Channels 0-2]
    C --> E[自适应高斯滤波]
    D --> E
    E --> F[时间累积混合]
    F --> G[μ-law去编码]
    G --> H[曝光校正]
    H --> I[RCAS锐化]
    I --> J[最终RGB输出3840×2160×3]

关键技术原理

1. 智能滤波:

• 神经网络为每个像素预测最优的滤波参数
• 自适应调整滤波核的形状和强度
• 保护重要的高频细节信息

2. 时间一致性:

• 基于神经网络预测的混合权重
• 智能的历史帧对齐和融合
• 自动检测和处理时间不稳定性

3. 感知优化:

• μ-law编码保护视觉重要区域
• HDR/曝光感知处理
• 对比度自适应锐化

4. 硬件优化:

• AMD WMMA指令加速矩阵运算
• 内存coalescing优化
• 64×1×1线程组高效执行

这种设计使FSR4能够：

• 智能上采样: 每个像素使用最优处理策略
• 时间稳定: 减少闪烁和temporal artifacts
• 细节保护: 恢复和增强高频信息
• 实时性能: 在现代GPU上达到实时帧率

阶段5: 质量控制和优化

5.1 置信度驱动的质量控制

if (confidence < threshold) {
    apply_fallback_processing();
}

• 低置信度检测: 识别网络输出质量较低的区域
• 回退处理: 对低置信度区域应用传统方法
• 混合权重: 动态调整神经网络和传统方法的权重

5.2 响应式处理

• 粒子区域: 基于Reactive Mask的特殊处理
• UI区域: 基于Composition Mask的锐度保持
• 动态调整: 根据场景内容调整处理策略

5.3 性能优化策略

• Async Compute: 与图形管线并行执行
• Memory Coalescing: 优化内存访问模式
• Wavefront Optimization: 针对AMD GPU的波前优化

与Frame Generation的协同工作

FSR4 Upscaling → Frame Generation → Display

帧生成集成:

1. 运动矢量传递: FSR4精细化的运动矢量用于帧生成
2. 时序一致性: 确保上采样和帧生成的时间一致性
3. 质量平衡: 在上采样质量和帧生成效果间取得平衡

实时性能特性

延迟控制:

• 单帧处理: 每帧独立处理，无多帧依赖
• 管线化: 14个Pass可以管线化执行
• 内存优化: 79.1MB暂存内存高效复用

质量vs性能平衡:

• 质量预设: Quality/Balanced/Performance/Ultra Performance
• 动态调整: 基于GPU负载动态调整质量
• 帧率目标: 优先保证帧率稳定性

模型复杂度分析

参数统计

基于权重数组大小的粗略估算：

• 总权重参数: 约 50,000+ 参数
• 内存占用: ~79.1MB 暂存 + ~200KB 权重
• 计算复杂度: 约 100+ GFLOPS（针对4K推理）

设计亮点

1. 多尺度特征融合: 编码器-解码器架构支持多尺度特征学习
2. 残差学习: 大量残差块确保梯度流动和特征保持
3. 深度可分离卷积: 减少参数量的同时保持表达能力
4. 硬件加速: 针对AMD RDNA 3+架构的特定优化

与传统FSR的区别

特性	FSR 2/3	FSR 4
方法	传统算法（TAA+锐化）	深度神经网络
权重文件	无	嵌入在Shader中
计算资源	低	高（需要ML推理）
质量	良好	优秀（特别是细节重建）
硬件要求	广泛兼容	需要Shader Model 6.6

FSR4对透明物体和Shading Change的处理机制

透明物体和运动矢量缺失的处理

1. 反应式遮罩（Reactive Mask）系统

FSR4使用双重遮罩系统来识别和处理透明物体：

Reactive Mask生成 (fsrapirendermodule.cpp:1667-1700):

// 自动反应式遮罩生成
ffx::DispatchDescUpscaleGenerateReactiveMask dispatchDesc{};
dispatchDesc.colorOpaqueOnly = m_pOpaqueTexture;      // 仅不透明物体的颜色
dispatchDesc.colorPreUpscale = m_pColorTarget;        // 包含透明物体的完整颜色
dispatchDesc.outReactive = m_pReactiveMask;           // 输出反应式遮罩

// 关键参数设置
dispatchDesc.cutoffThreshold = 0.2f;         // 差异检测阈值
dispatchDesc.binaryValue = 0.9f;             // 高反应区域的标记值

工作原理：

• 比较不透明渲染和完整渲染的颜色差异
• 差异超过阈值(0.2f)的区域被标记为高反应区域
• 这些区域主要包含透明物体、粒子特效、UI元素

Composition Mask处理 (fsrapirendermodule.cpp:91-103):

// 透明物体渲染时的额外输出
transOptions.OptionalAdditionalExports =
    L"output.CompositionTarget = max(Alpha, hasAnimatedTexture);";

• 直接存储透明物体的Alpha值
• 动画纹理也被标记为需要特殊处理的区域

2. Disocclusion Detection（遮挡检测）

运动矢量有效性检查 (mlsr_optimized_includes.hlsli:171-181):

bool local_disocclusion_user(uint2 tid, inout float2 velocity)
{
    // 检测无效运动矢量的多重条件
    if (any(isnan(velocity)) ||           // NaN检查
        any(isinf(velocity)) ||           // 无限大检查
        any(velocity > 1000000.f))        // 异常大值检查
    {
        velocity = float2(0, 0);          // 重置为零运动
        return true;                      // 标记为遮挡
    }
    return false;
}

透明物体的运动矢量问题：

• 透明物体通常没有可靠的运动矢量信息
• 粒子系统可能产生极大或无效的运动矢量
• FSR4通过检测异常值自动识别这些区域

3. 运动矢量稀释（Motion Vector Dilation）

深度导向的矢量选择 (mlsr_optimized_includes.hlsli:115-169):

int2 dilate_mv(uint2 tid, float2 origin_offset, Texture2D<float> depth_tex)
{
    // 8邻域深度采样
    for (uint i = 0; i < 8; i++)
    {
        int2 neighbor_pos = tid + depth_offsets[i];
        float neighbor_depth = depth_tex[neighbor_pos];

        // 选择最近物体的运动矢量
        if (neighbor_depth < closest_depth)
        {
            closest_depth = neighbor_depth;
            selected_pos = neighbor_pos;
        }
    }
    return selected_pos;  // 返回最可靠的运动矢量位置
}

处理策略：

• 当透明物体缺乏运动矢量时，使用背景物体的运动矢量
• 通过深度比较找到最近的可靠几何体
• 确保时间重投影有合理的参考

Shading Change的检测和处理

1. 色度距离检测

YCbCr色彩空间分析 (pre_wmma.hlsl:185-202):

// 颜色变化检测
float3 input_ycbcr = RGBtoYCbCr(upscale_input.xyz);    // 当前帧
float3 history_ycbcr = RGBtoYCbCr(history);            // 历史帧

// 计算色度差异（Cb和Cr分量）
const float color_distance = sqrt(
    pow(input_ycbcr.y - history_ycbcr.y, 2) +   // Cb差异
    pow(input_ycbcr.z - history_ycbcr.z, 2) +   // Cr差异
    1e-6);                                       // 数值稳定性

// 作为神经网络输入通道2
downscaleInputs[0].z = NETWORK_DATA_TYPE(color_distance);

技术优势：

• YCbCr分离: 亮度(Y)和色度(CbCr)独立处理
• 色度敏感: 专注检测材质、光照变化而非亮度波动
• 神经网络输入: 色度距离直接输入网络，用于学习适应策略

2. 循环状态的时间记忆

跨帧特征传递 (pre_wmma.hlsl:195-201):

// 循环状态：来自上一帧的网络输出记忆
downscaleInputs[0].w = MODEL_RFM_NORMALIZE(recurrent[0]);  // R通道记忆
downscaleInputs[1].x = MODEL_RFM_NORMALIZE(recurrent[1]);  // G通道记忆
downscaleInputs[1].y = MODEL_RFM_NORMALIZE(recurrent[2]);  // B通道记忆
downscaleInputs[1].z = MODEL_RFM_NORMALIZE(recurrent[3]);  // A通道记忆

记忆机制：

• 循环状态保存: 上一帧网络输出的特征表示
• 时间连续性: 帮助网络理解和预测场景变化趋势
• 自适应学习: 根据历史模式调整当前帧的处理策略

3. 动态时间权重调整

基础权重计算 (pre_wmma.hlsl:144-146):

const float history_rect_alpha = 0.1f;  // 基础混合因子
float temporal_sample_weight = upscale_input.a * history_rect_alpha;

神经网络权重预测 (post_wmma.hlsl:51-54):

// 神经网络输出的混合因子（通道3）
const float blending_factor = 1.0 / (1.0 + exp(-filter[3]));

// 智能时间混合
float3 res = upscaled_color * (1.0 - blending_factor) +
             r_reprojected_color[uint2(x, y)] * blending_factor;

自适应策略：

• 内容感知: 神经网络为每个像素预测最优混合权重
• 变化敏感: 检测到shading change时降低历史帧权重
• 稳定区域: 静态区域使用更多历史信息提高质量

处理无运动矢量透明物体的完整流程

阶段1: 渲染时标记

不透明渲染 → 保存ColorOpaqueOnly
     ↓
透明物体渲染 → 输出Alpha到CompositionMask
     ↓
差异检测 → 生成ReactiveMask

阶段2: FSR4预处理

运动矢量检查 → 检测无效值 → 标记为Disocclusion
     ↓
深度稀释 → 使用背景物体运动矢量
     ↓
色度距离 → 输入神经网络通道2

阶段3: 神经网络推理

7通道输入 → 14-Pass网络 → 8通道滤波参数
(包含色度距离和循环状态)

阶段4: 智能后处理

提取混合因子 → 自适应时间权重
     ↓
高反应区域 → 更多依赖当前帧
     ↓
稳定区域 → 更多使用历史帧

关键技术创新

1. 多重检测机制: 反应式遮罩 + 运动矢量检查 + 色度距离
2. 智能替代策略: 深度稀释提供可靠的运动参考
3. 神经网络驱动: 端到端学习最优的时间混合策略
4. 像素级自适应: 每个像素独立的处理决策

这种设计使FSR4能够高质量地处理透明物体、粒子特效和复杂光照变化，同时保持实时性能。

FSR 4 是一个革命性的循环神经网络超分辨率系统，具有以下核心创新：

1. 循环神经网络架构

• 时间记忆机制: 通过循环状态保持跨帧特征连续性，类似LSTM的记忆机制
• 多帧融合: 同时处理当前帧、历史帧和循环状态，实现真正的时间建模
• 运动补偿: 使用Catmull-Rom重采样和运动矢量实现高质量的历史帧对齐

2. 智能自适应滤波

• 参数化滤波: 神经网络输出滤波器参数而非直接颜色，实现像素级自适应处理
• 各向异性处理: 支持X/Y方向独立的滤波缩放，处理不同方向的特征
• 内容感知混合: 基于神经网络预测的置信度进行智能的时间混合

3. 硬件优化设计

• Int8量化: 所有权重使用8位整数量化，减少内存占用和提高推理速度
• AMD WMMA加速: 充分利用AMD RDNA 3+架构的Wave Matrix Multiply指令
• 高效内存布局: NHWC格式和优化的内存访问模式

4. 编码器-解码器拓扑

• 14个推理Pass: 从Pass 0到Pass 13的系统化处理流程
• 多尺度特征: 通过下采样和上采样实现不同分辨率的特征学习
• 残差连接: 保持梯度流动和特征传递

5. 实时性能

• 管线化执行: 14个Pass可以管线化并行执行
• 内存复用: 79.1MB暂存内存的高效管理
• 质量可调: 多种质量预设适应不同性能需求

FSR4的这种设计使其能够在保持实时性能的同时，提供接近或超越传统方法的图像质量，特别是在处理复杂运动场景和细节保持方面表现突出。其循环神经网络架构和智能滤波机制代表了实时超分辨率技术的重要突破。

---

本分析基于FSR4 v0.7质量预设的HLSL Compute Shader代码进行逆向工程，可能存在细节偏差。