深度集成学习不均衡样本图像分类

Secede.2025-04-09 13:06

用五个不同的网络，然后对分类概率进行平均，得到分类结果。基本上分类精度可以提升10%

1.导入基本库

python 复制代码 
import torch
import copy
import torch.nn as nn
import torchvision.models as models
from torchvision import datasets
from torchvision import transforms
from tqdm import tqdm
from torch.utils.data import DataLoader
from torch.utils.data import random_split
from transformers import AutoModelForImageClassification,AutoConfig

2.数据集准备

python 复制代码 
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
# 数据预处理
transform = transforms.Compose([
    transforms.Resize((224, 224)),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),  
])

train_dataset = datasets.ImageFolder(root='./aug_datasets1', transform=transform)
dataset_size  = len(train_dataset)

train_size = int(0.8 * dataset_size)
val_size = dataset_size - train_size

train_dataset, val_dataset = random_split(train_dataset, [train_size, val_size])


train_dataloader = DataLoader(train_dataset, batch_size=32, shuffle=True)
val_dataloader = DataLoader(val_dataset, batch_size=32, shuffle=False)

3.定义不同模型与对应的训练策略

模型1 ResNet

python 复制代码 
class ResNet(nn.Module):
    def __init__(self, num_classes=21,train=True):
        super(ResNet, self).__init__()
        if(train):
            self.resnet = models.resnet50(weights=torchvision.models.ResNet50_Weights.IMAGENET1K_V1)
        else:
            self.resnet = models.resnet50(weights=None)
        in_features = self.resnet.fc.in_features
        self.resnet.fc = nn.Sequential(
            nn.Linear(in_features, 512),
            nn.ReLU(inplace=True),
            nn.Dropout(0.5),
            nn.Linear(512, num_classes)
        )
        self.resnet.to(device)
    def forward(self, x):
        return self.resnet(x)

    # 训练策略
    def startTrain(self, train_loader, val_loader):
        criterion = nn.CrossEntropyLoss()
        optimizer = torch.optim.AdamW(self.parameters(), lr=1e-4, weight_decay=1e-4)
        scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=50)
        Best_Acc = 0.0
        print("Training ResNet.....")
        for epoch in range(10):  # 训练 10 个 epoch
            self.train()
            train_loss = 0
            for batch in tqdm(train_loader):
                images, labels = batch
                images, labels = images.to(device), labels.to(device)
                
                optimizer.zero_grad()
                # 处理图像并将其传递给模型
                logits = self(images)

                # 计算损失并进行反向传播
                loss = criterion(logits, labels)
                loss.backward()
                optimizer.step()
                

                train_loss += loss.item()
            print(f"Epoch {epoch+1}/{10}, Train Loss: {train_loss/len(train_loader)}")
            scheduler.step()
            self.eval()
            val_loss = 0
            correct = 0
            total = 0

            with torch.no_grad():
                for batch in tqdm(val_loader):
                    images, labels = batch
                    images, labels = images.to(device), labels.to(device)

                    # 处理图像并传递给模型
                    logits = self(images)

                    # 计算损失
                    loss = criterion(logits, labels)
                    val_loss += loss.item()

                    # 计算准确率
                    _, predicted = torch.max(logits, 1)
                    total += labels.size(0)
                    correct += (predicted == labels).sum().item()

            print(f"Validation Loss: {val_loss/len(val_loader)}")
            print(f"Accuracy: {100 * correct / total}%")
            if(100 * correct / total > Best_Acc):
                Best_Acc = 100 * correct / total
                torch.save(self.state_dict(), './saved/resnet/model_weights_{}.pth'.format(Best_Acc))

模型2 EfficientNet

