在 Feed_Forward 类中，每一步的数据维度变化如下：

输入：

输入张量 x 的形状为 [batch_size, seq_len, d_model]。
在 forward 方法的开始，这个形状被打印出来：([64, 125, 128])。
扩展维度：

x.unsqueeze(1) 增加一个通道维度，使得输入形状变为 [batch_size, 1, seq_len, d_model]。
经过 x.unsqueeze(1) 后，形状为 ([64, 1, 125, 128])。
卷积层：

self.conv1 是一个卷积层，它的输入形状是 [batch_size, 1, seq_len, d_model]。
self.conv1 的参数是 nn.Conv2d(1, 16, (15, 16), bias=False, stride=(15, 16))，意味着卷积核大小为 (15, 16)，步幅为 (15, 16)，输出通道数为 16。
卷积运算后，形状变为 ([64, 16, 8, 8])。
在 self.gelu(self.conv1(x.unsqueeze(1))) 之后，输出形状为 ([64, 16, 8, 8])。
激活函数：

self.gelu 是一个激活函数，不改变形状。
在 output = self.gelu(self.conv1(x.unsqueeze(1))) 之后，输出形状仍为 ([64, 16, 8, 8])。
Dropout：

self.dropout 是一个 Dropout 层，也不改变形状。
在 output = self.dropout(output) 之后，输出形状仍为 ([64, 16, 8, 8])。
展平：

output.contiguous().view(-1, self.num_flat_features(output)) 将输出展平成二维张量。
self.num_flat_features(output) 计算除了批次维度外的所有维度的乘积，即 16 * 8 * 8 = 1024。
output.contiguous().view(-1, 1024) 将输出形状展平为 [batch_size, 1024]。
最终输出形状为 ([64, 1024])。
修改后的完整代码如下：

python
复制代码
class Feed_Forward(nn.Module):
    def __init__(self, device):
        super(Feed_Forward, self).__init__()
        F1 = 16
        self.conv1 = nn.Conv2d(1, F1, (15, 16), bias=False, stride=(15, 16))  # Conv2d #F1*4*8
        self.dropout = nn.Dropout(0.45)
        self.gelu = GELU().to(device)

    def forward(self, x):
        print("Feed_Forward input shape : {}".format(x.shape))  # ([64, 125, 128])
        output = self.gelu(self.conv1(x.unsqueeze(1)))  # ([64, 16, 8, 8])
        print("Feed_Forward output shape : {}".format(output.shape))
        output = self.dropout(output)  # ([64, 16, 8, 8])
        print("Feed_Forward output shape : {}".format(output.shape))
        output = output.contiguous().view(-1, self.num_flat_features(output))  # torch.Size([64, 1024])
        print("Feed_Forward output shape : {}".format(output.shape))
        return output

    def num_flat_features(self, x):
        size = x.size()[1:]  # all dimensions except the batch dimension
        num_features = 1
        for s in size:
            num_features = num_features * s
        return num_features

import torch
import torch.nn as nn
import torch.optim as optim

class Encoder(nn.Module):
    def __init__(self,**kwargs):
        super(Encoder,self).__init__(**kwargs)
    def forward(self,X,*args):
        raise NotImplementedError
        
class Decoder(nn.Module):
    def __init__(self,**kwargs):
        super(Decoder,self).__init__(**kwargs)
    def init_state(self,enc_outputs,*args):
        raise NotImplementedError
    def forware(self,X,state):
        raise NotImplementedError
        
class EncoderDecorder(nn.Module):
    """编码器-解码器结构的基类"""
    def __init__(self,encoder,decorder,**kwargs):
        super(EncoderDecorder,self).__init__(**kwargs)
        self.encoder=encoder
        self.decoder=decoder
     def forward(self,enc_X,dec_X,*args): #decoder结合一些其他输入
        enc_outputs=self.encoder(enc_X,*args)
        dec_state=self.decoder.init_state(enc_outputs)
        outputs=self.decoder(dec_X,dec_state)
        return outputs

# 使用PyTorch实现简单的点积注意力
import torch
import torch.nn.functional as F

