pytoflow的net

最新推荐文章于 2025-06-06 19:09:24 发布
最新推荐文章于 2025-06-06 19:09:24 发布
阅读量354 收藏
点赞数
分类专栏： 超分模型学习 文章标签： 深度学习 python tensorflow
原文链接：https://github.com/Coldog2333/pytoflow/blob/master/Network.py
版权
该博客介绍了一个基于PyTorch实现的光流估计网络SpyNet，以及相关图像处理操作，如归一化、反归一化、光流反向传播等。模型包括SpyNet、warp模块和ResNet，适用于图像插值、去噪、超分辨率等任务。此外，还提供了一个名为TOFlow的模块，用于整合这些功能并处理多帧图像。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

参考文献：https://github.com/Coldog2333/pytoflow
（https://github.com/anchen1011/toflow）
在这里插入图片描述

import math
import torch
# import torch.utils.serialization   # it was removed in torch v1.0.0 or higher version.

arguments_strModel = 'sintel-final'
SpyNet_model_dir = './models'  # The directory of SpyNet's weights

def normalize(tensorInput):
    tensorRed = (tensorInput[:, 0:1, :, :] - 0.485) / 0.229
    tensorGreen = (tensorInput[:, 1:2, :, :] - 0.456) / 0.224
    tensorBlue = (tensorInput[:, 2:3, :, :] - 0.406) / 0.225
    return torch.cat([tensorRed, tensorGreen, tensorBlue], 1)


def denormalize(tensorInput):
    tensorRed = (tensorInput[:, 0:1, :, :] * 0.229) + 0.485
    tensorGreen = (tensorInput[:, 1:2, :, :] * 0.224) + 0.456
    tensorBlue = (tensorInput[:, 2:3, :, :] * 0.225) + 0.406
    return torch.cat([tensorRed, tensorGreen, tensorBlue], 1)


Backward_tensorGrid = {}

def Backward(tensorInput, tensorFlow, cuda_flag):
    if str(tensorFlow.size()) not in Backward_tensorGrid:
        tensorHorizontal = torch.linspace(-1.0, 1.0, tensorFlow.size(3)).view(1, 1, 1, tensorFlow.size(3)).expand(tensorFlow.size(0), -1, tensorFlow.size(2), -1)
        tensorVertical = torch.linspace(-1.0, 1.0, tensorFlow.size(2)).view(1, 1, tensorFlow.size(2), 1).expand(tensorFlow.size(0), -1, -1, tensorFlow.size(3))
        if cuda_flag:
            Backward_tensorGrid[str(tensorFlow.size())] = torch.cat([ tensorHorizontal, tensorVertical ], 1).cuda()
        else:
            Backward_tensorGrid[str(tensorFlow.size())] = torch.cat([tensorHorizontal, tensorVertical], 1)
    # end

    tensorFlow = torch.cat([ tensorFlow[:, 0:1, :, :] / ((tensorInput.size(3) - 1.0) / 2.0), tensorFlow[:, 1:2, :, :] / ((tensorInput.size(2) - 1.0) / 2.0) ], 1)

    return torch.nn.functional.grid_sample(input=tensorInput, grid=(Backward_tensorGrid[str(tensorFlow.size())] + tensorFlow).permute(0, 2, 3, 1), mode='bilinear', padding_mode='border')
# end

SpyNet

