【LUT技术专题】SPLUT代码解读

最新推荐文章于 2025-12-16 10:44:31 发布
原创 最新推荐文章于 2025-12-16 10:44:31 发布 · 944 阅读 · 30 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#python #深度学习 #开发语言

目录

原文概要

1. 训练

2. 转表

3. 测试

本文是对SPLUT技术的代码解读，原文解读请看SPLUT。

原文概要

SPLUT通过增大网络感受野，来提升超分效果，实现SRLUT的改进，主要两个创新点：

  • 提出了一个无需旋转集成、多LUT串联和并联的方法来提升感受野。
  • 提出了一个并行网络做补偿，来改善LUT的量化误差问题。

其网络结构图如下：

Query Blocks：

代码结构如下：


我们这里以后缀为M的SPLUT为例进行讲解。

1. 训练

代码位于Train_SPLUT_M.py文件中，某一个分支结构实现如下，MSB和LSB都会经过下面的结构，处理后相加就得到最终结果，跟前面讲到的结构是对应的：

class SRNet(torch.nn.Module):
    def __init__(self, upscale=4):
        super(SRNet, self).__init__()

        self.upscale = upscale
        self.lvls = 16
        self.quant= BASEQ(self.lvls ,8.0)
        self.out_channal= OUT_NUM

        #cwh
        self.lut122=nn.Sequential(
            nn.Conv2d(1, 64, [2,2], stride=1, padding=0, dilation=1),
            nn.GELU(),
            nn.Conv2d(64, 64, 1, stride=1, padding=0, dilation=1),
            nn.GELU(),
            nn.Conv2d(64, 8, 1, stride=1, padding=0, dilation=1)
        )

        self.lut221=nn.Sequential(
            nn.Conv2d(2,  64, [2,1], stride=1, padding=0, dilation=1),
            nn.GELU(),
            nn.Conv2d(64, 64, 1, stride=1, padding=0, dilation=1),
            nn.GELU(),
            nn.Conv2d(64, 64, 1, stride=1, padding=0, dilation=1),
            nn.GELU(),
            nn.Conv2d(64, 8, 1, stride=1, padding=0, dilation=1)
        )

        self.lut212=nn.Sequential(
            nn.Conv2d(2,  64, [1,2], stride=1, padding=0, dilation=1),
            nn.GELU(),
            nn.Conv2d(64, 64, 1, stride=1, padding=0, dilation=1),
            nn.GELU(),
            nn.Conv2d(64, 64, 1, stride=1, padding=0, dilation=1),
            nn.GELU(),
            nn.Conv2d(64, 8, 1, stride=1, padding=0, dilation=1)
        )

        self.lut221_c12=nn.Sequential(
            nn.Conv2d(2,  64, [2,1], stride=1, padding=0, dilation=1),
            nn.GELU(),
            nn.Conv2d(64, 64, 1, stride=1, padding=0, dilation=1),
            nn.GELU(),
            nn.Conv2d(64, 64, 1, stride=1, padding=0, dilation=1),
            nn.GELU(),
            nn.Conv2d(64, 16, 1, stride=1, padding=0, dilation=1)
        )

        self.lut212_c34=nn.Sequential(
            nn.Conv2d(2,  64, [1,2], stride=1, padding=0, dilation=1),
            nn.GELU(),
            nn.Conv2d(64, 64, 1, stride=1, padding=0, dilation=1),
            nn.GELU(),
            nn.Conv2d(64, 64, 1, stride=1, padding=0, dilation=1),
            nn.GELU(),
            nn.Conv2d(64, 16, 1, stride=1, padding=0, dilation=1)
        )

        self.pixel_shuffle = nn.PixelShuffle(upscale)

        # Init weights
        for m in self.modules():
            classname = m.__class__.__name__
            if classname.lower().find('conv') != -1:
                nn.init.kaiming_normal(m.weight)
                nn.init.constant(m.bias, 0)
            elif classname.find('bn') != -1:
                m.weight.data.normal_(1.0, 0.02)
                m.bias.data.fill_(0)

    def forward(self, x_in):
        B, C, H, W = x_in.size()
        x_in = x_in.reshape(B*C, 1, H, W)
        x = self.lut122(x_in)+x_in[:,:,:H-1,:W-1]
        x_temp=x_in
        x221 = self.lut221(self.quant(F.pad(x[:,0:2,:,:],(0,0,0,1), mode='reflect')+F.pad(x[:,2:4,:,:],(0,0,1,0), mode='reflect')))
        x212 = self.lut212(self.quant(F.pad(x[:,4:6,:,:],(0,1,0,0), mode='reflect')+F.pad(x[:,6: ,:,:],(1,0,0,0), mode='reflect')))
        x=(x221+x212)/2.0+x

        x2 = self.lut221_c12(self.quant(F.pad(x[:,0:2,:,:],(0,0,0,1), mode='reflect')+F.pad(x[:,2:4,:,:],(0,0,1,0), mode='reflect')))
        x3 = self.lut212_c34(self.quant(F.pad(x[:,4:6,:,:],(0,1,0,0), mode='reflect')+F.pad(x[:,6: ,:,:],(1,0,0,0), mode='reflect')))
        x=(x2+x3)/2.0+x_temp[:,:,:H-1,:W-1]
        x = self.pixel_shuffle(x)
        x = x.reshape(B, C, self.upscale*(H-1), self.upscale*(W-1))
        return x