# 初始化Query, Key, Value
Q = torch.tensor([[1.0, 0.8]])  # Query 对应于 "喜欢" 的编码
K = torch.tensor([[0.9, 0.1], [0.8, 0.2], [0.7, 0.9]])  # Key 对应于 "猫", "追逐", "老鼠" 的编码
V = torch.tensor([[1.0, 0.1], [0.9, 0.2], [0.8, 0.3]])  # Value 也对应于 "猫", "追逐", "老鼠" 的编码

# 计算注意力权重
d_k = K.size(1)
scores = torch.matmul(Q, K.transpose(0, 1)) / (d_k ** 0.5)
weights = F.softmax(scores, dim=-1)

# 计算注意力输出
output = torch.matmul(weights, V)

print("注意力权重:", weights)
print("注意力输出:", output)

注意力权重: tensor([[0.4761, 0.2678, 0.2561]])
注意力输出: tensor([[0.9529, 0.1797]])

from torch.utils.data import Dataset
from PIL import Image
import os


class MyData(Dataset):

    def __init__(self, root_dir, label_dir):
        self.root_dir = root_dir  # 数据集文件夹
        self.label_dir = label_dir  # 数据集标签
        self.path = os.path.join(root_dir, label_dir)  # 拼接路径 这里正好文件夹名就是标签名
        self.img_path = os.listdir(self.path)  # 将文件夹下图片转换成列表

    def __getitem__(self, idx):  # idx是索引
        img_name = self.img_path[idx]  # 获取单张图片名字
        img_item_path = os.path.join(self.root_dir, self.label_dir, img_name)  # 拼接获得单张图的地址
        img = Image.open(img_item_path)  # 图片读取
        label = self.label_dir  # 获取标签
        return img, label

    def __len__(self):
        return len(self.img_path)  # 长度即数据集的列表长度


root_dir = "dataset/train"  # 大路径
ants_label_dir = "ants"  # 蚂蚁标签
bees_label_dir = "bees"  # 蜜蜂标签
ants_dataset = MyData(root_dir, ants_label_dir)  # 实例化蚂蚁
bees_dataset = MyData(root_dir, bees_label_dir)  # 实例化蜜蜂

train_dataset = ants_dataset + bees_dataset  # 拼接数据集

import numpy as np
from torch.utils.tensorboard import SummaryWriter
from PIL import Image

writer = SummaryWriter("logs")
image_path = "data/train/ants_image/0013035.jpg"
img_PIL = Image.open(image_path)  # 打开图片
img_array = np.array(img_PIL)  # 转成numpy型
print(type(img_array))  # 验证时numpy型
print(img_array.shape)  # 检查图片的形状，发现是HWC，即高度-宽度-通道

writer.add_image("test", img_array, dataformats="HWC")  # HWC对应图片的形状

for i in range(100):
    writer.add_scalar("y=2*x",3*i,i)

writer.close()

from PIL import Image
from  torch.utils.tensorboard import SummaryWriter
from torchvision import transforms

writer=SummaryWriter("logs")
img=Image.open("dataset/val/ants/800px-Meat_eater_ant_qeen_excavating_hole.jpg")
print(img)

#ToTensor
trans_totensor=transforms.ToTensor()
img_tensor=trans_totensor(img) #  转成tensor类型
writer.add_image("ToTensor",img_tensor)

#  Normalize
print(img_tensor[0][0][0])
trans_norm=transforms.Normalize([3,0.5,0.5],[0.5,0.5,0.5]) #  标准差
img_norm=trans_norm(img_tensor)
print(img_norm[0][0][0])
writer.add_image("Normalize",img_norm,1)

writer.close()

#接上面代码
# Resize
print(img.size)  # 原图的大小(800, 534)
trans_resize = transforms.Resize((512, 512)) # 改大小
# img PIL -> resize -> img_resize PIL
img_resize = trans_resize(img)
# img_resize PIL -> totensor -> img_resize tensor
img_resize=trans_totensor(img_resize)
writer.add_image("Resize",img_resize,0)
print(img_resize)

Compose([transforms参数1,transforms参数2,...])

# Compose - resize - 2
trans_resize_2 = transforms.Resize(512) # 只改了宽 没改长
# PIL -> PIL -> tensor
tran_compose = transforms.Compose([trans_resize_2, trans_totensor])
img_resize_2 = tran_compose(img)
writer.add_image("Resize", img_resize_2, 1)
writer.close()

