P7学习笔记

于 2024-04-25 21:19:57 发布
阅读量381 收藏 6
点赞数 3
文章标签： 学习 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Inface0443/article/details/138199870
版权

咖啡豆识别

设置GPU

import torch
import torch.nn as nn
import torchvision.transforms as transforms
import torchvision
from torchvision import transforms, datasets
import os,PIL,pathlib,warnings

warnings.filterwarnings("ignore")             #忽略警告信息

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
device

device(type='cuda')

导入数据

import os,PIL,random,pathlib

data_dir = r"C:\Users\11054\Desktop\kLearning\p7_learning\data"
data_dir = pathlib.Path(data_dir)

data_paths  = list(data_dir.glob('*'))
classeNames = [str(path).split("\\")[-1] for path in data_paths]
classeNames

['Dark', 'Green', 'Light', 'Medium']

# 关于transforms.Compose的更多介绍可以参考：https://blog.csdn.net/qq_38251616/article/details/124878863
train_transforms = transforms.Compose([
    transforms.Resize([224, 224]),  # 将输入图片resize成统一尺寸
    # transforms.RandomHorizontalFlip(), # 随机水平翻转
    transforms.ToTensor(),          # 将PIL Image或numpy.ndarray转换为tensor，并归一化到[0,1]之间
    transforms.Normalize(           # 标准化处理-->转换为标准正太分布（高斯分布），使模型更容易收敛
        mean=[0.485, 0.456, 0.406],
        std=[0.229, 0.224, 0.225])  # 其中 mean=[0.485,0.456,0.406]与std=[0.229,0.224,0.225] 从数据集中随机抽样计算得到的。
])

test_transform = transforms.Compose([
    transforms.Resize([224, 224]),  # 将输入图片resize成统一尺寸
    transforms.ToTensor(),          # 将PIL Image或numpy.ndarray转换为tensor，并归一化到[0,1]之间
    transforms.Normalize(           # 标准化处理-->转换为标准正太分布（高斯分布），使模型更容易收敛
        mean=[0.485, 0.456, 0.406],
        std=[0.229, 0.224, 0.225])  # 其中 mean=[0.485,0.456,0.406]与std=[0.229,0.224,0.225] 从数据集中随机抽样计算得到的。
])

total_data = datasets.ImageFolder(r"C:\Users\11054\Desktop\kLearning\p7_learning\data",transform=train_transforms)
total_data

Dataset ImageFolder
    Number of datapoints: 1200
    Root location: C:\Users\11054\Desktop\kLearning\p7_learning\data
    StandardTransform
Transform: Compose(
               Resize(size=[224, 224], interpolation=bilinear, max_size=None, antialias=True)
               ToTensor()
               Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
           )

total_data.class_to_idx

{'Dark': 0, 'Green': 1, 'Light': 2, 'Medium': 3}

划分数据集

train_size = int(0.8 * len(total_data))
test_size  = len(total_data) - train_size
train_dataset, test_dataset = torch.utils.data.random_split(total_data, [train_size, test_size])
train_dataset, test_dataset

(<torch.utils.data.dataset.Subset at 0x15fdadad9a0>,
 <torch.utils.data.dataset.Subset at 0x15fdadadcd0>)

batch_size = 32

train_dl = torch.utils.data.DataLoader(train_dataset,
                                           batch_size=batch_size,
                                           shuffle=True,
                                           num_workers=1)
test_dl = torch.utils.data.DataLoader(test_dataset,
                                          batch_size=batch_size,
                                          shuffle=True,
                                          num_workers=1)

for X, y in test_dl:
    print("Shape of X [N, C, H, W]: ", X.shape)
    print("Shape of y: ", y.shape, y.dtype)
    break

Shape of X [N, C, H, W]:  torch.Size([32, 3, 224, 224])
Shape of y:  torch.Size([32]) torch.int64

# 手动搭建VGG-16模型

VGG-16结构说明：

● 13个卷积层（Convolutional Layer），分别用blockX_convX表示
● 3个全连接层（Fully connected Layer），分别用fcX与predictions表示
● 5个池化层（Pool layer），分别用blockX_pool表示