python 复制代码 
class EfficientNet(nn.Module):
    def __init__(self, num_classes=21,train=True):
        super(EfficientNet, self).__init__()
        if(train):
            self.effnet = models.efficientnet_b2(weights=torchvision.models.EfficientNet_B2_Weights.IMAGENET1K_V1)
        else:
            self.effnet = models.efficientnet_b2(weights=None)
        
        in_features = self.effnet.classifier[1].in_features
        self.effnet.classifier = nn.Sequential(
            nn.Linear(in_features, 512),
            nn.ReLU(inplace=True),
            nn.Dropout(0.5),
            nn.Linear(512, num_classes)
        )
        self.effnet.to(device)
    def forward(self, x):
        return self.effnet(x)

    # 训练策略
    def startTrain(self, train_loader, val_loader):
        # 焦点损失，gamma参数增强对少数类的关注
        criterion = nn.CrossEntropyLoss()
        optimizer = torch.optim.AdamW(self.parameters(), lr=1e-4, weight_decay=1e-4)
        scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, patience=5)
        Best_Acc = 0.0
        print("Training EfficientNet.....")
        for epoch in range(10):  # 训练 10 个 epoch
            self.train()
            train_loss = 0
            for batch in tqdm(train_loader):
                images, labels = batch
                images, labels = images.to(device), labels.to(device)

                optimizer.zero_grad()
                # 处理图像并将其传递给模型
                logits = self(images)
                
                # 计算损失并进行反向传播
                loss = criterion(logits, labels)
                loss.backward()
                optimizer.step()
                

                train_loss += loss.item()
            print(f"Epoch {epoch+1}/{10}, Train Loss: {train_loss/len(train_loader)}")
            scheduler.step(train_loss/len(train_loader))
            self.eval()
            val_loss = 0
            correct = 0
            total = 0

            with torch.no_grad():
                for batch in tqdm(val_loader):
                    images, labels = batch
                    images, labels = images.to(device), labels.to(device)

                    # 处理图像并传递给模型
                    logits = self(images)

                    # 计算损失
                    loss = criterion(logits, labels)
                    val_loss += loss.item()

                    # 计算准确率
                    _, predicted = torch.max(logits, 1)
                    total += labels.size(0)
                    correct += (predicted == labels).sum().item()

            print(f"Validation Loss: {val_loss/len(val_loader)}")
            print(f"Accuracy: {100 * correct / total}%")
            if(100 * correct / total > Best_Acc):
                Best_Acc = 100 * correct / total
                torch.save(self.state_dict(), './saved/efficientnet/model_weights_{}.pth'.format(Best_Acc))

模型3 DenseNet

python 复制代码 
class DenseNet(nn.Module):
    def __init__(self, num_classes=21, train=True):
        super(DenseNet, self).__init__()
        self.num_classes = num_classes
        if(train):
            self.densenet = models.densenet121(weights=torchvision.models.DenseNet121_Weights.IMAGENET1K_V1)
        else:
            self.densenet = models.densenet121(weights=None) 
        
        in_features = self.densenet.classifier.in_features
        self.densenet.classifier = nn.Sequential(
            nn.BatchNorm1d(in_features),
            nn.Linear(in_features, 512),
            nn.ReLU(inplace=True),
            nn.Dropout(0.5),
            nn.Linear(512, num_classes)
        )
        self.densenet.to(device)
    def forward(self, x):
        return self.densenet(x)

    # 训练策略
    def startTrain(self, train_loader, val_loader):
        
        criterion = nn.CrossEntropyLoss()
        optimizer = torch.optim.Adam(self.parameters(), lr=1e-4)
        scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=50)
        Best_Acc = 0.0
        print("Training DenseNet.....")
        for epoch in range(10):  # 训练 10 个 epoch
            self.train()
            train_loss = 0
            for batch in tqdm(train_loader):
                images, labels = batch
                images, labels = images.to(device), labels.to(device)

                optimizer.zero_grad()
                # 处理图像并将其传递给模型
                logits = self(images)

                # 计算损失并进行反向传播
                loss = criterion(logits, labels)
                loss.backward()
                optimizer.step()
                

                train_loss += loss.item()
            print(f"Epoch {epoch+1}/{10}, Train Loss: {train_loss/len(train_loader)}")
            scheduler.step()
            self.eval()
            val_loss = 0
            correct = 0
            total = 0

            with torch.no_grad():
                for batch in tqdm(val_loader):
                    images, labels = batch
                    images, labels = images.to(device), labels.to(device)

                    # 处理图像并传递给模型
                    logits = self(images)

                    # 计算损失
                    loss = criterion(logits, labels)
                    val_loss += loss.item()

                    # 计算准确率
                    _, predicted = torch.max(logits, 1)
                    total += labels.size(0)
                    correct += (predicted == labels).sum().item()

            print(f"Validation Loss: {val_loss/len(val_loader)}")
            print(f"Accuracy: {100 * correct / total}%")
            if(100 * correct / total > Best_Acc):
                Best_Acc = 100 * correct / total
                torch.save(self.state_dict(), './saved/densenet/model_weights_{}.pth'.format(Best_Acc))