trans_random = transforms.RandomCrop(512) 
# PIL -> PIL -> tensor
tran_compose_2 = transforms.Compose([trans_random, trans_totensor])
for i in range(10): # 设置不同步数
    img_crop=trans_compose_2(img)
    writer.add_image("RandomCrop", img_resize_2, 1)

writer.close()

import torchvision
from torch.utils.tensorboard import SummaryWriter

dataset_transform=torchvision.transforms.Compose([torchvision.transforms.ToTensor()]) # 设置transforms
train_set=torchvision.datasets.CIFAR10(root="./dataset/data1",train=True,transform=dataset_transform,download=True) # 加入transforms参数
test_set=torchvision.datasets.CIFAR10(root="./dataset/test1",train=False,transform=dataset_transform,download=True)

writer=SummaryWriter('p10')
for i in range(10):
    img,target = test_set[i]
    writer.add_image("test_set",img,i)

writer.close()

import torchvision
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter

# 准备测试数据集
test_data = torchvision.datasets.CIFAR10("./dataset/test1", train=False, transform=torchvision.transforms.ToTensor())
test_loader = DataLoader(dataset=test_data, batch_size=64, shuffle=True, num_workers=0, drop_last=True)

# 测试数据集中第一张照片及target
img, target = test_data[0]
print(img.shape)
print(target)

writer = SummaryWriter("dataloader")
step = 0
for data in test_loader:
    imgs, targets = data  # test_loader返回值是batch_size设定的一组图片打包的img和target
    writer.add_images("test_data", imgs, step)
    step = step + 1

writer.close()

import torch
import torch.nn as nn
import torch.nn.functional as F

class Model(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2d(1, 20, 5)
        self.conv2 = nn.Conv2d(20, 20, 5)

    def forward(self, x): # 隐藏层
        x = F.relu(self.conv1(x)) #  经过一次卷积然后一次非线性 
        return F.relu(self.conv2(x)) # 输出
    
    

import torch
import torch.nn.functional as F

input=torch.tensor([[1,2,0,3,1],
                   [0,1,2,3,1],
                   [3,2,3,1,1],
                   [5,2,3,1,1],
                   [2,1,0,1,1]])

kernel=torch.tensor([[1,2,1],
                     [0,1,0],
                     [2,1,0]])

print(input.shape) # 只有两个参数，不能直接放进卷积，要reshape

input=torch.reshape(input,(1,1,5,5)) # 5X5矩阵
kernel=torch.reshape(kernel,(1,1,3,3))

print(input.shape)
print(kernel.shape) # 变成四个参数

output=F.conv2d(input,kernel,stride=1,padding=1)
print(output)

# 输出
# torch.Size([5, 5])
# torch.Size([1, 1, 5, 5])
# torch.Size([1, 1, 3, 3])
# tensor([[[[ 1,  3,  4, 10,  8],
#           [ 7, 14, 14, 17,  9],
#           [ 9, 18, 18, 17,  9],
#           [15, 17, 14,  8,  7],
#           [14, 13,  9,  7,  4]]]])

CLASS torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True, padding_mode='zeros', device=None, dtype=None)

# 参数表 输入通道数，输出通道数，卷积核大小，卷积操作步径大小，边缘填充，卷积核距离...后面都是默认参数

import torch
import torchvision.datasets
from torch import nn
from torch.nn import Conv2d
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter

dataset = torchvision.datasets.CIFAR10("/dataset/data2", train=False, transform=torchvision.transforms.ToTensor(),
                                       download=True)
dataLoader = DataLoader(dataset, batch_size=64)


class MyModule(nn.Module):
    def __init__(self):
        super(Tudui, self).__init__()
        self.conv1 = Conv2d(in_channels=3, out_channels=6, kernel_size=3, stride=1, padding=0)

    def forward(self, x):
        x = self.conv1(x)
        return x