VGG-16包含了16个隐藏层（13个卷积层和3个全连接层），故称为VGG-16

## 搭建模型

import torch.nn.functional as F

class vgg16(nn.Module):
    def __init__(self):
        super(vgg16, self).__init__()
        # 卷积块1
        self.block1 = nn.Sequential(
            nn.Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)),
            nn.ReLU(),
            nn.Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=(2, 2), stride=(2, 2))
        )
        # 卷积块2
        self.block2 = nn.Sequential(
            nn.Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)),
            nn.ReLU(),
            nn.Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=(2, 2), stride=(2, 2))
        )
        # 卷积块3
        self.block3 = nn.Sequential(
            nn.Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)),
            nn.ReLU(),
            nn.Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)),
            nn.ReLU(),
            nn.Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=(2, 2), stride=(2, 2))
        )
        # 卷积块4
        self.block4 = nn.Sequential(
            nn.Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)),
            nn.ReLU(),
            nn.Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)),
            nn.ReLU(),
            nn.Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=(2, 2), stride=(2, 2))
        )
        # 卷积块5
        self.block5 = nn.Sequential(
            nn.Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)),
            nn.ReLU(),
            nn.Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)),
            nn.ReLU(),
            nn.Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=(2, 2), stride=(2, 2))
        )

        # 全连接网络层，用于分类
        self.classifier = nn.Sequential(
            nn.Linear(in_features=512*7*7, out_features=4096),
            nn.ReLU(),
            nn.Linear(in_features=4096, out_features=4096),
            nn.ReLU(),
            nn.Linear(in_features=4096, out_features=4)
        )

    def forward(self, x):

        x = self.block1(x)
        x = self.block2(x)
        x = self.block3(x)
        x = self.block4(x)
        x = self.block5(x)
        x = torch.flatten(x, start_dim=1)
        x = self.classifier(x)

        return x

device = "cuda" if torch.cuda.is_available() else "cpu"
print("Using {} device".format(device))

model = vgg16().to(device)
model

Using cuda device