模型4 ResNeXt

python 复制代码 
class ResNeXt(nn.Module):

    def __init__(self, num_classes=21,train=True):
        super(ResNeXt, self).__init__()
        if(train):
            self.resnext50 = models.resnext50_32x4d(weights=torchvision.models.ResNeXt50_32X4D_Weights.IMAGENET1K_V1)
        else:
            self.resnext50 = models.resnext50_32x4d(weights=None)
        
        in_features = self.resnext50.fc.in_features
        self.resnext50.fc = nn.Sequential(
            nn.BatchNorm1d(in_features),
            nn.Linear(in_features, 512),
            nn.ReLU(inplace=True),
            nn.Dropout(0.5),
            nn.Linear(512, num_classes)
        )
        self.resnext50.to(device)
              
        self.to(device)
    def forward(self, x):
        return self.resnext50(x)

    def startTrain(self, train_loader, val_loader):
        
        optimizer = torch.optim.AdamW(self.parameters(), lr=1e-4)
        scheduler = torch.optim.lr_scheduler.OneCycleLR(optimizer, max_lr=5e-4, epochs=30, steps_per_epoch=len(train_loader))        
        criterion = nn.CrossEntropyLoss()
        Best_Acc = 0.0
        print("Training ResNeXt.....")
        for epoch in range(10):  # 训练 10 个 epoch
            self.train()
            train_loss = 0
            for batch in tqdm(train_loader):
                images, labels = batch
                images, labels = images.to(device), labels.to(device)

                optimizer.zero_grad()
                # 处理图像并将其传递给模型
                logits = self(images)

                # 计算损失并进行反向传播
                loss = criterion(logits, labels)
                loss.backward()
                optimizer.step()

                train_loss += loss.item()
            print(f"Epoch {epoch+1}/{10}, Train Loss: {train_loss/len(train_loader)}")
            scheduler.step(train_loss/len(train_loader))
            self.eval()
            val_loss = 0
            correct = 0
            total = 0

            with torch.no_grad():
                for batch in tqdm(val_loader):
                    images, labels = batch
                    images, labels = images.to(device), labels.to(device)

                    # 处理图像并传递给模型
                    logits = self(images)

                    # 计算损失
                    loss = criterion(logits, labels)
                    val_loss += loss.item()

                    # 计算准确率
                    _, predicted = torch.max(logits, 1)
                    total += labels.size(0)
                    correct += (predicted == labels).sum().item()

            print(f"Validation Loss: {val_loss/len(val_loader)}")
            print(f"Accuracy: {100 * correct / total}%")
            if(100 * correct / total > Best_Acc):
                Best_Acc = 100 * correct / total
                torch.save(self.state_dict(), './saved/se-resnext/model_weights_{}.pth'.format(Best_Acc))

模型5 SwinTransformer