myModule = MyModule()
writer = SummaryWriter("logs2")
step = 0
for data in dataLoader:
    imgs, targets = data
    output = myModule(imgs)
    print(imgs.shape)
    print(output.shape)
    # torch.Size([64,3,32,32])
    writer.add_images("input", imgs, step)
    # torch.Size([64,6,30,30]) -> [xxx,3,30,30]
    output = torch.reshape(output, (-1, 3, 30, 30))  # 原本输出通道数变两倍，这一步相当于切开放到一个
    writer.add_images("output", output, step)
    step = step + 1

# 最大池化

import torch
from torch import nn
from torch.nn import MaxPool2d

input = torch.tensor([[1, 2, 0, 3, 1],
                      [0, 1, 2, 3, 1],
                      [1, 2, 1, 0, 0],
                      [5, 2, 3, 1, 1],
                      [2, 1, 0, 1, 1]], dtype=torch.float32)  # 声明一下类型否则报错
input = torch.reshape(input, (-1, 1, 5, 5))
print(input.shape)


class MyModule(nn.Module):
    def __init__(self):
        super(MyModule, self).__init__()
        self.maxpool1 = MaxPool2d(kernel_size=3, ceil_mode=False) # 注意ceil_mode

    def forward(self,input):
        output=self.maxpool1(input)
        return output

myModule = MyModule()
output = myModule(input)
print(output)

# 当ceilmode设置为false结果：
# torch.Size([1, 1, 5, 5])
# tensor([[[[2.]]]])

# 当ceilmode设置为true结果：
# torch.Size([1, 1, 5, 5])
# tensor([[[[2., 3.],
#           [5., 1.]]]])

# 最大池化

import torch
import torchvision
from torch import nn
from torch.nn import MaxPool2d
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter

dataset = torchvision.datasets.CIFAR10("/dataset/data2", train=False, transform=torchvision.transforms.ToTensor(),
                                       download=True)
dataLoader = DataLoader(dataset, batch_size=64)


class MyModule(nn.Module):
    def __init__(self):
        super(MyModule, self).__init__()
        self.maxpool1 = MaxPool2d(kernel_size=3, ceil_mode=True)

    def forward(self, input):
        output = self.maxpool1(input)
        return output


myModule = MyModule()
writer = SummaryWriter("Logs_maxpool")
step = 0

for data in dataLoader:
    imgs, targets = data
    writer.add_images("input", imgs, step)
    output = myModule(imgs)
    writer.add_images("output", output, step)
    step = step + 1

writer.close()

import torch
import torchvision
from torch import nn
from torch.nn import Sigmoid, ReLU
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter

dataset = torchvision.datasets.CIFAR10("/dataset/data2", train=False, transform=torchvision.transforms.ToTensor(),
                                       download=True)
dataLoader = DataLoader(dataset, batch_size=64)


class MyModule(nn.Module):
    def __init__(self):
        super(MyModule, self).__init__()
        self.relu = ReLU()
        self.sigmoid1 = Sigmoid()

    def forward(self, input):
        output = self.sigmoid1(input)
        return output


MyModule = MyModule()

writer = SummaryWriter("logs_relu")
step = 0
for data in dataLoader:
    imgs, targets = data
    writer.add_images("input", imgs, global_step=step)
    output = MyModule(imgs)
    writer.add_images("output", output, global_step=step)
    step += 1

writer.close()

CLASS torch.nn.Linear(in_features,out_features,biass=True)

import torch
from torch import nn
from torch.nn import Conv2d, MaxPool2d, Flatten, Linear, Sequential
from torch.utils.tensorboard import SummaryWriter


class MyModule(nn.Module):
    def __init__(self):
        super(MyModule, self).__init__()
        self.model1 = Sequential(
            Conv2d(3, 32, 5, padding=2),
            MaxPool2d(2),
            Conv2d(32, 32, 5, padding=2),
            MaxPool2d(2),
            Conv2d(32, 64, 5, padding=2),
            MaxPool2d(2),
            Flatten(),
            Linear(1024, 64),
            Linear(64, 10)
        )

    def forward(self, x):
        x = self.model1(x)
        return x


myModule = MyModule()
print(myModule)
input = torch.ones((64, 3, 32, 32))  # torch提供的一个假设的输入
output = myModule(input)
print(output.shape)

writer = SummaryWriter("logs_seq2")
writer.add_graph(myModule,input)
writer.close()