可以看到self.lut122代表了空间的lut，即Spatial Lookup。

接下来计算x221，先忽略quant算子，可以看到F.pad(x[:,0:2,:,:],(0,0,0,1), mode='reflect')+F.pad(x[:,2:4,:,:],(0,0,1,0), mode='reflect')，这个过程代表了Query Blocks里的horizontal aggregate模块。再进行LUT221，即LUT WC的操作，这样子完成Query Blocks的一个支路。x212即是对应的vertical部分，这两部分加起来之后除以2即可。

接下来是重复的计算x2和x3，最后经过一个pixel_shuffle完成超分即可。

然后是量化节点的实现，代码如下：

class _baseq(torch.autograd.Function):
    @staticmethod
    def forward(ctx, x, steps):
        y_step_ind=torch.floor(x / steps)
        y = y_step_ind * steps
        return y

    @staticmethod
    def backward(ctx, grad_output):
        return grad_output, None

class BASEQ(nn.Module):
    def __init__(self, lvls,activation_range):
        super(BASEQ, self).__init__()
        self.lvls = lvls
        self.activation_range = activation_range
        self.steps = 2 * activation_range / self.lvls

    def forward(self, x):
        x=(((-x - self.activation_range).abs() - (x - self.activation_range).abs()))/2.0
        x[x > self.activation_range-0.1*self.steps] =self.activation_range-0.1*self.steps
        return _baseq.apply(x, self.steps)

量化节点是这个BASEQ类，作者给的lvls和activation_range的默认值分别是16和8，因此steps就是1，前向第一步是等价一个torch.clip操作，大于activation range是activation range，小于-activation range是-activation range，在-activation range和activation range之间是x（这里可以将不同情况下的输入带入代码中计算，可以得到这个结论），第二步博主这里认为是由于带符号数正数和负数是不对称的，例如一个4bit的输入，它的值域范围是[-8, 7]，因此这里对正数做了进一步的clip，来减小这个误差。最后应用_baseq的量化算子，因为steps是1，这里Funcition的forward完成的是一个向下取整的floor操作，backward完成的就是STE，直接将梯度传递下去，保证整个网络的可导性。

2. 转表

在Transfer_SPLUT_M.py中，这里跟SRLUT基本一致，根据LUT类型，先构造4bit的输入，如下：

