import winnt
from torch.nn import Conv1d
import torch.nn as nn
import torch
"""torch.rand(*sizes, out=None) → Tensor 返回一个张量，包含了从区间[0,1)的均匀分布中抽取的一组随机数，形状由可变参数sizes 定义.
torch.randn(*sizes, out=None) → Tensor 返回一个张量，包含了从标准正态分布(均值为0，方差为 1，即高斯白噪声)中抽取一组随机数，形状由可变参数sizes定义。 参数:"""
x = torch.randn((32,1, 20))
y = torch.nn.Conv1d(1,10,4)(x)
y.shape

torch.Size([32, 10, 17])

class torch.nn.Conv1d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True)

一维卷积层，输入的尺度是(N, C_in,L_in)，输出尺度（ N,C_out,L_out）的计算方式：

N: sample 个数 ,

C_in : 进入网络的channel 数 ,

L_in ：每个channel 的特征个数

out = [ n_sample, out_channels, (20 - 4 + 2 *0 )/ step +1 ]
out = [32, 10, 17] 计算获得上方得到的size

更为详细的解答:----------------------------------------------------------
in = [n_sample = 31, c_in = 1, L_in = 20]
L_out = (L_in - kernel_size + 2*padding ) / stride  + 1

Conv1d 的计算方式 ： L_out = floor( {L_in - dialation(kernel_size -1 )-1 + 2*padding} / stride  +1)  floor 向下取整
若令  ： new_kernelsize=dilation∗(kernelsize−1)+1
则：  L_out = (L - new_kernelsize + 2*padding ) / stride  + 1
而这个dilation 默认 =1 , 此时 new_kernelsize = kernel_size 未变    若设置为其他,则变成了空洞卷积
如果我们把dilation设置成2，其实也就是在两两卷积点中插入一个空白，使得4*4的卷积核，变为了7 * 7:

见下方代码

参数：

in_channels(int) – 输入信号的通道

out_channels(int) – 卷积产生的通道

kerner_size(int or tuple) – 卷积核的尺寸

stride(int or tuple, optional) – 卷积步长

padding (int or tuple, optional)- 输入的每一条边补充0的层数

dilation(int or tuple, `optional“) – 卷积核元素之间的间距

groups(int, optional) – 从输入通道到输出通道的阻塞连接数

bias(bool, optional) – 如果bias=True，添加偏置

y1 = torch.nn.Conv1d(1,10,4,dilation=2)(x)
y2 = torch.nn.Conv1d(1,10,7,dilation=1)(x)
y1.shape , y2.shape

(torch.Size([32, 10, 14]), torch.Size([32, 10, 14]))

"""查看conv1d 保存的参数shape"""
class Model3(nn.Module):
    def __init__(self):
        super(Model3, self).__init__()
        self.conv1 = nn.Conv2d(1, 20 ,5,padding='same')
        self.add_module("conv2", nn.Conv2d(20,64,5, padding= 'same'))
        self.relu = nn.ReLU()

    def forward(self,x):
        x = self.relu(self.conv1(x))
        x = self.relu(self.conv2(x))

model = Model3()
model.state_dict().keys(),[param.shape for param in model.parameters()]

(odict_keys(['conv1.weight', 'conv1.bias', 'conv2.weight', 'conv2.bias']),
 [torch.Size([20, 1, 5, 5]),
  torch.Size([20]),
  torch.Size([64, 20, 5, 5]),
  torch.Size([64])])

class torch.nn.ConvTranspose1d(in_channels, out_channels, kernel_size, stride=1, padding=0, output_padding=0, groups=1, bias=True)

参数

1维的解卷积操作（transposed convolution operator，注意改视作操作可视作解卷积操作，但并不是真正的解卷积操作)

该模块可以看作是Conv1d相对于其输入的梯度，有时（但不正确地）被称为解卷积操作。

可以视为一个求近似逆映射的过程

由于内核的大小，输入的最后的一些列的数据可能会丢失。因为输入和输出是 非完全的互相关。因此，用户可以进行适当的填充（padding操作).

x = torch.randn((32,1, 20))
y1 = torch.nn.Conv1d(1,10,4,dilation=1)(x)
re_x = torch.nn.ConvTranspose1d(10,1,4)(y1)
y1.shape , re_x.shape , x.shape, x[1],re_x[1]

(torch.Size([32, 10, 17]),
 torch.Size([32, 1, 20]),
 torch.Size([32, 1, 20]),
 tensor([[ 0.0698,  2.0271, -1.0443,  0.9315,  0.1222, -0.1993,  0.0328, -2.2057,
           0.1258,  0.6767, -1.6506,  0.4317,  0.8273, -0.2652,  0.6150,  0.5171,
          -0.6493, -0.1054, -0.0118,  0.1087]]),
 tensor([[-0.5308,  1.5538,  0.1205,  1.6790, -0.1221,  2.6355,  0.0653,  1.4681,
           1.2753, -1.6583,  1.7006,  0.7527, -1.5624,  1.4852,  1.1013, -0.0268,
           1.2792,  0.2737, -0.8311, -0.2432]], grad_fn=<SelectBackward0>))

class torch.nn.BatchNorm1d(num_features, eps=1e-05, momentum=0.1, affine=True) [source]

对小批量(mini-batch)的2d或3d输入进行批标准化(Batch Normalization)操作

y= {x−mean[x] / sqrt(var(x))+ ϵ}∗  gamma+beta

在每一个小批量（mini-batch）数据中，计算输入各个维度的均值和标准差。gamma与beta是可学习的大小为C的参数向量（C为输入大小
在训练时，该层计算每次输入的均值与方差，并进行移动平均。移动平均默认的动量值为0.1。
在验证时，训练求得的均值/方差将用于标准化验证数据。
参数：
num_features： 来自期望输入的特征数，该期望输入的大小为'batch_size x num_features [x width]'
eps ϵ ： 为保证数值稳定性（分母不能趋近或取0）,给分母加上的值。默认为1e-5。
momentum： 动态均值和动态方差所使用的动量。默认为0.1。
affine： 一个布尔值，当设为true，给该层添加可学习的仿射变换参数。
Shape： - 输入：（N, C）或者(N, C, L) - 输出：（N, C）或者（N，C，L）（输入输出相同)