python 复制代码 
class SwinTransformer(nn.Module):
    def __init__(self, num_classes=21,train=True):
        super(SwinTransformer, self).__init__()
        if(train):
            self.vit = AutoModelForImageClassification.from_pretrained('./swinv2-tiny-patch4-window16-256/models--microsoft--swinv2-tiny-patch4-window16-256/snapshots/f4d3075206f2ad5eda586c30d6b4d0500f312421/')   
            #这个地方怎么写加载模型
            self.vit.classifier = nn.Sequential(
                nn.Dropout(0.5),
                nn.Linear(self.vit.classifier.in_features, num_classes)
            )
            # 冻结Swin Transformer模型中的所有层
            for param in self.vit.parameters():
                param.requires_grad = False        
            
            # 只解冻最后两个Transformer块和分类头
            for param in self.vit.swinv2.encoder.layers[-4:].parameters():  # 假设你想解冻最后两层
                param.requires_grad = True
            for param in self.vit.classifier.parameters():
                param.requires_grad = True
        else:
            # 先加载 config，然后手动修改 num_labels
            config = AutoConfig.from_pretrained('./saved/swin-transformer/')
            config.num_labels = 21
            self.vit = AutoModelForImageClassification.from_pretrained('./saved/swin-transformer/',config=config)   
        self.vit.to(device)
        
    def forward(self, x):
        return self.vit(x)

    # 训练策略
    def startTrain(self, train_loader, val_loader):
        # 使用标签平滑处理，考虑到类别是连续尺度
        criterion = nn.CrossEntropyLoss()
        # 两阶段训练策略
        # 阶段1: 只训练解冻的层
        num_epochs_stage1 = 10
        num_epochs_stage2 = 10
        optimizer_stage1 = torch.optim.AdamW([p for p in self.parameters() if p.requires_grad], lr=1e-3)

        scheduler_stage1 = torch.optim.lr_scheduler.OneCycleLR(
            optimizer_stage1, max_lr=1e-3, epochs=num_epochs_stage1, steps_per_epoch=len(train_loader)
        )
        best_model_wts = copy.deepcopy(self.state_dict())
        print("Training SwinTransformer.....") 
        print("===== Stage 1 Training =====")
        Best_Acc = 0.0
        for epoch in range(num_epochs_stage1):  # 训练 10 个 epoch
            self.train()
            train_loss = 0
            for batch in tqdm(train_loader):
                images, labels = batch
                images, labels = images.to(device), labels.to(device)

                optimizer_stage1.zero_grad()
                # 处理图像并将其传递给模型
                outputs = self(images)
                logits = outputs.logits

                # 计算损失并进行反向传播
                loss = criterion(logits, labels)
                loss.backward()
                optimizer_stage1.step()


                train_loss += loss.item()
            print(f"Epoch {epoch+1}/{10}, Train Loss: {train_loss/len(train_loader)}")
            scheduler_stage1.step()
            self.eval()
            val_loss = 0
            correct = 0
            total = 0

            with torch.no_grad():
                for batch in tqdm(val_loader):
                    images, labels = batch
                    images, labels = images.to(device), labels.to(device)

                    # 处理图像并传递给模型
                    outputs = self(images)
                    logits = outputs.logits

                    # 计算损失
                    loss = criterion(logits, labels)
                    val_loss += loss.item()

                    # 计算准确率
                    _, predicted = torch.max(logits, 1)
                    total += labels.size(0)
                    correct += (predicted == labels).sum().item()

            print(f"Validation Loss: {val_loss/len(val_loader)}")
            print(f"Accuracy: {100 * correct / total}%")
            if(100 * correct / total > Best_Acc):
                Best_Acc = 100 * correct / total
                best_model_wts = copy.deepcopy(self.state_dict())
                self.vit.save_pretrained('./saved/swin-transformer/', safe_serialization=False)       
        
        # 阶段1结束后加载最佳模型权重
        self.load_state_dict(best_model_wts)    
        Best_Acc = 0.0
        print("===== Stage 2 Training =====")
        # 阶段2: 微调整个网络
        for param in self.parameters():
            param.requires_grad = True
        optimizer_stage2 = torch.optim.Adam(self.parameters(), lr=1e-6)
        scheduler_stage2 = torch.optim.lr_scheduler.OneCycleLR(
            optimizer_stage2, max_lr=5e-6, epochs=num_epochs_stage2, steps_per_epoch=len(train_loader)
        )
        for epoch in range(num_epochs_stage2):  # 训练 10 个 epoch
            self.train()
            train_loss = 0
            for batch in tqdm(train_loader):
                images, labels = batch
                images, labels = images.to(device), labels.to(device)

                optimizer_stage2.zero_grad()
                # 处理图像并将其传递给模型
                outputs = self(images)
                logits = outputs.logits

                # 计算损失并进行反向传播
                loss = criterion(logits, labels)
                loss.backward()
                optimizer_stage2.step()
                

                train_loss += loss.item()
            print(f"Epoch {epoch+1}/{10}, Train Loss: {train_loss/len(train_loader)}")
            scheduler_stage2.step()
            self.eval()
            val_loss = 0
            correct = 0
            total = 0

            with torch.no_grad():
                for batch in tqdm(val_loader):
                    images, labels = batch
                    images, labels = images.to(device), labels.to(device)

                    # 处理图像并传递给模型
                    outputs = self(images)
                    logits = outputs.logits

                    # 计算损失
                    loss = criterion(logits, labels)
                    val_loss += loss.item()

                    # 计算准确率
                    _, predicted = torch.max(logits, 1)
                    total += labels.size(0)
                    correct += (predicted == labels).sum().item()

            print(f"Validation Loss: {val_loss/len(val_loader)}")
            print(f"Accuracy: {100 * correct / total}%")
            if(100 * correct / total > Best_Acc):
                Best_Acc = 100 * correct / total
                self.vit.save_pretrained('./saved/swin-transformer/', safe_serialization=False)