class SpyNet(torch.nn.Module):
    def __init__(self, cuda_flag):
        super(SpyNet, self).__init__()
        self.cuda_flag = cuda_flag

        class Basic(torch.nn.Module):
            def __init__(self, intLevel):
                super(Basic, self).__init__()

                self.moduleBasic = torch.nn.Sequential(
                    torch.nn.Conv2d(in_channels=8, out_channels=32, kernel_size=7, stride=1, padding=3),
                    torch.nn.ReLU(inplace=False),
                    torch.nn.Conv2d(in_channels=32, out_channels=64, kernel_size=7, stride=1, padding=3),
                    torch.nn.ReLU(inplace=False),
                    torch.nn.Conv2d(in_channels=64, out_channels=32, kernel_size=7, stride=1, padding=3),
                    torch.nn.ReLU(inplace=False),
                    torch.nn.Conv2d(in_channels=32, out_channels=16, kernel_size=7, stride=1, padding=3),
                    torch.nn.ReLU(inplace=False),
                    torch.nn.Conv2d(in_channels=16, out_channels=2, kernel_size=7, stride=1, padding=3)
                )

            # end

            def forward(self, tensorInput):
                return self.moduleBasic(tensorInput)

        self.moduleBasic = torch.nn.ModuleList([Basic(intLevel) for intLevel in range(4)])

        self.load_state_dict(torch.load(SpyNet_model_dir + '/network-' + arguments_strModel + '.pytorch'), strict=False)


    def forward(self, tensorFirst, tensorSecond):
        tensorFirst = [tensorFirst]
        tensorSecond = [tensorSecond]

        for intLevel in range(3):
            if tensorFirst[0].size(2) > 32 or tensorFirst[0].size(3) > 32:
                tensorFirst.insert(0, torch.nn.functional.avg_pool2d(input=tensorFirst[0], kernel_size=2, stride=2))
                tensorSecond.insert(0, torch.nn.functional.avg_pool2d(input=tensorSecond[0], kernel_size=2, stride=2))

        tensorFlow = tensorFirst[0].new_zeros(tensorFirst[0].size(0), 2,
                                              int(math.floor(tensorFirst[0].size(2) / 2.0)),
                                              int(math.floor(tensorFirst[0].size(3) / 2.0)))

        for intLevel in range(len(tensorFirst)):
            tensorUpsampled = torch.nn.functional.interpolate(input=tensorFlow, scale_factor=2, mode='bilinear', align_corners=True) * 2.0

            # if the sizes of upsampling and downsampling are not the same, apply zero-padding.
            if tensorUpsampled.size(2) != tensorFirst[intLevel].size(2):
                tensorUpsampled = torch.nn.functional.pad(input=tensorUpsampled, pad=[0, 0, 0, 1], mode='replicate')
            if tensorUpsampled.size(3) != tensorFirst[intLevel].size(3):
                tensorUpsampled = torch.nn.functional.pad(input=tensorUpsampled, pad=[0, 1, 0, 0], mode='replicate')

            # input ：[first picture of corresponding level,
            # 		   the output of w with input second picture of corresponding level and upsampling flow,
            # 		   upsampling flow]
            # then we obtain the final flow. 最终再加起来得到intLevel的flow
            tensorFlow = self.moduleBasic[intLevel](torch.cat([tensorFirst[intLevel],
                                                               Backward(tensorInput=tensorSecond[intLevel],
                                                                        tensorFlow=tensorUpsampled,
                                                                        cuda_flag=self.cuda_flag),
                                                               tensorUpsampled], 1)) + tensorUpsampled
        return tensorFlow

warp

class warp(torch.nn.Module):
    def __init__(self, h, w, cuda_flag):
        super(warp, self).__init__()
        self.height = h
        self.width = w
        if cuda_flag:
            self.addterm = self.init_addterm().cuda()
        else:
            self.addterm = self.init_addterm()

    def init_addterm(self):
        n = torch.FloatTensor(list(range(self.width)))
        horizontal_term = n.expand((1, 1, self.height, self.width))  # 第一个1是batch size
        n = torch.FloatTensor(list(range(self.height)))
        vertical_term = n.expand((1, 1, self.width, self.height)).permute(0, 1, 3, 2)
        addterm = torch.cat((horizontal_term, vertical_term), dim=1)
        return addterm

    def forward(self, frame, flow):
        """
        :param frame: frame.shape (batch_size=1, n_channels=3, width=256, height=448)
        :param flow: flow.shape (batch_size=1, n_channels=2, width=256, height=448)
        :return: reference_frame: warped frame
        """
        if True:
            flow = flow + self.addterm
        else:
            self.addterm = self.init_addterm()
            flow = flow + self.addterm

        horizontal_flow = flow[0, 0, :, :].expand(1, 1, self.height, self.width)  # 第一个0是batch size
        vertical_flow = flow[0, 1, :, :].expand(1, 1, self.height, self.width)

        horizontal_flow = horizontal_flow * 2 / (self.width - 1) - 1
        vertical_flow = vertical_flow * 2 / (self.height - 1) - 1
        flow = torch.cat((horizontal_flow, vertical_flow), dim=1)
        flow = flow.permute(0, 2, 3, 1)
        reference_frame = torch.nn.functional.grid_sample(frame, flow)
        return reference_frame