vgg16(
  (block1): Sequential(
    (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (1): ReLU()
    (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (3): ReLU()
    (4): MaxPool2d(kernel_size=(2, 2), stride=(2, 2), padding=0, dilation=1, ceil_mode=False)
  )
  (block2): Sequential(
    (0): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (1): ReLU()
    (2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (3): ReLU()
    (4): MaxPool2d(kernel_size=(2, 2), stride=(2, 2), padding=0, dilation=1, ceil_mode=False)
  )
  (block3): Sequential(
    (0): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (1): ReLU()
    (2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (3): ReLU()
    (4): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (5): ReLU()
    (6): MaxPool2d(kernel_size=(2, 2), stride=(2, 2), padding=0, dilation=1, ceil_mode=False)
  )
  (block4): Sequential(
    (0): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (1): ReLU()
    (2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (3): ReLU()
    (4): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (5): ReLU()
    (6): MaxPool2d(kernel_size=(2, 2), stride=(2, 2), padding=0, dilation=1, ceil_mode=False)
  )
  (block5): Sequential(
    (0): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (1): ReLU()
    (2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (3): ReLU()
    (4): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (5): ReLU()
    (6): MaxPool2d(kernel_size=(2, 2), stride=(2, 2), padding=0, dilation=1, ceil_mode=False)
  )
  (classifier): Sequential(
    (0): Linear(in_features=25088, out_features=4096, bias=True)
    (1): ReLU()
    (2): Linear(in_features=4096, out_features=4096, bias=True)
    (3): ReLU()
    (4): Linear(in_features=4096, out_features=4, bias=True)
  )
)

查看模型

# 统计模型参数量以及其他指标
import torchsummary as summary
summary.summary(model, (3, 224, 224))

----------------------------------------------------------------
        Layer (type)               Output Shape         Param #
================================================================
            Conv2d-1         [-1, 64, 224, 224]           1,792
              ReLU-2         [-1, 64, 224, 224]               0
            Conv2d-3         [-1, 64, 224, 224]          36,928
              ReLU-4         [-1, 64, 224, 224]               0
         MaxPool2d-5         [-1, 64, 112, 112]               0
            Conv2d-6        [-1, 128, 112, 112]          73,856
              ReLU-7        [-1, 128, 112, 112]               0
            Conv2d-8        [-1, 128, 112, 112]         147,584
              ReLU-9        [-1, 128, 112, 112]               0
        MaxPool2d-10          [-1, 128, 56, 56]               0
           Conv2d-11          [-1, 256, 56, 56]         295,168
             ReLU-12          [-1, 256, 56, 56]               0
           Conv2d-13          [-1, 256, 56, 56]         590,080
             ReLU-14          [-1, 256, 56, 56]               0
           Conv2d-15          [-1, 256, 56, 56]         590,080
             ReLU-16          [-1, 256, 56, 56]               0
        MaxPool2d-17          [-1, 256, 28, 28]               0
           Conv2d-18          [-1, 512, 28, 28]       1,180,160
             ReLU-19          [-1, 512, 28, 28]               0
           Conv2d-20          [-1, 512, 28, 28]       2,359,808
             ReLU-21          [-1, 512, 28, 28]               0
           Conv2d-22          [-1, 512, 28, 28]       2,359,808
             ReLU-23          [-1, 512, 28, 28]               0
        MaxPool2d-24          [-1, 512, 14, 14]               0
           Conv2d-25          [-1, 512, 14, 14]       2,359,808
             ReLU-26          [-1, 512, 14, 14]               0
           Conv2d-27          [-1, 512, 14, 14]       2,359,808
             ReLU-28          [-1, 512, 14, 14]               0
           Conv2d-29          [-1, 512, 14, 14]       2,359,808
             ReLU-30          [-1, 512, 14, 14]               0
        MaxPool2d-31            [-1, 512, 7, 7]               0
           Linear-32                 [-1, 4096]     102,764,544
             ReLU-33                 [-1, 4096]               0
           Linear-34                 [-1, 4096]      16,781,312
             ReLU-35                 [-1, 4096]               0
           Linear-36                    [-1, 4]          16,388
================================================================
Total params: 134,276,932
Trainable params: 134,276,932
Non-trainable params: 0
----------------------------------------------------------------
Input size (MB): 0.57
Forward/backward pass size (MB): 218.52
Params size (MB): 512.23
Estimated Total Size (MB): 731.32
----------------------------------------------------------------

训练模型

# 训练循环
def train(dataloader, model, loss_fn, optimizer):
    size = len(dataloader.dataset)  # 训练集的大小
    num_batches = len(dataloader)   # 批次数目, (size/batch_size，向上取整)

    train_loss, train_acc = 0, 0  # 初始化训练损失和正确率

    for X, y in dataloader:  # 获取图片及其标签
        X, y = X.to(device), y.to(device)

        # 计算预测误差
        pred = model(X)          # 网络输出
        loss = loss_fn(pred, y)  # 计算网络输出和真实值之间的差距，targets为真实值，计算二者差值即为损失

        # 反向传播
        optimizer.zero_grad()  # grad属性归零
        loss.backward()        # 反向传播
        optimizer.step()       # 每一步自动更新

        # 记录acc与loss
        train_acc  += (pred.argmax(1) == y).type(torch.float).sum().item()
        train_loss += loss.item()

    train_acc  /= size
    train_loss /= num_batches

    return train_acc, train_loss

def test (dataloader, model, loss_fn):
    size        = len(dataloader.dataset)  # 测试集的大小
    num_batches = len(dataloader)          # 批次数目, (size/batch_size，向上取整)
    test_loss, test_acc = 0, 0

    # 当不进行训练时，停止梯度更新，节省计算内存消耗
    with torch.no_grad():
        for imgs, target in dataloader:
            imgs, target = imgs.to(device), target.to(device)

            # 计算loss
            target_pred = model(imgs)
            loss        = loss_fn(target_pred, target)

            test_loss += loss.item()
            test_acc  += (target_pred.argmax(1) == target).type(torch.float).sum().item()

    test_acc  /= size
    test_loss /= num_batches

    return test_acc, test_loss

正式训练

import copy

optimizer  = torch.optim.Adam(model.parameters(), lr= 1e-4)
loss_fn    = nn.CrossEntropyLoss() # 创建损失函数

epochs     = 40

train_loss = []
train_acc  = []
test_loss  = []
test_acc   = []

best_acc = 0    # 设置一个最佳准确率，作为最佳模型的判别指标

for epoch in range(epochs):

    model.train()
    epoch_train_acc, epoch_train_loss = train(train_dl, model, loss_fn, optimizer)

    model.eval()
    epoch_test_acc, epoch_test_loss = test(test_dl, model, loss_fn)

    # 保存最佳模型到 best_model
    if epoch_test_acc > best_acc:
        best_acc   = epoch_test_acc
        best_model = copy.deepcopy(model)

    train_acc.append(epoch_train_acc)
    train_loss.append(epoch_train_loss)
    test_acc.append(epoch_test_acc)
    test_loss.append(epoch_test_loss)

    # 获取当前的学习率
    lr = optimizer.state_dict()['param_groups'][0]['lr']

    template = ('Epoch:{:2d}, Train_acc:{:.1f}%, Train_loss:{:.3f}, Test_acc:{:.1f}%, Test_loss:{:.3f}, Lr:{:.2E}')
    print(template.format(epoch+1, epoch_train_acc*100, epoch_train_loss,
                          epoch_test_acc*100, epoch_test_loss, lr))

# 保存最佳模型到文件中
PATH = './best_model.pth'  # 保存的参数文件名
torch.save(model.state_dict(), PATH)

print('Done')

Epoch: 1, Train_acc:23.9%, Train_loss:1.383, Test_acc:22.9%, Test_loss:1.320, Lr:1.00E-04
Epoch: 2, Train_acc:49.9%, Train_loss:1.019, Test_acc:55.4%, Test_loss:0.703, Lr:1.00E-04
Epoch: 3, Train_acc:60.0%, Train_loss:0.784, Test_acc:70.4%, Test_loss:0.693, Lr:1.00E-04
Epoch: 4, Train_acc:67.4%, Train_loss:0.697, Test_acc:75.4%, Test_loss:0.604, Lr:1.00E-04
Epoch: 5, Train_acc:73.6%, Train_loss:0.587, Test_acc:76.7%, Test_loss:0.480, Lr:1.00E-04
Epoch: 6, Train_acc:85.0%, Train_loss:0.372, Test_acc:92.1%, Test_loss:0.194, Lr:1.00E-04
Epoch: 7, Train_acc:86.0%, Train_loss:0.356, Test_acc:92.9%, Test_loss:0.208, Lr:1.00E-04
Epoch: 8, Train_acc:95.0%, Train_loss:0.161, Test_acc:95.4%, Test_loss:0.129, Lr:1.00E-04
Epoch: 9, Train_acc:94.9%, Train_loss:0.131, Test_acc:91.2%, Test_loss:0.212, Lr:1.00E-04
Epoch:10, Train_acc:96.1%, Train_loss:0.091, Test_acc:97.9%, Test_loss:0.070, Lr:1.00E-04
Epoch:11, Train_acc:96.4%, Train_loss:0.108, Test_acc:89.6%, Test_loss:0.267, Lr:1.00E-04
Epoch:12, Train_acc:95.1%, Train_loss:0.119, Test_acc:97.1%, Test_loss:0.105, Lr:1.00E-04
Epoch:13, Train_acc:98.0%, Train_loss:0.038, Test_acc:99.2%, Test_loss:0.029, Lr:1.00E-04
Epoch:14, Train_acc:97.7%, Train_loss:0.068, Test_acc:99.2%, Test_loss:0.026, Lr:1.00E-04
Epoch:15, Train_acc:99.1%, Train_loss:0.027, Test_acc:99.6%, Test_loss:0.017, Lr:1.00E-04
Epoch:16, Train_acc:99.5%, Train_loss:0.013, Test_acc:98.8%, Test_loss:0.089, Lr:1.00E-04
Epoch:17, Train_acc:99.3%, Train_loss:0.024, Test_acc:99.2%, Test_loss:0.030, Lr:1.00E-04
Epoch:18, Train_acc:96.9%, Train_loss:0.105, Test_acc:92.5%, Test_loss:0.212, Lr:1.00E-04
Epoch:19, Train_acc:97.5%, Train_loss:0.063, Test_acc:97.1%, Test_loss:0.113, Lr:1.00E-04
Epoch:20, Train_acc:97.5%, Train_loss:0.061, Test_acc:90.0%, Test_loss:0.322, Lr:1.00E-04
Epoch:21, Train_acc:96.1%, Train_loss:0.113, Test_acc:98.3%, Test_loss:0.066, Lr:1.00E-04
Epoch:22, Train_acc:99.3%, Train_loss:0.021, Test_acc:98.8%, Test_loss:0.026, Lr:1.00E-04
Epoch:23, Train_acc:97.4%, Train_loss:0.058, Test_acc:93.8%, Test_loss:0.222, Lr:1.00E-04
Epoch:24, Train_acc:99.2%, Train_loss:0.021, Test_acc:98.3%, Test_loss:0.042, Lr:1.00E-04
Epoch:25, Train_acc:98.4%, Train_loss:0.048, Test_acc:97.9%, Test_loss:0.073, Lr:1.00E-04
Epoch:26, Train_acc:99.1%, Train_loss:0.036, Test_acc:99.2%, Test_loss:0.023, Lr:1.00E-04
Epoch:27, Train_acc:99.8%, Train_loss:0.010, Test_acc:97.5%, Test_loss:0.085, Lr:1.00E-04
Epoch:28, Train_acc:98.5%, Train_loss:0.036, Test_acc:97.5%, Test_loss:0.064, Lr:1.00E-04
Epoch:29, Train_acc:99.7%, Train_loss:0.012, Test_acc:100.0%, Test_loss:0.009, Lr:1.00E-04
Epoch:30, Train_acc:99.6%, Train_loss:0.011, Test_acc:97.9%, Test_loss:0.076, Lr:1.00E-04
Epoch:31, Train_acc:90.6%, Train_loss:0.312, Test_acc:93.3%, Test_loss:0.242, Lr:1.00E-04
Epoch:32, Train_acc:95.5%, Train_loss:0.136, Test_acc:97.9%, Test_loss:0.066, Lr:1.00E-04
Epoch:33, Train_acc:99.2%, Train_loss:0.033, Test_acc:97.5%, Test_loss:0.070, Lr:1.00E-04
Epoch:34, Train_acc:98.6%, Train_loss:0.033, Test_acc:98.8%, Test_loss:0.033, Lr:1.00E-04
Epoch:35, Train_acc:99.2%, Train_loss:0.015, Test_acc:99.2%, Test_loss:0.020, Lr:1.00E-04
Epoch:36, Train_acc:99.6%, Train_loss:0.011, Test_acc:99.2%, Test_loss:0.030, Lr:1.00E-04
Epoch:37, Train_acc:99.6%, Train_loss:0.021, Test_acc:99.2%, Test_loss:0.015, Lr:1.00E-04
Epoch:38, Train_acc:99.3%, Train_loss:0.024, Test_acc:97.9%, Test_loss:0.045, Lr:1.00E-04
Epoch:39, Train_acc:99.6%, Train_loss:0.013, Test_acc:99.2%, Test_loss:0.017, Lr:1.00E-04
Epoch:40, Train_acc:99.8%, Train_loss:0.007, Test_acc:97.1%, Test_loss:0.092, Lr:1.00E-04
Done

显示结果


import matplotlib.pyplot as plt
#隐藏警告
import warnings
warnings.filterwarnings("ignore")               #忽略警告信息
plt.rcParams['font.sans-serif']    = ['SimHei'] # 用来正常显示中文标签
plt.rcParams['axes.unicode_minus'] = False      # 用来正常显示负号
plt.rcParams['figure.dpi']         = 100        #分辨率

epochs_range = range(epochs)

plt.figure(figsize=(12, 3))
plt.subplot(1, 2, 1)

plt.plot(epochs_range, train_acc, label='Training Accuracy')
plt.plot(epochs_range, test_acc, label='Test Accuracy')
plt.legend(loc='lower right')
plt.title('Training and Validation Accuracy')

plt.subplot(1, 2, 2)
plt.plot(epochs_range, train_loss, label='Training Loss')
plt.plot(epochs_range, test_loss, label='Test Loss')
plt.legend(loc='upper right')
plt.title('Training and Validation Loss')
plt.show()

在这里插入图片描述

使用模型预测

from PIL import Image

classes = list(total_data.class_to_idx)

def predict_one_image(image_path, model, transform, classes):

    test_img = Image.open(image_path).convert('RGB')
    plt.imshow(test_img)  # 展示预测的图片

    test_img = transform(test_img)
    img = test_img.to(device).unsqueeze(0)

    model.eval()
    output = model(img)

    _,pred = torch.max(output,1)
    pred_class = classes[pred]
    print(f'预测结果是：{pred_class}')

# 预测训练集中的某张照片
predict_one_image(image_path=r'C:\Users\11054\Desktop\kLearning\p7_learning\data\Green\green (1).png',
                  model=model,
                  transform=train_transforms,
                  classes=classes)

预测结果是：Green

在这里插入图片描述

模型评估

best_model.eval()
epoch_test_acc, epoch_test_loss = test(test_dl, best_model, loss_fn)
epoch_test_acc, epoch_test_loss

(1.0, 0.010856887987756636)

个人总结

Adam优化器表现明显优于SGD

无涯学徒1998
关注
  • 3
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
面试阿里P7需要掌握的技术.md
07-22
面试阿里P7需要掌握的技术
Android-Architecture-knowledge-2-:阿里P7移动架构师学习路线
03-18
Android架构知识-2-阿里P7移动架构师学习路线 Android开发者技术交流群领取最新Android架构进阶教学视频+ BATJ面试专题PDF +学习笔记入口：点击链接加入群聊【Android Framework高级技术】： ://jq.qq....
PyTorch预训练和微调：以VGG16为例
阿正的梦工坊
07-12 1497
加载vgg16预训练模型，进行CIFAR10图片分类
P8-YOLOv5-C3模块实现
m0_63880699的博客
03-16 2088
YOLO5 C3模块实现
YOLOv5 Focus C3 各模块详解及代码实现
热门推荐
偶尔想看云飞的博客
11-03 4万+
关于yolov5的参数的讲解
P8：Pytorch实战：YOLOv5-C3模块实现
weixin_62602550的博客
06-17 1664
YOLOv5 是一种常见的目标检测算法和架构，它基于之前的 YOLO（You Only Look Once）模型进行改进和扩展。最后，经过一系列的瓶颈块之后，两个特征张量被拼接在一起，并通过一个1x1卷积层来融合它们。这样，C3模块的输出特征张量就得到了，可以继续用于后续的处理，例如目标检测头部的操作。它通过使用瓶颈块和1x1卷积层的组合来实现这一目标，并在保持计算效率的同时提高了模型的性能。在YOLOv5中，C3模块是一种重要的组件，它是一种CSP（Cross Stage Partial）瓶颈块。
365天深度学习训练营-第P8周：YOLOv5-C3模块实现
m0_54827939的博客
09-15 1608
总结起来，YOLOv5-C3模块通过多尺度特征融合技术和跨通道信息传递机制来提高特征图的表达能力，进而提升YOLOv5模型的性能和准确性。YOLOv5-C3模块是YOLOv5网络中的一个重要组成部分，其主要作用是增加网络的深度和感受野，提高特征提取的能力。在每个Conv模块之间，还加入了BN层和LeakyReLU激活函数，以提高模型的稳定性和泛化性能。构建C3组成的模块，并将其整合。编写训练函数和测试函数。处理数据并划分数据集。
C8051F020学习笔记-IO初始化
07-01
在C8051F020微控制器的学习过程中，IO初始化是一个重要的环节，它涉及到对微控制器的I/O端口进行配置，以便用于不同功能的实现。C8051F020是一个高度集成的混合信号片上系统，具有64个8位数字I/O引脚，分布在P0到P7...
Guillaume_Bellanger_p7_21032021
03-28
考虑到压缩包内的文件名为“Guillaume_Bellanger_p7_21032021-master”，这通常表明这是一个GitHub仓库的克隆，可能包含了源代码、示例、笔记或其他学习资源。"master"分支是GitHub仓库的默认分支，通常包含项目的...
Openclassroom_P7_30_01_2021
02-10
在"Openclassroom_P7_30_01_2021-main"这个文件中，我们可能会找到以下学习资源： 1. 教程文档：这些文档可能详细介绍了JavaScript的基本概念，包括变量、数据类型、运算符、流程控制等，并逐步引导学习者理解更...
易语言训练和调用yolov5——3（3份）
06-30
配套视频教程地址 https://www.bilibili.com/video/av73849419/ 作者出教程不易 禁转载下载 CSDN付费下载 包手把手教会易语言部署和调用深度学习训练
yolov5c3模块
a05170929的博客
05-12 1426
🍦 参考文章：Pytorch实战 | 第P8周：yolov5c3模块。🍨 本文为🔗365天深度学习训练营 中的学习记录博客。🍖 原作者：K同学啊|接辅导、项目定制。二、搭建包含C3模块的模型¶。
记录yolov5目标检测算法学习（主要模块学习之c3模块）23/10/15
这个博主不懒，但Ta什么也没写~（私信互关24小时必回）
10-15 1316
本篇介绍yolov5模型中的c3模块
p8 YOLOv5-C3模块实现
tjl521314_21的博客
01-04 862
YOLOv5C3模块是YOLOv5目标检测算法中的一个模块。它是YOLOv5的骨干网络中的一部分，用于提取图像特征。该模块的主要作用是将输入的特征图进行卷积操作，以提取更高级别的特征。YOLOv5C3模块由Conv模块、Bottleneck模块和C3模块组成1。其中，Conv模块是卷积层，Bottleneck模块是残差块，C3模块是一种特殊的残差块，它可以在不增加计算量的情况下提高模型的性能。通过这周的学习对YOLOV5的C3模块有了简单了解，为后续学习奠定基础。
YOLOv5改进——使用深度可分离卷积轻量化C3
python_plus的博客
02-23 1万+
YOLOv5改进——使用深度可分离卷积轻量化C3
【目标检测】YOLOv5 网络结构，bottleneckCSP 与 C3 模块图解
最新发布
Jiangnan_Cai的博客
03-29 5891
YOLOv5 作为 YOLO 家族的第五个版本，本身也演进了几个子版本，现在网上的资料都没有标注具体是哪个子版本的，导致不同文章之间各种混乱，像是盲人摸象。其实官方的里对各个版本的变动其实都讲得非常清楚了。下面简单说一下各版本用到的模块：V1.0版本V2.0版本在V1.0版本基础上删去nn.Conv2d，并且Detect指定为17, 20, 23层输出。V4.0版本用C3代替了BottleneckCSP，而其他的结构不变。CBL 也换成了 CBS，使用 SiLU 作为激活函数。
YOLOv5+Swin Transformer
m0_60461719的博客
10-30 5457
YOLOv5＋swin tansformer里遇到的报错
【Week-P8】YOLOv5-C3模块实现天气识别
qq_40724911的博客
02-22 946
增加C3模块，forward()函数内部无变化C3模块个数test_acc187.1%291.6%392.0%增加C3模块，forward()函数内部也相应增加C3模块C3模块个数test_acc187.1%23。
在YOLOv5中添加Swin-Transformer模块
YanHS_的博客
02-09 1万+
提供了一个在YOLOv5代码中添加SwinTransformer相应模块的代码仓库，并对使用方法进行了简单介绍。
海量数据大课学习笔记.pdf
11-27
"海量数据大课学习笔记.pdf"是一份关于大数据处理和管理的学习资料，涵盖了丰富的课程内容。笔记中提到了以下几个关键知识点： 1. 数据处理技术：文档中提到的"୮leader敖॒"和"梵布拉ṛ̵ᙎᐥ̵ॹᰂ"可能是指高级...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值