4.分别训练，然后得到权重

python 复制代码 
    swinTransformer= SwinTransformer()
    swinTransformer.startTrain(train_dataloader,val_dataloader)
      
    efficientNet= EfficientNet()
    efficientNet.startTrain(train_dataloader,val_dataloader)

    resNet= ResNet()
    resNet.startTrain(train_dataloader,val_dataloader)
    
    resNeXt= ResNeXt()
    resNeXt.startTrain(train_dataloader,val_dataloader)
    
    denseNet= DenseNet()
    denseNet.startTrain(train_dataloader,val_dataloader)

5.构建集成分类模型

python 复制代码 
import torch
import torchvision.transforms as transforms
import torch.nn as nn
from torchvision import datasets
from torchvision import transforms
from tqdm import tqdm
from torch.utils.data import DataLoader
from torch.utils.data import random_split
from tqdm import tqdm
from PIL import Image

def remove_prefix_from_state_dict(state_dict, prefix='resnext.'):
    return {"resnext50." + k[len(prefix):] if k.startswith(prefix) else k: v for k, v in state_dict.items()}


# 定义集成模型
class EnsembleModel():
    def __init__(self, efficientNet, resNet, resNeXt, denseNet,swinTransformer):
        super(EnsembleModel, self).__init__()

        self.efficientNet= efficientNet.eval()
        self.resNet= resNet.eval()
        self.resNeXt= resNeXt.eval()
        self.denseNet= denseNet.eval()
        self.swinTransformer= swinTransformer.eval()

    def predict(self, x):
        efficientNet_out = torch.softmax(self.efficientNet(x),dim=1)
        resNet_out = torch.softmax(self.resNet(x),dim=1)
        resNeXt_out = torch.softmax(self.resNeXt(x),dim=1)
        denseNet_out = torch.softmax(self.denseNet(x),dim=1)
        swinTransformer_out = torch.softmax(self.swinTransformer(x).logits,dim=1)
        avg_pred = (efficientNet_out + resNet_out + resNeXt_out + denseNet_out + swinTransformer_out ) / 5
        return avg_pred

这样就可以提升性能

相关推荐
WWZZ20254 小时前
快速上手大模型：机器学习3（多元线性回归及梯度、向量化、正规方程）
人工智能·算法·机器学习·机器人·slam·具身感知
晓枫-迷麟7 小时前
【文献阅读】当代MOF与机器学习
人工智能·机器学习
来酱何人8 小时前
实时NLP数据处理：流数据的清洗、特征提取与模型推理适配
人工智能·深度学习·分类·nlp·bert
sensen_kiss8 小时前
INT301 Bio-computation 生物计算（神经网络）Pt.3 梯度下降与Sigmoid激活函数
人工智能·神经网络·机器学习
Shilong Wang8 小时前
MLE, MAP, Full Bayes
人工智能·算法·机器学习
Theodore_10228 小时前
机器学习（6）特征工程与多项式回归
深度学习·算法·机器学习·数据分析·多项式回归
Blossom.1188 小时前
把AI“刻”进玻璃：基于飞秒激光量子缺陷的随机数生成器与边缘安全实战
人工智能·python·单片机·深度学习·神经网络·安全·机器学习
Aurora-silas9 小时前
LLM微调尝试——MAC版
人工智能·pytorch·深度学习·macos·机器学习·语言模型·自然语言处理
安於宿命12 小时前
【machine learning】COVID-19 daily cases prediction
人工智能·机器学习
razelan13 小时前
第一例：石头剪刀布的机器学习（xedu，示例15）
人工智能·机器学习
热门推荐
01GitHub 镜像站点02BongoCat - 跨平台键盘猫动画工具03UV安装并设置国内源04Linux下V2Ray安装配置指南05GitLab 零基础入门指南：从安装到项目管理全流程06NVIDIA显卡驱动、CUDA、cuDNN 和 TensorRT 版本匹配指南07一文了解国产算子编程语言 TileLang，TileLang 对国产开源生态的影响与启示082025软件测试面试八股文（含答案+文档）09在VSCode配置Java开发环境的保姆级教程（适配各类AI编程IDE）10Labelme从安装到标注：零基础完整指南