MWCNN中使用的haar小波变换 pytorch

最新推荐文章于 2024-04-22 08:55:21 发布
最新推荐文章于 2024-04-22 08:55:21 发布
阅读量881 收藏 3
点赞数
文章标签： pytorch 人工智能 python
原文链接：https://www.cnblogs.com/wanghui-garcia/p/12524515.html
版权

1.原理

小波变换的计算方法：

1）一维信号：

例如：有a=[5,7,6,8]四个数，并使用b[4]数组来保存结果.

        则一级Haar小波变换的结果为:

        b[0]=(a[0]+a[1])/2,                       b[2]=(a[0]-a[1])/2

        b[1]=(a[2]+a[3])/2,                       b[3]=(a[2]-a[3])/2

⚠️计算差均值时也有看见a[1]-a[0]的，只要保持一致应该都可以

由此可知，Haar变换采用的原理是：

A）低频采用和均值，即b[0]和b[1]，和均值中均值存储了图像的整体信息

B）高频采用差均值，即b[2]和b[3]，用于记录图像的细节信息，这样在重构时能够恢复图像的全部信息

 因此上面的例子中

b[0] = (5+7)/2 = 6 , b[1] = (6+8)/2 = 6, b[2] = (5-7)/2 = -1, b[3] = (6-8)/2 = -1 

如果要继续进行多级的小波变换：

  如上图可见是对低频的信息继续进行haar小波变换

2）二维

对于二维haar小波，我们通常一次分解形成了整体图像，水平细节，垂直细节，对角细节。首先我们按照一维haar小波分解的原理，按照行顺序对行进行处理，然后按照列顺序对行处理结果进行同样的处理

用图像表述如图所示：图中a表示原图，图b表示经过一级小波变换的结果，h1 表示水平反向的细节，v1 表示竖直方向的细节，c1表示对角线方向的细节，b表示下2采样的图像。图c中表示继续进行了三次Haar小波变换的结果：

详细过程经过下面的代码来解释

2.实现

1）

代码：https://github.com/lpj0/MWCNN_PyTorch/blob/master/model/common.py：

原图为：

中间有个问题，就是逆向重构的时候发现并没有成功，得到的结果是：

于是对操作的数据进行了一番输出：

复制代码

#coding:utf-8
import torch.nn as nn
import torch

def dwt_init(x):
    print('-------------- origin ---------------')
    print(x[:,0,:,:])
    x01 = x[:, :, 0::2, :] / 2
    x02 = x[:, :, 1::2, :] / 2
    x1 = x01[:, :, :, 0::2]
    x2 = x02[:, :, :, 0::2]
    x3 = x01[:, :, :, 1::2]
    x4 = x02[:, :, :, 1::2]
    x_LL = x1 + x2 + x3 + x4
    x_HL = -x1 - x2 + x3 + x4
    x_LH = -x1 + x2 - x3 + x4
    x_HH = x1 - x2 - x3 + x4
    print('---------------- LL ------------------')
    print(x_LL[:,0,:,:])
    print()
    print('---------------- HL ------------------')
    print(x_HL[:,0,:,:])
    print()
    print('---------------- LH ------------------')
    print(x_LH[:,0,:,:])
    print()
    print('---------------- HH ------------------')
    print(x_HH[:,0,:,:])
    return torch.cat((x_LL, x_HL, x_LH, x_HH), 1)


# 使用哈尔 haar 小波变换来实现二维逆向离散小波
def iwt_init(x):
    r = 2
    in_batch, in_channel, in_height, in_width = x.size()
    # print([in_batch, in_channel, in_height, in_width]) #[1, 12, 56, 56]
    out_batch, out_channel, out_height, out_width = in_batch, int(in_channel / (r**2)), r * in_height, r * in_width
    # print(out_batch, out_channel, out_height, out_width) #1 3 112 112
    x1 = x[:, 0:out_channel, :, :] / 2
    print('-------------- enter iwt ---------------')
    print(x1[:,0,:,:])
    x2 = x[:, out_channel:out_channel * 2, :, :] / 2
    x3 = x[:, out_channel * 2:out_channel * 3, :, :] / 2
    x4 = x[:, out_channel * 3:out_channel * 4, :, :] / 2
    # print(x1.shape) #torch.Size([1, 3, 56, 56])
    # print(x2.shape) #torch.Size([1, 3, 56, 56])
    # print(x3.shape) #torch.Size([1, 3, 56, 56])
    # print(x4.shape) #torch.Size([1, 3, 56, 56])
    # h = torch.zeros([out_batch, out_channel, out_height, out_width]).float().cuda()
    h = torch.zeros([out_batch, out_channel, out_height, out_width]).float()

    h[:, :, 0::2, 0::2] = x1 - x2 - x3 + x4
    h[:, :, 1::2, 0::2] = x1 - x2 + x3 - x4
    h[:, :, 0::2, 1::2] = x1 + x2 - x3 - x4
    h[:, :, 1::2, 1::2] = x1 + x2 + x3 + x4
    print('-------------- back ---------------')
    print(h[:,0,:,:])
    return h


