vit-mnist.ipynb

{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"name":"python","version":"3.10.14","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"},"kaggle":{"accelerator":"gpu","dataSources":[],"dockerImageVersionId":30762,"isInternetEnabled":true,"language":"python","sourceType":"notebook","isGpuEnabled":true}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"code","source":"import numpy as np\nimport torch\nimport matplotlib.pyplot as plt\nfrom torch import nn\nfrom torch.utils.data import Dataset, DataLoader\nfrom torchvision.transforms import transforms\nfrom torchvision.datasets import MNIST\nfrom tqdm import tqdm\n\n\nclass PatchEmbedding(nn.Module):\n    def __init__(self, img_size, patch_size, d_model, n_channels):\n        \"\"\"\n        将输入图片(BS, C, H, W)划分为patches(BS, num_patches, d_model)\n\n        img_size: (H, W) 图片大小\n        patch_size: (ph, pw) patch大小\n        d_model: 每个patch/token的嵌入维度\n        n_channels: 输入图片的通道数\n        \"\"\"\n        super(PatchEmbedding, self).__init__()\n        self.img_size = img_size\n        self.patch_size = patch_size\n        self.d_model = d_model\n        self.n_channels = n_channels\n        self.patcher = nn.Conv2d(in_channels=n_channels, out_channels=d_model, kernel_size=patch_size, stride=patch_size)\n        self.flatten = nn.Flatten(start_dim=2)\n\n\n    def forward(self, x):   # x:(BS, C, H, W)\n        x = self.patcher(x)      # (BS, C, H, W)->(BS, d_model, H//ph, W//pw)\n        x = self.flatten(x)      # (BS, d_model, H//ph * W//pw) = (BS, d_model, num_patches)\n        x = x.transpose(-1, -2)   # (BS, d_model, num_patches)->(BS, num_patches, d_model)\n        return x                 # (BS, num_patches, d_model)\n\n\n\n\nclass PositionalEncoding(nn.Module):\n    def __init__(self, d_model, max_seq_length):\n        \"\"\"\n        给经过patch的输入加上class_token和位置编码，然后直接输入到TransformerEncoder中\n        d_model: 每个patch/token的嵌入维度，也是位置编码每个位置的嵌入维度\n        max_seq_length: 1+num_patches， 包括class_token在内的总的tokens数\n        \"\"\"\n        super(PositionalEncoding, self).__init__()\n        self.d_model = d_model\n        self.max_seq_length = max_seq_length\n        self.cls_token = nn.Parameter(data=torch.randn(size=(1, 1, d_model)), requires_grad=True)\n        # 第一个1指BS维度，第二个1指只有1个token，第三个d_model指这个token的嵌入维度\n#         self.pe = nn.Parameter(data=torch.randn(size=(1, max_seq_length, d_model)), requires_grad=True)\n\n        pe = torch.zeros(max_seq_length, d_model)   # 使用全0初始化位置编码pe\n        # 位置编码采用固定的正余弦位置编码\n        # 对于每个位置pos的嵌入[0,0,...,0]共d_model个0\n        # 对于第i个0，\n        # 如果i是偶数，则取值sin(pos/(10000**(i/d_model)))\n        # 如果i是奇数，则取值cos(pos/(10000**((i-1)/d_model)))\n        for pos in range(max_seq_length):\n            for i in range(d_model):\n                if i % 2 == 0:\n                    pe[pos][i] = np.sin(pos/(10000**(i/d_model)))\n                else:\n                    pe[pos][i] = np.cos(pos/(10000**((i-1)/d_model)))\n\n        pe = pe.unsqueeze(0)  # (max_seq_length, d_model)->(1, max_seq_length, d_model)\n        self.register_buffer(\"pe\", pe)\n        # 将变量pe注册为模型的参数，但是不会被优化器更新，是固定的，可以通过self.pe来调用\n        # 当模型被保存下来的时候，参数pe也会被保存下来\n\n\n\n\n    def forward(self, x):    # x来自PatchEmbedding   (BS, num_patches, d_model)\n        cls_tokens = self.cls_token.expand(size=(x.shape[0], -1, -1))    # (1, 1, d_model)->(BS, 1, d_model)\n        x = torch.cat([cls_tokens, x], dim=1)     # (BS, 1, d_model)(BS, num_patches, d_model)->(BS, 1+num_patches, d_model)\n        x = x + self.pe   # (BS, 1+num_patches, d_model)+(1, max_seq_length, d_model)=(BS, 1+num_patches, d_model)\n        return x     # (BS, 1+num_patches, d_model)\n\n\n\n# 自注意力模块，首先计算单头注意力\nclass AttentionHead(nn.Module):\n    def __init__(self, d_model, head_size):\n        \"\"\"\n        计算单头注意力\n        d_model: 每个patch/token的嵌入维度\n        head_size: 每个头中每个patch/token的嵌入维度\n        \"\"\"\n        super(AttentionHead, self).__init__()\n        self.d_model = d_model\n        self.head_size = head_size\n\n        self.query = nn.Linear(d_model, head_size)\n        self.key = nn.Linear(d_model, head_size)\n        self.value = nn.Linear(d_model, head_size)\n\n\n    def forward(self, x):   # x: (BS, 1+num_patches, d_model)\n        Q = self.query(x)   # (BS, 1+num_patches, d_model)->(BS, 1+num_patches, head_size)\n        K = self.key(x)     # (BS, 1+num_patches, d_model)->(BS, 1+num_patches, head_size)\n        V = self.value(x)   # (BS, 1+num_patches, d_model)->(BS, 1+num_patches, head_size)\n        attention = Q @ (K.transpose(-2, -1))   # (BS, 1+num_patches, head_size) @ (BS, head_size, 1+num_patches) -> (BS, 1+num_patches, 1+num_patches)\n        attention = attention / np.sqrt(self.head_size)\n        attention = torch.softmax(attention, dim=-1)   # 对最后一个维度进行softmax，因为最后一个维度将对V中的各个token的嵌入进行加权求和\n        out = attention @ V  # (BS, 1+num_patches, 1+num_patches) @ (BS, 1+num_patches, head_size) -> (BS, 1+num_patches, head_size)\n        return out           # (BS, 1+num_patches, head_size)\n\n\n# 多头注意力模块，计算多个头的注意力\nclass MultiHeadAttention(nn.Module):\n    def __init__(self, d_model, n_heads):\n        \"\"\"\n        计算多头注意力\n        d_model: 每个patch/token的嵌入维度\n        n_heads: 总的头数\n        \"\"\"\n        super(MultiHeadAttention, self).__init__()\n        self.d_model = d_model\n        self.n_heads = n_heads\n        self.head_size = d_model // n_heads\n        self.heads = nn.ModuleList([AttentionHead(self.d_model, self.head_size) for _ in range(n_heads)])\n        self.W_o = nn.Linear(d_model, d_model)\n\n    def forward(self, x):   # x: (BS, 1+num_patches, d_model)\n        out = torch.cat([head(x) for head in self.heads], dim=-1)    # x: (BS, 1+num_patches, head_size*n_heads)=(BS, 1+num_patches, d_model)\n        # [head1(x), head2(x), ...]   headi(x):(BS, 1+num_patches, head_size)\n        out = self.W_o(out)   # (BS, 1+num_patches, d_model)->(BS, 1+num_patches, d_model)\n        return out          # (BS, 1+num_patches, d_model)   多头注意力模块不改变输入的形状\n\n\n\n\n# 构造Transformer编码器\nclass TransformerEncoder(nn.Module):\n    def __init__(self, d_model, n_heads, r_mlp=4):\n        \"\"\"\n        d_model: 每个patch/token的嵌入维度\n        n_heads: 总的头数\n        r_mlp: MLP中隐藏层相对于d_model放大的倍数\n        \"\"\"\n        super(TransformerEncoder, self).__init__()\n        self.d_model = d_model\n        self.n_heads = n_heads\n        self.r_mlp = r_mlp\n\n        self.ln1 = nn.LayerNorm(d_model)      # 第一个LayerNorm层(LayerNorm层是有参数的)\n        self.mha = MultiHeadAttention(d_model, n_heads)\n        self.ln2 = nn.LayerNorm(d_model)      # 第二个LayerNorm层(LayerNorm层是有参数的)\n        self.mlp = nn.Sequential(\n            nn.Linear(d_model, d_model * r_mlp),\n            nn.GELU(),\n            nn.Linear(d_model * r_mlp, d_model),\n        )\n\n    def forward(self, x):   # x: (BS, 1+num_patches, d_model)\n        out = x + self.mha(self.ln1(x))       # (BS, 1+num_patches, d_model)\n        out = out + self.mlp(self.ln2(out))     # (BS, 1+num_patches, d_model)\n        return out          # (BS, 1+num_patches, d_model)   经过Transformer编码器不改变输入的形状\n\n\n\n# 构造ViT\nclass VisionTransformer(nn.Module):\n    def __init__(self, d_model, img_size, patch_size, n_channels, n_heads, n_classes, n_layers):\n        \"\"\"\n        构造VisionTransformer\n        d_model: 每个patch/token的嵌入维度\n        img_size: 输入图片的大小(H, W)\n        patch_size: 每个patch的大小(ph, pw)\n        n_channels: 输入图片的通道数\n        max_seq_length: patches/tokens的总数=1+num_patches\n        n_heads: 多头注意力的头数\n        n_classes: 总的分类类别数\n        n_layers: Transformer编码器的个数\n        \"\"\"\n        super(VisionTransformer, self).__init__()\n        # 断言图片的高和宽能被patch的高和宽整除\n        assert img_size[0] % patch_size[0] == 0 and img_size[1] % patch_size[1] == 0, \"img_size dimensions must be divisible by patch_size dimensions\"\n\n        # 断言d_model能被n_heads整除\n        assert d_model % n_heads == 0, \"d_model must be divisible by n_heads\"\n\n        self.d_model = d_model\n        self.img_size = img_size\n        self.patch_size = patch_size\n        self.n_channels = n_channels\n        self.n_heads = n_heads\n        self.n_classes = n_classes\n        self.n_layers = n_layers\n\n\n\n        self.num_patches = (img_size[0] // patch_size[0]) * (img_size[1] // patch_size[1])\n        self.max_seq_length = 1 + self.num_patches\n\n        self.patch_embedding = PatchEmbedding(self.img_size, self.patch_size, self.d_model, self.n_channels)\n        self.positional_encoding = PositionalEncoding(self.d_model, self.max_seq_length)\n        self.transformer_encoder = nn.Sequential(*[TransformerEncoder(self.d_model, self.n_heads) for _ in range(n_layers)])\n        self.classifier = nn.Sequential(\n            nn.LayerNorm(normalized_shape=self.d_model),\n            nn.Linear(self.d_model, self.n_classes),\n        )\n\n    def forward(self, images):                     # images: (BS, C, H, W)\n        x = self.patch_embedding(images)           # (BS, C, H, W)->(BS, num_patches, d_model)\n        x = self.positional_encoding(x)            # (BS, num_patches, d_model)->(BS, 1+num_patches, d_model)\n        x = self.transformer_encoder(x)            # (BS, 1+num_patches, d_model)->(BS, 1+num_patches, d_model)\n        x = self.classifier(x[:, 0, :])            # x[:, 0, :] (BS, d_model)->(BS, n_classes)\n        return x       # (BS, n_classes)\n\n\nimages = torch.randn(32, 1, 28, 28)\nmodel = VisionTransformer(d_model=256, img_size=(28, 28), patch_size=(4, 4), n_channels=1, n_heads=8, n_classes=10, n_layers=6)\nprint(model(images).shape)    # 应该是(32, 10)","metadata":{"execution":{"iopub.status.busy":"2024-09-07T07:00:34.253837Z","iopub.execute_input":"2024-09-07T07:00:34.254241Z","iopub.status.idle":"2024-09-07T07:00:37.266271Z","shell.execute_reply.started":"2024-09-07T07:00:34.254197Z","shell.execute_reply":"2024-09-07T07:00:37.265261Z"},"trusted":true},"execution_count":1,"outputs":[{"name":"stdout","text":"torch.Size([32, 10])\n","output_type":"stream"}]},{"cell_type":"code","source":"# Hyperparameter\nd_model = 9    \nn_classes = 10\nimg_size = (32, 32)\npatch_size = (16, 16)\nn_channels = 1\nn_heads = 3\nn_layers = 3\nbatch_size = 128\nepochs = 20\nlearning_rate = 1e-4\nweight_decay = 0.005\n\n\n\n\n\n\n# 构建数据集\ntransform = transforms.Compose([\n    transforms.Resize(img_size),\n    transforms.RandomRotation(15),\n    transforms.ToTensor(),\n#     transforms.Normalize([0.5], [0.5]),\n])\n\ntrain_set = MNIST(root=\"/kaggle/working/datasets\", train=True, transform=transform, download=True)\ntest_set = MNIST(root=\"/kaggle/working/datasets\", train=False, transform=transform, download=True)\n\ntrain_loader = DataLoader(dataset=train_set, batch_size=batch_size, shuffle=True)\ntest_loader = DataLoader(dataset=test_set, batch_size=batch_size, shuffle=False)\n\ndevice = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\nmodel = VisionTransformer(d_model, img_size, patch_size, n_channels, n_heads, n_classes, n_layers).to(device)\n\ncriterion = nn.CrossEntropyLoss()\noptimizer = torch.optim.Adam(model.parameters(), lr=learning_rate, betas=(0.9, 0.999), weight_decay=weight_decay)\nscheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, factor=0.1, patience=10)\n\n\n# 训练模型\nfor epoch in tqdm(range(epochs), position=0, leave=True):\n    model.train()\n    training_loss = 0    # 记录每个epoch的总的训练损失\n    for batch_idx, data in enumerate(tqdm(train_loader, position=0, leave=True)):    # 这里的0显式地指定了batch_idx从0开始(默认也是从0开始)\n        images, labels = data     # images:(BS, 1, 28, 28)  labels:(BS)\n        images, labels = images.to(device), labels.to(device)\n\n        outputs = model(images)   # (BS, n_classes)\n        loss = criterion(outputs, labels)    # (BS, n_classes) (BS)\n        training_loss += loss.item()\n\n        optimizer.zero_grad()\n        loss.backward()\n        optimizer.step()\n\n    train_loss = training_loss / (batch_idx + 1)  # 每个epoch平均每个batch的损失\n\n    print(f\"Epoch: {epoch}/{epochs}  Train_Loss: {train_loss: .4f}\")\n\n    # 测试训练好的模型\n    correct = 0     # 预测正确的个数\n    total = 0       # 总的预测个数\n    model.eval()    # 将模型设置为验证模式\n    val_loss = 0\n    with torch.no_grad():\n        for batch_idx, data in enumerate(tqdm(test_loader, position=0, leave=True)):\n            images, labels = data     # images:(BS, C, H, W)  labels:(BS)\n            images, labels = images.to(device), labels.to(device)\n            outputs = model(images)   # (BS, n_classes)\n            loss = criterion(outputs, labels)\n            val_loss += loss.item()\n            \n            max_values, max_indexes = torch.max(outputs, dim=-1)    # max_values:(BS)  max_indexes:(BS)\n            total += labels.shape[0]\n            correct += (max_indexes == labels).sum().item()\n            \n    val_loss = val_loss / (batch_idx + 1)\n    scheduler.step(val_loss)\n    current_lr = scheduler.get_last_lr()\n    print(f\"Current learning rates: {current_lr}\")\n    print(f\"Epoch: {epoch}/{epochs}  Val_Loss: {val_loss: .4f}\")\n    print(f\"Model Accuracy: {correct/total}\")\n","metadata":{"execution":{"iopub.status.busy":"2024-09-07T07:00:37.267690Z","iopub.execute_input":"2024-09-07T07:00:37.268167Z","iopub.status.idle":"2024-09-07T07:04:38.103267Z","shell.execute_reply.started":"2024-09-07T07:00:37.268127Z","shell.execute_reply":"2024-09-07T07:04:38.102298Z"},"trusted":true},"execution_count":2,"outputs":[{"name":"stderr","text":"100%|██████████| 469/469 [00:21<00:00, 21.78it/s]\n","output_type":"stream"},{"name":"stdout","text":"Epoch: 0/10  Train_Loss:  2.1598\n","output_type":"stream"},{"name":"stderr","text":"100%|██████████| 79/79 [00:02<00:00, 28.47it/s]\n 10%|█         | 1/10 [00:24<03:38, 24.31s/it]","output_type":"stream"},{"name":"stdout","text":"Current learning rates: [0.0001]\nEpoch: 0/10  Val_Loss:  1.7694\nModel Accuracy: 0.3847\n","output_type":"stream"},{"name":"stderr","text":"100%|██████████| 469/469 [00:21<00:00, 22.33it/s]\n","output_type":"stream"},{"name":"stdout","text":"Epoch: 1/10  Train_Loss:  1.5729\n","output_type":"stream"},{"name":"stderr","text":"100%|██████████| 79/79 [00:02<00:00, 28.89it/s]\n 20%|██        | 2/10 [00:48<03:11, 23.98s/it]","output_type":"stream"},{"name":"stdout","text":"Current learning rates: [0.0001]\nEpoch: 1/10  Val_Loss:  1.3964\nModel Accuracy: 0.6462\n","output_type":"stream"},{"name":"stderr","text":"100%|██████████| 469/469 [00:21<00:00, 21.98it/s]\n","output_type":"stream"},{"name":"stdout","text":"Epoch: 2/10  Train_Loss:  1.2800\n","output_type":"stream"},{"name":"stderr","text":"100%|██████████| 79/79 [00:02<00:00, 28.88it/s]\n 30%|███       | 3/10 [01:12<02:48, 24.02s/it]","output_type":"stream"},{"name":"stdout","text":"Current learning rates: [0.0001]\nEpoch: 2/10  Val_Loss:  1.1449\nModel Accuracy: 0.755\n","output_type":"stream"},{"name":"stderr","text":"100%|██████████| 469/469 [00:21<00:00, 21.93it/s]\n","output_type":"stream"},{"name":"stdout","text":"Epoch: 3/10  Train_Loss:  1.0633\n","output_type":"stream"},{"name":"stderr","text":"100%|██████████| 79/79 [00:02<00:00, 28.38it/s]\n 40%|████      | 4/10 [01:36<02:24, 24.09s/it]","output_type":"stream"},{"name":"stdout","text":"Current learning rates: [0.0001]\nEpoch: 3/10  Val_Loss:  0.9475\nModel Accuracy: 0.8116\n","output_type":"stream"},{"name":"stderr","text":"100%|██████████| 469/469 [00:21<00:00, 22.16it/s]\n","output_type":"stream"},{"name":"stdout","text":"Epoch: 4/10  Train_Loss:  0.8921\n","output_type":"stream"},{"name":"stderr","text":"100%|██████████| 79/79 [00:02<00:00, 28.59it/s]\n 50%|█████     | 5/10 [02:00<02:00, 24.03s/it]","output_type":"stream"},{"name":"stdout","text":"Current learning rates: [0.0001]\nEpoch: 4/10  Val_Loss:  0.7948\nModel Accuracy: 0.8409\n","output_type":"stream"},{"name":"stderr","text":"100%|██████████| 469/469 [00:21<00:00, 21.82it/s]\n","output_type":"stream"},{"name":"stdout","text":"Epoch: 5/10  Train_Loss:  0.7577\n","output_type":"stream"},{"name":"stderr","text":"100%|██████████| 79/79 [00:02<00:00, 28.24it/s]\n 60%|██████    | 6/10 [02:24<01:36, 24.12s/it]","output_type":"stream"},{"name":"stdout","text":"Current learning rates: [0.0001]\nEpoch: 5/10  Val_Loss:  0.6802\nModel Accuracy: 0.8596\n","output_type":"stream"},{"name":"stderr","text":"100%|██████████| 469/469 [00:21<00:00, 22.16it/s]\n","output_type":"stream"},{"name":"stdout","text":"Epoch: 6/10  Train_Loss:  0.6529\n","output_type":"stream"},{"name":"stderr","text":"100%|██████████| 79/79 [00:02<00:00, 28.50it/s]\n 70%|███████   | 7/10 [02:48<01:12, 24.06s/it]","output_type":"stream"},{"name":"stdout","text":"Current learning rates: [0.0001]\nEpoch: 6/10  Val_Loss:  0.5907\nModel Accuracy: 0.8726\n","output_type":"stream"},{"name":"stderr","text":"100%|██████████| 469/469 [00:20<00:00, 22.45it/s]\n","output_type":"stream"},{"name":"stdout","text":"Epoch: 7/10  Train_Loss:  0.5756\n","output_type":"stream"},{"name":"stderr","text":"100%|██████████| 79/79 [00:02<00:00, 28.75it/s]\n 80%|████████  | 8/10 [03:12<00:47, 23.93s/it]","output_type":"stream"},{"name":"stdout","text":"Current learning rates: [0.0001]\nEpoch: 7/10  Val_Loss:  0.5243\nModel Accuracy: 0.8852\n","output_type":"stream"},{"name":"stderr","text":"100%|██████████| 469/469 [00:21<00:00, 21.67it/s]\n","output_type":"stream"},{"name":"stdout","text":"Epoch: 8/10  Train_Loss:  0.5191\n","output_type":"stream"},{"name":"stderr","text":"100%|██████████| 79/79 [00:02<00:00, 28.30it/s]\n 90%|█████████ | 9/10 [03:36<00:24, 24.09s/it]","output_type":"stream"},{"name":"stdout","text":"Current learning rates: [0.0001]\nEpoch: 8/10  Val_Loss:  0.4744\nModel Accuracy: 0.8841\n","output_type":"stream"},{"name":"stderr","text":"100%|██████████| 469/469 [00:21<00:00, 22.03it/s]\n","output_type":"stream"},{"name":"stdout","text":"Epoch: 9/10  Train_Loss:  0.4758\n","output_type":"stream"},{"name":"stderr","text":"100%|██████████| 79/79 [00:02<00:00, 28.94it/s]\n100%|██████████| 10/10 [04:00<00:00, 24.06s/it]","output_type":"stream"},{"name":"stdout","text":"Current learning rates: [0.0001]\nEpoch: 9/10  Val_Loss:  0.4430\nModel Accuracy: 0.8944\n","output_type":"stream"},{"name":"stderr","text":"\n","output_type":"stream"}]},{"cell_type":"code","source":"# 画出测试数据集中前6张图片和对应的预测label\nfig, axarr = plt.subplots(2, 3)\ncounter = 0   # 显示的图片的id\nimages, labels = next(iter(test_loader))  # (BS, 1, 32, 32) (BS)\nimages, labels = images.to(device), labels.to(device)\noutputs = model(images)    # (BS, 1, 32, 32)->(BS, 10)\nmax_values, max_indexes = torch.max(outputs, dim=-1)  # max_indexes: (BS)\nfor i in range(2):\n    for j in range(3):\n        image = images[counter]    # (BS, 1, 32, 32)->(1, 32, 32)\n        label = labels[counter]    # (BS)->(1)\n        axarr[i][j].imshow(image.squeeze().detach().cpu(), cmap=\"gray\")    # (1, 32, 32)->(32, 32)  \"gray\"\n        axarr[i][j].set_title(f\"predicted:{max_indexes[counter]} label:{label}\")\n        counter += 1\n\n# 显示所有图片\nplt.show()\n","metadata":{"execution":{"iopub.status.busy":"2024-09-07T07:05:43.202548Z","iopub.execute_input":"2024-09-07T07:05:43.203213Z","iopub.status.idle":"2024-09-07T07:05:43.993720Z","shell.execute_reply.started":"2024-09-07T07:05:43.203172Z","shell.execute_reply":"2024-09-07T07:05:43.992755Z"},"trusted":true},"execution_count":5,"outputs":[{"output_type":"display_data","data":{"text/plain":"<Figure size 640x480 with 6 Axes>","image/png":"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"},"metadata":{}}]},{"cell_type":"code","source":"","metadata":{},"execution_count":null,"outputs":[]}]}