L = 2 ** img_bits
 base_step_ind=torch.arange(0, L, 1)
 base=base_step_ind/16.0
 index_4D=torch.meshgrid(base,base,base,base)
 onebyfourth=torch.cat([index_4D[0].flatten().unsqueeze(1),index_4D[1].flatten().unsqueeze(1),index_4D[2].flatten().unsqueeze(1),index_4D[3].flatten().unsqueeze(1)],1)
 
 base_B=base_step_ind/16.0
 index_4D_B=torch.meshgrid(base_B,base_B,base_B,base_B)
 onebyfourth_B=torch.cat([index_4D_B[0].flatten().unsqueeze(1),index_4D_B[1].flatten().unsqueeze(1),index_4D_B[2].flatten().unsqueeze(1),index_4D_B[3].flatten().unsqueeze(1)],1)

if LUT_NUM==1:
    input_tensor   = onebyfourth.unsqueeze(1).unsqueeze(1).reshape(-1,1,2,2)
    input_tensor_B = onebyfourth_B.unsqueeze(1).unsqueeze(1).reshape(-1,1,2,2)
elif KERNAL==221:
    input_tensor = onebyfourth.unsqueeze(1).unsqueeze(1).reshape(-1,2,2,1)
    input_tensor_B = onebyfourth.unsqueeze(1).unsqueeze(1).reshape(-1,2,2,1)
elif KERNAL==212:
    input_tensor = onebyfourth.unsqueeze(1).unsqueeze(1).reshape(-1,2,1,2)
    input_tensor_B = onebyfourth.unsqueeze(1).unsqueeze(1).reshape(-1,2,1,2)


再送入之前训练好的层中输出结果并将其保存即可。

3. 测试

在Inference_SPLUT_M.py中，这里只是将网络的部分用LUT表去实现了，而且前面也讲到了，SPLUT是4bit的，不用量化，所以它的测试中不存在插值，所以与网络推理的代码就非常相像了。如下：

 img_in = np.pad(img_lr, ((0,1), (0,1), (0,0)), mode='reflect').transpose((2,0,1))
    img_in_A255 = img_in// L
    img_in_B255 = img_in % L
    img_in_A = img_in_A255/L
    img_in_B = img_in_B255/L

    # A
    x_layer1=LUT1_122(LUTA1_122,img_in_A255)+img_in_A[:,0:h,0:w].reshape((3,1,h,w))
    x2_in1=np.pad(x_layer1[:,0:2,:,:],((0,0),(0,0),(0,1),(0,0)), mode='reflect')+np.pad(x_layer1[:,2:4,:,:],((0,0),(0,0),(1,0),(0,0)), mode='reflect')
    x2_in2=np.pad(x_layer1[:,4:6,:,:],((0,0),(0,0),(0,0),(0,1)), mode='reflect')+np.pad(x_layer1[:,6: ,:,:],((0,0),(0,0),(0,0),(1,0)), mode='reflect')
    x_layer2=(LUT23(LUTA2_221, x2_in1,8.0 ,'k221',2)+LUT23(LUTA2_212, x2_in2,8.0 ,'k212',2))/2.0+x_layer1
    x3_in1=np.pad(x_layer2[:,0:2,:,:],((0,0),(0,0),(0,1),(0,0)), mode='reflect')+np.pad(x_layer2[:,2:4,:,:],((0,0),(0,0),(1,0),(0,0)), mode='reflect')
    x3_in2=np.pad(x_layer2[:,4:6,:,:],((0,0),(0,0),(0,0),(0,1)), mode='reflect')+np.pad(x_layer2[:,6: ,:,:],((0,0),(0,0),(0,0),(1,0)), mode='reflect')
    img_out=(LUT23(LUTA3_221, x3_in1,8.0 ,'k221',3)+LUT23(LUTA3_212, x3_in2,8.0 ,'k212',3))/2.0+img_in_A[:,0:h,0:w].reshape((3,1,h,w))
    img_out=img_out.reshape((3,UPSCALE,UPSCALE,h,w))
    img_out=np.transpose(img_out,(0,3,1,4,2)).reshape((3,UPSCALE*h,UPSCALE*w))    
    img_out_A = img_out.transpose((1,2,0))
    # B
    x_layer1=LUT1_122(LUTB1_122,img_in_B255)+img_in_B[:,0:h,0:w].reshape((3,1,h,w))
    x2_in1=np.pad(x_layer1[:,0:2,:,:],((0,0),(0,0),(0,1),(0,0)), mode='reflect')+np.pad(x_layer1[:,2:4,:,:],((0,0),(0,0),(1,0),(0,0)), mode='reflect')
    x2_in2=np.pad(x_layer1[:,4:6,:,:],((0,0),(0,0),(0,0),(0,1)), mode='reflect')+np.pad(x_layer1[:,6: ,:,:],((0,0),(0,0),(0,0),(1,0)), mode='reflect')
    x_layer2=(LUT23(LUTB2_221, x2_in1,8.0 ,'k221',2)+LUT23(LUTB2_212, x2_in2,8.0 ,'k212',2))/2.0+x_layer1
    x3_in1=np.pad(x_layer2[:,0:2,:,:],((0,0),(0,0),(0,1),(0,0)), mode='reflect')+np.pad(x_layer2[:,2:4,:,:],((0,0),(0,0),(1,0),(0,0)), mode='reflect')
    x3_in2=np.pad(x_layer2[:,4:6,:,:],((0,0),(0,0),(0,0),(0,1)), mode='reflect')+np.pad(x_layer2[:,6: ,:,:],((0,0),(0,0),(0,0),(1,0)), mode='reflect')
    img_out=(LUT23(LUTB3_221, x3_in1,8.0 ,'k221',3)+LUT23(LUTB3_212, x3_in2,8.0 ,'k212',3))/2.0+img_in_B[:,0:h,0:w].reshape((3,1,h,w))
    img_out=img_out.reshape((3,UPSCALE,UPSCALE,h,w))
    img_out=np.transpose(img_out,(0,3,1,4,2)).reshape((3,UPSCALE*h,UPSCALE*w))    
    img_out_B = img_out.transpose((1,2,0))

    img_out=img_out_A+img_out_B
    img_out = np.round(np.clip(img_out, 0, 1) * 255).astype(np.uint8)