class ResNet(torch.nn.Module):
    """
    Three-layers ResNet/ResBlock
    reference: https://blog.youkuaiyun.com/chenyuping333/article/details/82344334
    """
    def __init__(self, task):
        super(ResNet, self).__init__()
        self.task = task
        self.conv_3x2_64_9x9 = torch.nn.Conv2d(in_channels=3 * 2, out_channels=64, kernel_size=9, padding=8 // 2)
        self.conv_3x7_64_9x9 = torch.nn.Conv2d(in_channels=3 * 7, out_channels=64, kernel_size=9, padding=8 // 2)
        self.conv_64_64_9x9 = torch.nn.Conv2d(in_channels=64, out_channels=64, kernel_size=9, padding=8 // 2)
        self.conv_64_64_1x1 = torch.nn.Conv2d(in_channels=64, out_channels=64, kernel_size=1)
        self.conv_64_3_1x1 = torch.nn.Conv2d(in_channels=64, out_channels=3, kernel_size=1)

    def ResBlock(self, x, aver):
        if self.task == 'interp':
            x = torch.nn.functional.relu(self.conv_3x2_64_9x9(x))
            x = torch.nn.functional.relu(self.conv_64_64_1x1(x))
        elif self.task in ['denoise', 'denoising']:
            x = torch.nn.functional.relu(self.conv_3x7_64_9x9(x))
            x = torch.nn.functional.relu(self.conv_64_64_1x1(x))
        elif self.task in ['sr', 'super-resolution']:
            x = torch.nn.functional.relu(self.conv_3x7_64_9x9(x))
            x = torch.nn.functional.relu(self.conv_64_64_9x9(x))
            x = torch.nn.functional.relu(self.conv_64_64_1x1(x))
        else:
            raise NameError('Only support: [interp, denoise/denoising, sr/super-resolution]')
        x = self.conv_64_3_1x1(x) + aver
        return x

    def forward(self, frames):
        aver = frames.mean(dim=1)
        x = frames[:, 0, :, :, :]
        for i in range(1, frames.size(1)):
            x = torch.cat((x, frames[:, i, :, :, :]), dim=1)
        result = self.ResBlock(x, aver)
        return result


class TOFlow(torch.nn.Module):
    def __init__(self, h, w, task, cuda_flag):
        super(TOFlow, self).__init__()
        self.height = h
        self.width = w
        self.task = task
        self.cuda_flag = cuda_flag

        self.SpyNet = SpyNet(cuda_flag=self.cuda_flag)  # SpyNet层
        # for param in self.SpyNet.parameters():  # fix
        #     param.requires_grad = False

        self.warp = warp(self.height, self.width, cuda_flag=self.cuda_flag)

        self.ResNet = ResNet(task=self.task)

    # frames should be TensorFloat
    def forward(self, frames):
        """
        :param frames: [batch_size=1, img_num, n_channels=3, h, w]
        :return:
        """
        for i in range(frames.size(1)):
            frames[:, i, :, :, :] = normalize(frames[:, i, :, :, :])

        if self.cuda_flag:
            opticalflows = torch.zeros(frames.size(0), frames.size(1), 2, frames.size(3), frames.size(4)).cuda()
            warpframes = torch.empty(frames.size(0), frames.size(1), 3, frames.size(3), frames.size(4)).cuda()
        else:
            opticalflows = torch.zeros(frames.size(0), frames.size(1), 2, frames.size(3), frames.size(4))
            warpframes = torch.empty(frames.size(0), frames.size(1), 3, frames.size(3), frames.size(4))

        if self.task == 'interp':
            process_index = [0, 1]
            opticalflows[:, 1, :, :, :] = self.SpyNet(frames[:, 0, :, :, :], frames[:, 1, :, :, :]) / 2
            opticalflows[:, 0, :, :, :] = self.SpyNet(frames[:, 1, :, :, :], frames[:, 0, :, :, :]) / 2
        elif self.task in ['denoise', 'denoising', 'sr', 'super-resolution']:
            process_index = [0, 1, 2, 4, 5, 6]
            for i in process_index:
                opticalflows[:, i, :, :, :] = self.SpyNet(frames[:, 3, :, :, :], frames[:, i, :, :, :])
            warpframes[:, 3, :, :, :] = frames[:, 3, :, :, :]

        else:
            raise NameError('Only support: [interp, denoise/denoising, sr/super-resolution]')

        for i in process_index:
            warpframes[:, i, :, :, :] = self.warp(frames[:, i, :, :, :], opticalflows[:, i, :, :, :])
        # warpframes: [batch_size=1, img_num=7, n_channels=3, height=256, width=448]

        Img = self.ResNet(warpframes)
        # Img: [batch_size=1, n_channels=3, h, w]

        Img = denormalize(Img)

        return Img
torch序列化 pickle 慢
jacke121的专栏
12-23 2905
100张图片 反序列化需要1s，300张需要3s #coding=utf-8 import time import numpy as np import redis import cv2 as cv import pickle import torch pool = redis.ConnectionPool(host='localhost', port=6379, db=0) r = red...
tensorflow permute
_Hope_
09-01 1168
我猜是在找tf.transpose
新版本Pytorch中load_lua失效的解决办法及参数获取
lihengbit的博客
03-10 5563
由于 torch.utils.serialization被从新版Pytorch中移除了，可选的方法是： import torchfile 替代 from torch.utils.serialization import load_lua 同时torchfile.load 替换 load_lua 但是在运行Pytorch0.4.1代码时加载models，这种替换会出现读入格式的错误，例如https:...
基于光流的视频插帧算法 TOFlow 解读教程
qq_39967751的博客
07-01 3772
​ 以TOFlow(Video Enhancement with Task-Oriented Flow) 为例介绍基于光流的视频插帧算法以及其在MMEditing中的实现。
【语义分割】——多层特征的融合
怡宝2号
11-18 4226
转载自：语义分割－多层特征融合 尊重原创，请读原文 语义分割，也称为像素级分类问题，其输出和输入分辨率相同（如题图中，左边为2048x1024分辨率的Cityscapes街景图像，输入模型，得到右边同样分辨率的语义图）。由此，语义分割具有两大需求，即高分辨率和高层语义，而这两个需求和卷积网络设计是矛盾的。 卷积网络从输入到输出，会经过多个下采样层（一般为5个，输出原图1/32的特征图），从而逐步扩大视野获取高层语义特征，高层语义特征靠近输出端但分辨率低，高分率特征靠近输入端但语义层次低。高层特征和底层特征.
ModuleNotFoundError: No module named ‘torch.utils.serialization‘ 的解决方案
weixin_54186372的博客
04-02 2703
ModuleNotFoundError: No module named ‘torch.utils.serialization’ 的解决方案 产生原因：pycharm版本比较新 解决方案：1.换一个版本旧的pycharm 2.1安装torchfile 我们使用清华的镜像 pip install torchfile -i https://pypi.tuna.tsinghua.edu.cn/simple 2.2将from torch.utils.serialization import load_lua改为im
ModuleNotFoundError: No module named ‘torch.utils.serialization‘
Golden-sun的博客
09-15 6188
这是因为在torch新版本中删除了load_lua 解决办法:首先命令行运行pip install torchfile安装torchfile, 然后将utils.py第7行中的from torch.utils.serialization import load_lua改为import torchfile, 最后将utils.py第90行中的load_lua改为torchfile.load ...
ModuleNotFoundError: No module named ‘torch.utils.serialization‘解决
Golden-sun的博客
09-02 3196
安装：torchfile （1）安装torchfile pip install torchfile （2）将from torch.utils.serialization import load_lua改为import torchfile （3）将load_lua改为torchfile.load
2017-SpyNet
qq_45033722的博客
04-01 4230
1. 概述 2. Spatial Pyramid Network 2.1 Spatial Sampling 设d(⋅)d(\cdot)d(⋅)为降采样函数，它将一个m×nm×nm×n图像III抽取到大小为m2×n2\frac{m}{2}×\frac{n}{2}2m​×2n​的相应图像d(I)。设u(⋅)u(\cdot)u(⋅)是对图像进行上采样的反向操作。这些操作符还用于对光流场VVV的水平和垂直分量进行下采样和上采样。我们还定义了一个warping operator w(I，V)w(I，V)w(I，V)，
mean=[0.485, 0.456, 0.406] 、std=[0.229, 0.224, 0.225]
f9547064141的博客
07-08 3701
使用Imagenet的均值和标准差是一种常见的做法。它们是根据数百万张图像计算得出的。如果要在自己的数据集上从头开始训练，则可以计算新的均值和标准差。否则，建议使用Imagenet预设模型及其平均值和标准差。 对于我们特定数据集，如遥感图像或者医学图像不采用该处理方式。 ...
PyTorch中permute的用法详解
09-18
今天小编就为大家分享一篇PyTorch中permute的用法详解，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
RAFT上采样方法笔记
weixin_44762713的博客
02-22 1026
光流估计模型RAFT是在1/8分辨率的图片上以迭代的方式估计光流，根据论文中消融实验的结果，其上采样方法Convex比双线性上采样有一定的提升，因此作此笔记。 raft的上采样方法其实是一种加权相加的方法，代码中的mask其实就是权重，它是使用GRU模块的输出，再通过两层卷积得到的；另外一个很重要的函数就是F.unfold，这个其实就是使用滑动窗口提取特征然后展平的过程，具体地说比如一个张量为[N，C，H，W]，窗口大小设置为KK，忽略步长等细节，其输出就是[N，CKK，HW]，更具体的解释见https:/
SSD网络解析之Permute层
热门推荐
qq_21368481的博客
08-17 1万+
Permute层是SSD（Single Shot MultiBox Detector）中用于置换索引轴顺序的，与matlab中的permute()函数实现类似的功能，首先我们看一下caffe.proto中关于该层参数的说明： optional PermuteParameter permute_param = 202; message PermuteParameter { // The n...
语义分割中多尺度特征的配准问题
soaring_casia的专栏
08-05 2039
1.问题阐述 语义分割的目的是给每一个像素进行正确的分类，这个定义提供了一种从分类视角看待问题的思路，但不能很好的阐述语义分割所面临的关键问题。顾名思义，语义分割是将图像分成若干块，同时获取块的类别，也就是语义信息。这其中有两个关键，一是分割的准确性，保证每个类边缘的准确;二是类别预测的准确性。要准确预测类别，需要利用深层的网络提取语义特征，而随着网络层数的加深，边缘细节不可避免的损失掉了。 很直观的我们可以用边界预测的方式来解决这个问题，也的确有很多论文这么做。但更多的论文是通过融合多尺度特征来保证在
python argparse模块总结
m0_51661400的博客
12-23 254
介绍python argparse模块的简单使用
python argparse.ArgumentParser() 解析模块
小米mm修仙路
08-24 2044
示例：     parser = argparse.ArgumentParser()     parser.add_argument('--resume', type=int, help='resume epoch')     parser.add_argument("--blur", action="store_true")     parser.add_argument("train_set...
pytorch中tensor、backward一些总结
tz的博客
11-21 1618
该文章主要对pytorch中的Tensor一些属性进行说明，并对计算图进行初步了解，且对backward中两个属性gradient与retain_graph进行说明理解
RNN和CNN使用场景区别
最新发布
mayaohao的博客
06-06 1046
RNN（循环神经网络）和 CNN（卷积神经网络）是深度学习中两种核心架构，它们的使用场景主要取决于数据结构和任务需求。
山东大学深度学习2025年期末考试
c335000的博客
06-05 585
1.反向传播2.激活函数3.梯度裁剪4.数据增强5.迁移学习6.过拟合7.word2Vec8.注意力机制。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值