# 二维离散小波
class DWT(nn.Module):
    def __init__(self):
        super(DWT, self).__init__()
        self.requires_grad = False  # 信号处理，非卷积运算，不需要进行梯度求导

    def forward(self, x):
        return dwt_init(x)


# 逆向二维离散小波
class IWT(nn.Module):
    def __init__(self):
        super(IWT, self).__init__()
        self.requires_grad = False

    def forward(self, x):
        return iwt_init(x)

if __name__ == '__main__':
    import os, cv2, torchvision
    from PIL import Image
    import numpy as np
    from torchvision import transforms as trans

    img = Image.open('./1.jpg')
    transform = trans.Compose([
        trans.ToTensor()
    ])
    img = transform(img).unsqueeze(0)
    dwt = DWT()
    change_img_tensor = dwt(img)
    # print(change_img_tensor.shape) #torch.Size([1, 12, 56, 56])
    print('-------------- after dwt ---------------')
    print(change_img_tensor[:,0,:,:])

    for i in range(change_img_tensor.size(1)//3):
        torchvision.utils.save_image(change_img_tensor[:,i*3:i*3+3:,:], os.path.join('./', 'change_{}.jpg'.format(i)))
         
    iwt = IWT()
    back_img_tensor = iwt(change_img_tensor)
    print(back_img_tensor.shape)

    torchvision.utils.save_image(back_img_tensor, 'back.jpg')

复制代码

返回：

复制代码

(deeplearning) bogon:learning user$ python delete.py 
-------------- origin ---------------
tensor([[[0.9020, 0.9882, 0.9216,  ..., 0.7176, 0.7843, 0.8431],
         [0.8941, 0.9608, 0.9255,  ..., 0.7490, 0.7569, 0.7490],
         [0.8980, 0.9333, 0.8863,  ..., 0.6941, 0.7333, 0.7608],
         ...,
         [0.1373, 0.1373, 0.1451,  ..., 0.9529, 0.9686, 0.9804],
         [0.1451, 0.1451, 0.1490,  ..., 0.9294, 0.9373, 0.9569],
         [0.1373, 0.1412, 0.1451,  ..., 0.9137, 0.9020, 0.9176]]])
---------------- LL ------------------
tensor([[[1.8725, 1.8569, 1.9314,  ..., 1.4176, 1.4510, 1.5667],
         [1.8294, 1.7588, 1.5118,  ..., 1.4490, 1.4314, 1.5137],
         [1.9039, 1.6059, 1.0412,  ..., 1.2765, 1.4588, 1.5039],
         ...,
         [0.3078, 0.3216, 0.3490,  ..., 1.8784, 1.8333, 1.7627],
         [0.2647, 0.3059, 0.3784,  ..., 1.7510, 1.8725, 1.9137],
         [0.2843, 0.3020, 0.3922,  ..., 1.8941, 1.8549, 1.8569]]])

---------------- HL ------------------
tensor([[[ 0.0765,  0.0098,  0.0059,  ...,  0.0098,  0.0157,  0.0255],
         [ 0.0294, -0.0294, -0.0922,  ..., -0.0098,  0.0078,  0.0235],
         [-0.0412, -0.1588, -0.0725,  ...,  0.0569,  0.0314, -0.0059],
         ...,
         [-0.0137,  0.0196,  0.0039,  ...,  0.0275, -0.0412,  0.0098],
         [-0.0020,  0.0196,  0.0176,  ...,  0.0216,  0.0216,  0.0039],
         [ 0.0020,  0.0078,  0.0314,  ...,  0.0039, -0.0118,  0.0176]]])

---------------- LH ------------------
tensor([[[-0.0176,  0.0098, -0.0176,  ..., -0.0137,  0.0392, -0.0608],
         [-0.0020, -0.0098, -0.1510,  ...,  0.1078,  0.0745,  0.0196],
         [ 0.0176, -0.1392, -0.0882,  ..., -0.0059,  0.0588,  0.0725],
         ...,
         [-0.0255, -0.0078,  0.0118,  ..., -0.0431,  0.0216, -0.0098],
         [ 0.0098,  0.0000,  0.0020,  ...,  0.0020, -0.0020,  0.0353],
         [-0.0059, -0.0039,  0.0039,  ...,  0.0549,  0.0039, -0.0373]]])

---------------- HH ------------------
tensor([[[-0.0098,  0.0059, -0.0216,  ...,  0.0216, -0.0078, -0.0333],
         [-0.0059, -0.0255, -0.0294,  ...,  0.0137, -0.0235, -0.0039],
         [-0.0373, -0.0373,  0.0608,  ..., -0.0020,  0.0196, -0.0098],
         ...,
         [ 0.0059,  0.0039,  0.0039,  ...,  0.0118,  0.0137, -0.0137],
         [ 0.0020, -0.0039,  0.0020,  ..., -0.0098,  0.0137,  0.0078],
         [ 0.0020,  0.0000,  0.0039,  ...,  0.0000, -0.0196, -0.0020]]])
-------------- after dwt ---------------
tensor([[[1.8725, 1.8569, 1.9314,  ..., 1.4176, 1.4510, 1.5667],
         [1.8294, 1.7588, 1.5118,  ..., 1.4490, 1.4314, 1.5137],
         [1.9039, 1.6059, 1.0412,  ..., 1.2765, 1.4588, 1.5039],
         ...,
         [0.3078, 0.3216, 0.3490,  ..., 1.8784, 1.8333, 1.7627],
         [0.2647, 0.3059, 0.3784,  ..., 1.7510, 1.8725, 1.9137],
         [0.2843, 0.3020, 0.3922,  ..., 1.8941, 1.8549, 1.8569]]])
-------------- enter iwt ---------------
tensor([[[127.5000, 127.5000, 127.5000,  ..., 127.5000, 127.5000, 127.5000],
         [127.5000, 127.5000, 127.5000,  ..., 127.5000, 127.5000, 127.5000],
         [127.5000, 127.5000, 127.5000,  ..., 127.5000, 127.5000, 127.5000],
         ...,
         [ 39.5000,  41.2500,  44.7500,  ..., 127.5000, 127.5000, 127.5000],
         [ 34.0000,  39.2500,  48.5000,  ..., 127.5000, 127.5000, 127.5000],
         [ 36.5000,  38.7500,  50.2500,  ..., 127.5000, 127.5000, 127.5000]]])
-------------- back ---------------
tensor([[[117.5000, 137.5000, 125.5000,  ..., 124.5000, 124.0000, 131.0000],
         [117.5000, 137.5000, 126.5000,  ..., 135.0000, 124.0000, 131.0000],
         [123.5000, 131.5000, 127.5000,  ..., 119.0000, 121.5000, 128.0000],
         ...,
         [ 35.0000,  36.0000,  36.7500,  ..., 132.5000, 130.2500, 134.2500],
         [ 36.5000,  36.5000,  37.7500,  ..., 126.7500, 125.0000, 130.0000],
         [ 35.5000,  37.5000,  37.2500,  ..., 128.2500, 125.0000, 130.0000]]])
torch.Size([1, 3, 112, 112])

复制代码

发现输入iwt的结果变化了，突然想起来torchvision.utils.save_image函数是会对数据进行处理的

解决办法就是调整下顺序即可

重新运行一遍：

复制代码

#coding:utf-8
import torch.nn as nn
import torch

def dwt_init(x):
    x01 = x[:, :, 0::2, :] / 2
    x02 = x[:, :, 1::2, :] / 2
    x1 = x01[:, :, :, 0::2]
    x2 = x02[:, :, :, 0::2]
    x3 = x01[:, :, :, 1::2]
    x4 = x02[:, :, :, 1::2]
    x_LL = x1 + x2 + x3 + x4
    x_HL = -x1 - x2 + x3 + x4
    x_LH = -x1 + x2 - x3 + x4
    x_HH = x1 - x2 - x3 + x4

    return torch.cat((x_LL, x_HL, x_LH, x_HH), 1)


# 使用哈尔 haar 小波变换来实现二维逆向离散小波
def iwt_init(x):
    r = 2
    in_batch, in_channel, in_height, in_width = x.size()
    # print([in_batch, in_channel, in_height, in_width]) #[1, 12, 56, 56]
    out_batch, out_channel, out_height, out_width = in_batch, int(in_channel / (r**2)), r * in_height, r * in_width
    # print(out_batch, out_channel, out_height, out_width) #1 3 112 112
    x1 = x[:, 0:out_channel, :, :] / 2
    x2 = x[:, out_channel:out_channel * 2, :, :] / 2
    x3 = x[:, out_channel * 2:out_channel * 3, :, :] / 2
    x4 = x[:, out_channel * 3:out_channel * 4, :, :] / 2
    # print(x1.shape) #torch.Size([1, 3, 56, 56])
    # print(x2.shape) #torch.Size([1, 3, 56, 56])
    # print(x3.shape) #torch.Size([1, 3, 56, 56])
    # print(x4.shape) #torch.Size([1, 3, 56, 56])
    # h = torch.zeros([out_batch, out_channel, out_height, out_width]).float().cuda()
    h = torch.zeros([out_batch, out_channel, out_height, out_width]).float()

    h[:, :, 0::2, 0::2] = x1 - x2 - x3 + x4
    h[:, :, 1::2, 0::2] = x1 - x2 + x3 - x4
    h[:, :, 0::2, 1::2] = x1 + x2 - x3 - x4
    h[:, :, 1::2, 1::2] = x1 + x2 + x3 + x4
    return h


# 二维离散小波
class DWT(nn.Module):
    def __init__(self):
        super(DWT, self).__init__()
        self.requires_grad = False  # 信号处理，非卷积运算，不需要进行梯度求导

    def forward(self, x):
        return dwt_init(x)


# 逆向二维离散小波
class IWT(nn.Module):
    def __init__(self):
        super(IWT, self).__init__()
        self.requires_grad = False

    def forward(self, x):
        return iwt_init(x)

if __name__ == '__main__':
    import os, cv2, torchvision
    from PIL import Image
    import numpy as np
    from torchvision import transforms as trans
    # img = cv2.imread('./1.jpg')
    # print(img.shape)
    # img = Image.fromarray(img.astype(np.uint8))
    img = Image.open('./1.jpg')
    transform = trans.Compose([
        trans.ToTensor()
    ])
    img = transform(img).unsqueeze(0)
    dwt = DWT()
    change_img_tensor = dwt(img)
    iwt = IWT()
    back_img_tensor = iwt(change_img_tensor)
    print(back_img_tensor.shape)
    # print(change_img_tensor.shape) #torch.Size([1, 12, 56, 56])
    
    
    #合并成一张4格的图
    h = torch.zeros([4,3,change_img_tensor.size(2),change_img_tensor.size(2)]).float()

    
    for i in range(change_img_tensor.size(1)//3):
        h[i,:,:,:] = change_img_tensor[:,i*3:i*3+3:,:]
        #分别保存为一个图片
        torchvision.utils.save_image(change_img_tensor[:,i*3:i*3+3:,:], os.path.join('./', 'change_{}.jpg'.format(i)))
    
            
    change_img_grid = torchvision.utils.make_grid(h, 2) #一行2张图片    
    torchvision.utils.save_image(change_img_grid, 'change_img_grid.jpg')

    torchvision.utils.save_image(back_img_tensor, 'back.jpg')

复制代码

小波变换后的结果为：

重构的图为：

2）对代码进行解释

1》dwt

复制代码

def dwt_init(x):
    x01 = x[:, :, 0::2, :] / 2
    x02 = x[:, :, 1::2, :] / 2
    x1 = x01[:, :, :, 0::2]
    x2 = x02[:, :, :, 0::2]
    x3 = x01[:, :, :, 1::2]
    x4 = x02[:, :, :, 1::2]
    x_LL = x1 + x2 + x3 + x4
    x_HL = -x1 - x2 + x3 + x4
    x_LH = -x1 + x2 - x3 + x4
    x_HH = x1 - x2 - x3 + x4

    return torch.cat((x_LL, x_HL, x_LH, x_HH), 1)

复制代码

首先：

    x01 = x[:, :, 0::2, :] / 2
    x02 = x[:, :, 1::2, :] / 2

将矩阵分为偶数行和奇数行，并将所有值都除以2，这样后面只要进行求和和求差即可，因为已经求均值了

然后下面的：

    x1 = x01[:, :, :, 0::2]
    x2 = x02[:, :, :, 0::2]
    x3 = x01[:, :, :, 1::2]
    x4 = x02[:, :, :, 1::2]

就是分为偶数列和奇数列，假设矩阵为6*6大小，那么就将该矩阵分成了4个3*3大小的x1、x2、x3和x4，如下图所示:

那么接下来在进行的计算就是进行行、列的和、差变换了：

    x_LL = x1 + x2 + x3 + x4
    x_HL = -x1 - x2 + x3 + x4
    x_LH = -x1 + x2 - x3 + x4
    x_HH = x1 - x2 - x3 + x4

再用一张图说明：

2》iwt

复制代码

def iwt_init(x):
    r = 2
    in_batch, in_channel, in_height, in_width = x.size()
    # print([in_batch, in_channel, in_height, in_width]) #[1, 12, 56, 56]
    out_batch, out_channel, out_height, out_width = in_batch, int(in_channel / (r**2)), r * in_height, r * in_width
    # print(out_batch, out_channel, out_height, out_width) #1 3 112 112
    x1 = x[:, 0:out_channel, :, :] / 2
    x2 = x[:, out_channel:out_channel * 2, :, :] / 2
    x3 = x[:, out_channel * 2:out_channel * 3, :, :] / 2
    x4 = x[:, out_channel * 3:out_channel * 4, :, :] / 2
    # print(x1.shape) #torch.Size([1, 3, 56, 56])
    # print(x2.shape) #torch.Size([1, 3, 56, 56])
    # print(x3.shape) #torch.Size([1, 3, 56, 56])
    # print(x4.shape) #torch.Size([1, 3, 56, 56])
    # h = torch.zeros([out_batch, out_channel, out_height, out_width]).float().cuda()
    h = torch.zeros([out_batch, out_channel, out_height, out_width]).float()

    h[:, :, 0::2, 0::2] = x1 - x2 - x3 + x4
    h[:, :, 1::2, 0::2] = x1 - x2 + x3 - x4
    h[:, :, 0::2, 1::2] = x1 + x2 - x3 - x4
    h[:, :, 1::2, 1::2] = x1 + x2 + x3 + x4
    return h

复制代码

在这里的行x1=x_LL/2,  x2=x_HL/2,  x3=x_LH/2,  x4=x_HH/2

所以我们想重构，其实就是从这些值中恢复dwt中的x1,x2,x3,x4,分别放到h对应的位置变为原来的矩阵，如x1对应的是h[:, :, 0::2, 0::2]，如下图所示：

这就是重构的方法

过程中遇到的一点问题pytorch图像处理的问题

c2a2o2
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
MWCNN_PyTorch-master_pytorch去噪_MWCNN_MWCNN图片去噪程序_
09-29
这是MWCNN图片去噪程序，PyTorch运行，有价值！
深度学习与PyTorch-代码与PPT（全）.zip
05-13
pytorch入门与实战所有的代码及课件，环境搭建到实战，包含RNN,LSTM GAN等多个章节内容
Python|【Pytorch】基于小波时频图与SwinTransformer的轴承故障诊断研究
weixin_46039719的博客
03-20 747
小波时频图是一种将时间和频率信息结合起来的图像表示方法，它可以有效地捕捉信号的时频特征，从而提高故障诊断的准确性和可靠性。该模型使用了一种全新的Swin结构，它采用了分层的注意力机制和局部注意力机制，以实现高效的信息交互和全局视野。这种新的方法具有许多优点。最后，它可以适应不同类型的轴承故障，并能够自动学习和优化模型，从而实现更加智能和自适应的故障诊断。Swintransformer与小波时频图相结合，是一种非常新颖和创新的方法，可以为轴承故障诊断带来更加准确、可靠、高效和智能的解决方案。
哈尔小波变换实例讲解
热门推荐
Belial计算机视觉&机器视觉专栏
07-27 1万+
1.哈尔基函数        最简单的基函数是哈尔基函数(Haar basis function)。哈尔基函数在1909年提出，它是由一组分段常值函数组成的函数集。这个函数集定义在半开区间[0,1)上，每一个分段常值函数的数值在一个小范围里是1，其他地方为0，现以图像为例并使用线性代数中的矢量空间来说明哈尔基函数。        如果一幅图像仅由2^0=1个像素组成，这幅图像在整个[0,1)
Haar wavelet transform
OnePlus+博客
12-02 445
Haar Wavelet transform
【图像重建】基于matlab小波变换图像分解重建（PSNR对比）【含Matlab源码 2686期】
订阅付费专栏（初级版），可赠送该付费专栏任意代码1份；
06-11 1139
小波变换图像分解重建（PSNR对比） 完整代码，直接运行，适合小白！可提供运行操作视频！
MWCNN:多小波卷积神经网络研究
04-16
世界移动通信网络 多小波卷积神经网络研究 环境： conda创建--name dwtcnn python = 3.6 conda激活dwtcnn conda安装scipy == 1.5.2 conda安装matplotlib == 3.3.4 conda安装tensorflow == 1.15.0 conda安装keras == 2.3.1
了解DWT就看这篇——MWCNN
qq_45981086的博客
07-03 1977
提出了一种用于图像恢复的多层小波cnn(MWCNN)结构，该结构由收缩子网络和扩展子网络组成。收缩子网由多级 D WT 和 C NN 块组成，扩展子网由多级IWT和CNN 块组 成。由于 D WT 的可逆性、频率性和位置性，MWCNN可以安全地进行子采样而不丢失信息，并且可以有效地从退化的观测中恢复细节纹理和尖锐结构。结果表明， MWCNN可以在效率和性能之间取得更好的平衡，从而扩大接收域。大量的实验证明了MWCNN在图像去噪、SISR 和JPEG压缩、伪影去除、恢复三个任务上的有效性和效率。
【2DWT：2维离散小波变换（附Pytorch代码）】
NorthSmile的博客
10-05 1万+
图像信号具有非平稳特性，无法使用一种确定的数学模型来描述，而小波变换的多分辨率分析特性很好地解决了这个问题。小波变化的多分辨率特性使其既可以高效描述图像的平坦区域（低频信息、全局信息），也可以有效处理图像信号的局部突变（高频信息，即图像的边缘轮廓等部分）。小波变换在空域和频域同时具有良好的局部性，使其可以很好地聚焦到图像的任意细节。
chatgpt赋能python：Python小波变换——数据分析和信号处理方向的常见工具
m0_56069948的博客
05-27 569
小波变换是一种用于信号处理和数据分析的技术，它是一种基于小波函数的变换。小波函数通常是以多分辨率方式表示，即在一定范围内可以对数据的各个尺度进行描述。通过小波变换，我们可以将原始信号分解成不同的频率分量，从而更好地理解和分析信号的特性。小波变换的基本原理是将原始信号与小波函数进行卷积，然后通过不同的尺度来调整小波函数的大小。这样，就可以分解出不同尺度的信号分量并进行分析。经过小波变换后，我们可以得到小波系数，它们的幅度和相位信息可以用于进一步分析和处理。本文由chatgpt生成，文章没有在chatgpt。
读《Multi-level Wavelet-CNN for Image Restoration》
NorthSmile的博客
03-23 978
Multi-level Wavelet-CNN for Image Restoration阅读笔记
HaarWavelets:一维和二维Haar小波的简单实现
07-02
Haar小波变换 这是一维和二维 Haar 小波变换的简单实现。 对于每个转换，输入是一维或二维双精度数组，输出是一维或二维双精度数组。 用法 一维Haar小波变换 让我们以下面的例子为例。 我们有一个一维数组。 double [] data = { 9 , 7 , 3 , 5 }; 我们实例化一个类来转换矩阵： HaarWavelet1D oneD = new HaarWavelet1D (data); oneD . standardDecomposition(); 结果是： Processing One Dimensional Haar Wavelet Transformation Input : 9.0, 7.0, 3.0, 5.0 Output : 6.0, 2.0, 1.0, -1.0 二维哈尔小波变换 让我们看下面的例子：我们有一个二维数组。 double
Haar小波变换矩阵实现：创建Haar小波变换矩阵-matlab开发
06-01
为矩阵向量创建 Haar 小波变换矩阵 H Haar小波变换的乘法实现。 此函数使用以下漂亮的公式来创建 Haar 变换矩阵： H_n=1/sqrt(2)[H_(n/2) 克朗 (1 1) I_(n/2) 克朗 (1 -1)], 其中“kron”表示克罗内克积。 迭代从 H_...
haar小波变换
03-16
使用haar小波变换对图像进行处理，变换源代码，不是函数。对图像进行小波行变换
matlab实现Haar小波变换，优秀大作业，小白必看！
04-23
matlab实现Haar小波变换，优秀大作业，小白必看！ matlab实现Haar小波变换，优秀大作业，小白必看！ matlab实现Haar小波变换，优秀大作业，小白必看！ matlab实现Haar小波变换，优秀大作业，小白必看！ matlab实现...
基于LFM信号的Haar小波变换
06-29
Haar小波变换的基本思想：找到另一个基函数，通过压缩平移也生成差空间，这个基函数和原来的尺度函数能够建立直接的联系。优点是时域紧支撑的，正交对称的，而且计算简单。但是在时域上是不连续的，所以作为基本小波...
使用 HAAR 小波变换的人脸识别-研究论文
06-10
Haar 小波变换主要用于图像处理和模式识别，因为它具有较低的计算要求和质量，可以保存和压缩信号的能量。 在离散小波变换中，可以通过使图像信号通过分析滤波器组然后进行抽取操作来分析图像信号。 在相关系数、...
pytorch-过拟合&欠拟合
最新发布
wyw0000的博客
04-22 216
pytorch-过拟合和欠拟合
【pytorch】内容链接汇总
sazass的博客
04-21 565
所有pytorch相关文章链接
小波变换 pytorch
07-16
### 回答1： 小波变换（Wavelet Transform）是一种时间-频率分析方法，利用多个小波函数来将连续信号分解成不同频率的子信号，且在时域和频域都具有局部性质。 在PyTorch中，可以使用PyWavelets库实现小波变换。首先，我们需要导入PyWavelets库，并准备好待处理的信号数据。然后，可以选择合适的小波基函数和相关参数，如变换级别和边界处理方式。接下来，可以利用PyWavelets库的函数对信号进行小波变换，得到分解后的系数数组。最后，可以根据需要对系数数组进行处理，如阈值去噪或重建原始信号。 以下是一个简单的示例代码： ```python import pywt import numpy as np # 准备信号数据 signal = np.random.rand(100) # 定义小波基函数和参数 wavelet = 'haar' level = 3 # 小波变换 coeffs = pywt.wavedec(signal, wavelet, level=level) # 对系数数组进行处理 # ... # 重构信号 reconstructed_signal = pywt.waverec(coeffs, wavelet) ``` 需要注意的是，PyWavelets库提供了丰富的小波基函数和工具函数，可以根据具体需求选择合适的函数进行使用。同时，根据信号的特点，可以调整小波变换的参数以达到更好的效果。 总体来说，PyTorch结合PyWavelets库能够方便地实现小波变换，对信号的频率-时间分析和特征提取具有很好的效果。当然，实际应用中还需要根据具体问题进行调参和处理，以获得更好的结果。 ### 回答2： 小波变换是一种信号处理技术，可以将信号分解成一系列不同频率的子信号，并在不同时间尺度上进行分析。PyTorch是一个开源的深度学习框架，可以用于构建神经网络模型。在PyTorch中，我们可以使用它的信号处理库torchwave来实现小波变换。 首先，我们需要安装torchwave库。可以通过pip命令来安装，如：pip install torchwave。 然后，我们可以导入torchwave库，并使用它的wavelet包来实现小波变换。首先，我们需要定义一个输入信号。可以使用torch.Tensor类型来表示信号，如：signal = torch.Tensor([1,2,3,4,5])。 接下来，我们可以选择一个小波函数进行变换。torchwave库提供了多种小波函数的选择，如haar、db、bior等。我们可以使用wavelet包的家族函数来选择小波函数，如：wavelet.haar()。 然后，我们可以使用小波变换函数wavelet_transform()来对信号进行变换。需要指定信号、小波函数和层数等参数。如：transformed_signal = wavelet.wavelet_transform(signal, wavelet.haar(), level = 2)。 最后，我们可以通过查看变换后的系数来分析信号。可以使用小波系数函数wavelet_coefficients()来获取变换后的系数。如：coefficients = wavelet.wavelet_coefficients(transformed_signal)。 通过分析变换后的系数，我们可以获取信号的不同频率和时间尺度的信息。这对于信号处理和特征提取等应用非常有用。 总之，可以使用PyTorch的信号处理库torchwave来实现小波变换。通过定义输入信号、选择小波函数以及使用相应的小波变换函数，我们可以得到变换后的系数，从而分析信号的频率和时间尺度信息。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值