可见，开始先获取MSB和LSB，然后送入LUT表中推理，过程跟我们前面的网络的推理过程是非常相像的，数据只不过是numpy.array和torch.Tensor的区别。

【LUT技术专题】SRLUT：Practical Single-Image Super-Resolution Using Look-Up Table
PixelMind的博客
04-14 2187
一种极轻量超分算法，提出了模型训练+LUT推理的创新性图像处理范式。用查表来代替模型推理，无需计算过程。适用于算力有限且有SR需求的端侧应用。
Python中的split()函数的用法
热门推荐
u014229742的博客
01-03 1万+
原文：https://www.cnblogs.com/liujiacai/p/7839971.html Python split() 通过指定分隔符对字符串进行切片，如果参数 num 有指定值，则分隔 num+1 个子字符串 Python中有split()和os.path.split()两个函数，具体作用如下： split()：拆分字符串。通过指定分隔符对字符串进行切片，并返回分割后的字符串列表（...
【LUT技术专题】ECLUT代码解读
PixelMind的博客
05-09 1458
本文是对ECLUT技术的代码解读，原文解读请看。
【LUT技术专题】SPLUT: Learning Series-Parallel Lookup Tables for Efficient Image Super-Resolution
PixelMind的博客
04-23 1469
Look-Up Table（查找表，LUT）是一种数据结构（也可以理解为字典），通过输入的key来查找到对应的value。其优势在于无需计算过程，不依赖于GPU、NPU等特殊硬件，本质就是一种内存换算力的思想。LUT在图像处理中是比较常见的操作，如Gamma映射，3D CLUT等。近些年，LUT技术已被用于深度学习领域，由SR-LUT启发性地提出了模型训练+LUT推理的新范式。本专题旨在跟进和解读LUT技术的发展趋势，为读者分享最全最新的LUT方法，欢迎一起探讨交流。
【LUT技术专题】4DLUT代码讲解
PixelMind的博客
06-14 1258
本文解读了4DLUT技术的核心代码实现。4DLUT通过引入上下文编码器提取像素级上下文信息，与RGB图像组成4通道输入，克服了传统3DLUT的局部处理局限。代码实现包含三个核心模块： 1）Context Encoder（Generator_for_info类）生成上下文映射； 2）Param Encoder（Generator_for_bias类）输出12个融合参数； 3）4DLUT初始化与融合（Generator4DLUT_identity类）加载基础LUT并执行四次线性插值。此外还包含平滑/单调性正则损
【LUT技术专题】AdaInt代码讲解
PixelMind的博客
06-20 1247
摘要： 本文对AdaInt技术进行代码解读，该技术针对3DLUT均匀采样的不足，提出自适应采样间隔方法以减少非线性段插值误差。代码基于MMEditing框架实现，核心模块包括TPAMIBackbone（轻量CNN）和LUTGenerator（权重预测与基础LUT生成）。TPAMIBackbone通过5层卷积提取特征，LUTGenerator则结合线性层生成权重和基础LUT，并通过非均匀采样优化3DLUT渲染。
【LUT技术专题】SepLUT代码讲解
PixelMind的博客
06-25 1100
SepLUT技术将传统3DLUT分解为颜色无关的1DLUT和颜色相关的3DLUT，实现高效图像增强。其核心流程包括：轻量级CNN提取context向量，生成3个1DLUT和1个3DLUT作为变换权重，通过高效查找与插值完成增强。代码基于mmedit框架实现，主要模块包括splut_transform（插值运算CPP实现）和model.py（网络主干）。SepLUT类整合了backbone、权重预测器和LUT生成器，支持量化处理，并通过稀疏性、平滑性等正则化约束优化效果。该设计平衡了计算效率与增强性能，适用于
【LUT技术专题】CLUT代码讲解
PixelMind的博客
07-04 845
代码实现核心的部分讲解完毕，跟以往最不同的部分就在于这个CLUT的计算矩阵，把这部分看明白就行。
【LUT技术专题】LUT空间的极致压缩-SPFLUT
PixelMind的博客
05-11 1558
SPFLUT提出了一种基于查找表（LUT）的高效图像恢复方法，通过压缩策略减少LUT的冗余，提升性能并降低存储需求。该方法的核心是对角线优先压缩策略（DFC），针对LUT中对角线区域的高频使用特点，保留对角线部分并减少非对角线区域的采样，从而显著减小LUT尺寸。SPFLUT还设计了一个多LUT网络结构，增强了通道特征融合，进一步提升了恢复效果。实验表明，该方法在效果和存储效率之间达到了最佳平衡，尤其在LUT尺寸大幅减小的情况下，性能依然保持优异。
MODIS气溶胶反演系统：LUT技术实现与idl源代码分析
此外，文件还包括了生成查找表（LUT）所用到的文本文件，以及专门的IDL源代码模块，如modis_Aerosol_inversion.pro，用于MODIS气溶胶反演的主要计算。 ### 总结： 这份压缩文件为研究者提供了完整的工具和文档，...
利用LUT（查找表）进行 MODIS气溶胶反演系统、源代码和说明文档 完整版
04-15
利用LUT（查找表）进行 MODIS气溶胶反演系统、源代码和说明文档。 本压缩文件包含利用LUT（查找表）进行MODIS气溶胶反演的系统、源代码及说明文档 源代码为idl的pro文件,易于学习查看 还附赠了6s大气传输模型用以...
精选资源
LUT.rar_.lut_LUT
09-19
在IT领域，颜色查找表（LUT，Lookup Table）是一种常用的技术，特别是在图像处理和视频编辑中，用于快速改变图像的颜色表现。标题中的"LUT.rar_.lut_LUT"表明这是一个包含LUT相关资源的压缩包文件，而描述提到是用...
lut,影片专用，视频lut 图片lut，一健调色
12-08
在当今的影像制作领域，LUT（Look-Up Table）作为一种颜色校正和预设的工具，对提升视频质量起着至关重要的作用。LUT本质上是一个表格，它能将源图像的色彩空间映射到一个预设的色彩空间，从而达到调整色彩、对比度...
MODIS气溶胶反演系统与LUT技术：完整指南与源代码解析
综上所述，该文档提供的是一套完整的MODIS气溶胶反演系统，该系统利用LUT技术，结合6S大气传输模型生成的查找表，通过idl编写源代码进行气溶胶的反演分析。系统还包括了详细的使用说明文档，并适用于ENVI遥感图像...
javascript 性能优化实战：异步和延迟加载
小伙伴们全都Lucky！
12-11 932
本文探讨JavaScript性能优化中的异步加载与延迟加载技术。异步加载通过async/defer属性或动态创建script元素避免阻塞渲染；延迟加载则利用IntersectionObserver API按需加载非关键资源。二者结合可显著提升性能：异步加载核心脚本确保交互流畅，延迟加载减少初始请求量。实践表明，该方案能降低DOMContentLoaded时间30%以上，减少初始加载量90%，但需注意async脚本的执行顺序问题和延迟加载的回退处理。文中提供了完整的代码实现示例。
[Python实战] 解决Outlook同步中的字符编码问题：表情符号也能正确处理了！
最新发布
每日出拳老爷子的博客
12-16 126
摘要：本文分享了在使用Python同步Outlook会议信息时遇到的GBK编码问题解决方案。当处理包含表情符号（如📧）的会议内容时，Flask返回JSON会报"'gbk' codec can't encode"错误。作者通过封装ensure_utf8函数对文本进行UTF-8编码处理，同时建议设置Flask响应头编码为UTF-8和调整控制台输出编码，有效解决了特殊字符导致的编码异常问题。文章提供了从问题分析到完整解决方案的实践过程，适用于处理Python中的Unicode编码问题。
Python 语言编码规范
托塔天王的博客
12-11 974
通常， 不应该描述”怎么做”， 除非是一些复杂的算法，文档字符串应该提供足够的信息， 当别人编写代码调用该函数时，他不需要看一行代码，只要看文档字符串就可以了，对于复杂的代码，在代码旁边加注释会比使用文档字符串更有意义。但是，不要使用一个以上的空格，并且在二元运算符的两边使用相同数量的空格。当捕获异常时， 使用as而不要用逗号。3、 关于函数的几个方面应该在特定的小节中进行描述记录， 这几个方面如下文所述，每节应该以一个标题行开始，标题行以冒号结尾，除标题行外， 节的其他内容应被缩进2个空格。
《Python实战小课：爬虫工具场景——开启数据抓取之旅》导读
2501_93253814的博客
12-15 985
本文介绍了Python爬虫技术在三大场景中的应用：行业资讯爬取、学术文献摘要获取和电商评价收集。针对行业资讯，详细解析了从网页请求到数据存储的全流程；在学术文献方面，重点阐述了如何构建搜索请求和提取关键信息；对于电商评价，则说明了数据定位和清洗方法。文章还探讨了爬虫优化策略及反爬机制应对方案，为数据获取工作提供了实用指南。通过系统学习这些技术，读者可以提升数据采集能力，为商业决策、学术研究和市场分析提供有力支持。
Windows11系统安装Isaac Sim和Isaac Lab记录
weixin_65198494的博客
12-13 422
本文介绍了在Windows 11系统上安装IsaacSim和IsaacLab的完整流程。硬件配置为RTX4060显卡、32GB内存，软件环境包括NVIDIA驱动591.44、CUDA12.8、PyTorch2.7.0和Python3.11。安装IsaacSim5.1的主要步骤包括：更新GPU驱动、安装CUDA、创建conda虚拟环境、开启长路径支持、更新pip后安装IsaacSim pip包。IsaacLab安装则需要克隆GitHub仓库，通过安装脚本完成。最后通过运行验证脚本确认安装成功。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值