Pytorch搭建EfficientNet网络和Openmax

B站账号@狼群里的小杨，记得点赞收藏加关注，一键三连哦！

EfficientNet

代码

这是一个用包含40个类别的垃圾数据集做的开放场景实验。训练过程中仅使用24个训练类，测试时使用40个垃圾类别。
garbage数据集下载
首先是训练的代码。
task_garbage.py

'''
@File  :task_gabage.py
@Author:cjh
@Date  :2022/1/16 14:45
@Desc  :
'''
import random

import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F
import torch.backends.cudnn as cudnn

import torchvision
import numpy as np
import torchvision.transforms as transforms
from torchvision.transforms import autoaugment

import os
import argparse
import sys
import warnings
warnings.filterwarnings("ignore")


# os.chdir(os.path.dirname('X:/PyCharm/211211-DL-OSR/DL_OSR/model/OpenMax'))
# sys.path.append("../..")
from torch.optim import lr_scheduler

import backbones.cifar10 as models
from datasets import GARBAGE40_Dataset
from utils import adjust_learning_rate, progress_bar, Logger, mkdir_p, Evaluation

from openmax import compute_train_score_and_mavs_and_dists,fit_weibull,openmax
from Modelbuilder import Network
from Plotter import plot_feature
from garbage_transform import Resize, Cutout, RandomErasing
from garbage_loss import LabelSmoothSoftmaxCE, LabelSmoothingLoss, FocalLoss
from checkpoints import efficientnet
# from pytorch_toolbelt import losses as L

parser=argparse.ArgumentParser()
parser.add_argument('--lr',default=0.01,type=float,help='learning rate')
# ./checkpoints/garbage/ResNet/ResNet18.pth
parser.add_argument('--resume',default=None,type=str,metavar='PATH',help='path to load lastest pth')
parser.add_argument('--arch',default='EfficientNet_B5',type=str,help='choosing network')
parser.add_argument('--bs',default=8,type=int,help='batch size')
parser.add_argument('--es',default=40,type=int,help='epoches')
parser.add_argument('--train_class_num',default=24,type=int,help='classes used in training')
parser.add_argument('--test_class_num',default=40,type=int,help='classes used in testing')
parser.add_argument('--includes_all_train_class',default=True,action='store_true',
                    help='testing uses all known classes')
parser.add_argument('--embed_dim', default=2, type=int, help='embedding feature dimension')
parser.add_argument('--evaluate',default=False,action='store_true',help='evaluating')

parser.add_argument('--weibull_tail', default=20, type=int, help='Classes used in testing')
parser.add_argument('--weibull_alpha', default=5, type=int, help='Classes used in testing')
parser.add_argument('--weibull_threshold', default=0.9, type=float, help='Classes used in testing')

# Parameters for stage plotting
# parser.add_argument('--plot', default=False, action='store_true', help='Plotting the training set.')
# parser.add_argument('--plot_max', default=0, type=int, help='max examples to plot in each class, 0 indicates all.')
# parser.add_argument('--plot_quality', default=200, type=int, help='DPI of plot figure')

args=parser.parse_args()

def main():
    device = 'cuda' if torch.cuda.is_available() else 'cpu'
    print(device)
    best_acc = 0  # best test accuracy
    start_epoch = 0  # start from epoch 0 or last checkpoint epoch

    # checkpoint
    args.checkpoint = './checkpoints/garbage/' + args.arch
    if not os.path.isdir(args.checkpoint):
        mkdir_p(args.checkpoint)

    # folder to save figures
    args.plotfolder = './checkpoints/garbage/' + args.arch + '/plotter'
    if not os.path.isdir(args.plotfolder):
        mkdir_p(args.plotfolder)

    # Data
    print('==> Preparing data..')
    picture_size = 256
    train_transforms = transforms.Compose([

        Resize((int(288 * (256 / 224)), int(288 * (256 / 224)))),
        transforms.CenterCrop((picture_size, picture_size)),
        transforms.RandomAffine(degrees=0, translate=(0.05, 0.05)),
        transforms.RandomVerticalFlip(),
        autoaugment.AutoAugment(),
        transforms.ToTensor(),
        transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
        Cutout(probability=0.5, size=64, mean=[0.0, 0.0, 0.0]),
        RandomErasing(probability=0.0, mean=[0.485, 0.456, 0.406]),
    ])
    test_transforms = transforms.Compose([
        Resize((int(288 * (256 / 224)), int(288 * (256 / 224)))),
        transforms.CenterCrop((picture_size, picture_size)),
        transforms.ToTensor(),
        transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
    ])

    random.seed(42)
    train_classes = random.sample(range(0, 40), args.train_class_num)
    test_classes=train_classes+[999]

    trainset = GARBAGE40_Dataset(root='../../data/garbage', train=True,
                                 transform=train_transforms,
                     train_class_num=args.train_class_num, test_class_num=args.test_class_num,
                     includes_all_train_class=args.includes_all_train_class,
                                 train_classes=train_classes)
    testset = GARBAGE40_Dataset(root='../../data/garbage', train=False,
                                transform=test_transforms,
                    train_class_num=args.train_class_num, test_class_num=args.test_class_num,
                    includes_all_train_class=args.includes_all_train_class,
                                train_classes=train_classes)
    # data loader
    trainloader = torch.utils.data.DataLoader(trainset, batch_size=args.bs, shuffle=True, num_workers=0)
    testloader = torch.utils.data.DataLoader(testset, batch_size=args.bs, shuffle=False, num_workers=0)

    #Model
    # net=Network(backbone=args.arch,num_classes=args.train_class_num, embed_dim=args.embed_dim)
    # fea_dim = net.classifier.in_features
    # net = net.to(device)
    if args.arch=='ResNet18':
        net = torchvision.models.resnet18(pretrained=True).to(device)
        model_wight_path = "checkpoints/garbage/ResNet18/best_model.pth"
        assert os.path.exists(model_wight_path), "file {} dose not exist.".format(model_wight_path)  # 若路径不存在，则打印信息
        net.load_state_dict(torch.load(model_wight_path, map_location=device), strict=False)
        net.fc = nn.Sequential(
            nn.Linear(net.fc.in_features, 256),
            nn.ReLU(),
            nn.Dropout(0.4),
            nn.Linear(256, args.train_class_num)
        )

    if args.arch == 'ResNet50':
        net = torchvision.models.resnet50(pretrained=True).to(device)
        model_wight_path = "checkpoints/garbage/ResNet50/best_model.pth"
        assert os.path.exists(model_wight_path), "file {} dose not exist.".format(model_wight_path)  # 若路径不存在，则打印信息
        net.load_state_dict(torch.load(model_wight_path, map_location=device), strict=False)
        net.fc = nn.Sequential(
            nn.Linear(net.fc.in_features, 256),
            nn.ReLU(),
            nn.Dropout(0.4),
            nn.Linear(256, args.train_class_num)
        )
    if args.arch == 'EfficientNet_B5':
        # net = torchvision.models.efficientnet_b5(pretrained=True).to(device)
        net = efficientnet.efficientnet_b5().to(device)
        # model_wight_path = "checkpoints/garbage/EfficientNet_B5/efficientnetb5.pth"
        model_wight_path = "checkpoints/garbage/EfficientNet_B5/best_model.pth"
        assert os.path.exists(model_wight_path), "file {} dose not exist.".format(model_wight_path)  # 若路径不存在，则打印信息
        net.load_state_dict(torch.load(model_wight_path, map_location=device), strict=False)
        net.classifier= nn.Sequential(
            nn.Dropout(p=0.4, inplace=True),
            nn.Linear(2048, args.train_class_num),
        )
    if args.arch == 'EfficientNet_B7':
        # net = torchvision.models.efficientnet_b7(pretrained=True).to(device)
        net = efficientnet.efficientnet_b7().to(device)
        net.classifier= nn.Sequential(
            nn.Dropout(p=0.4, inplace=True),
            nn.Linear(2048, args.train_class_num),
        )
    if args.arch == 'ResNext101_32x16d_wsl':
        net = torch.hub.load('facebookresearch/WSL-Images', 'resnext101_32x16d_wsl')
        net.fc = nn.Sequential(
            nn.Dropout(0.2),
            nn.Linear(2048, args.train_class_num)
        )


    if args.arch == 'Resnext101_32x8d_wsl':
        net = torch.hub.load('facebookresearch/WSL-Images', 'resnext101_32x8d_wsl')
        net.fc = nn.Sequential(
            nn.Dropout(0.2),
            nn.Linear(2048, args.train_class_num)
        )
    if args.arch == 'Resnext50_32x4d':
        net = torchvision.models.resnext50_32x4d(pretrained=True).to(device)
        net.fc = nn.Sequential(
            nn.Dropout(0.2),
            nn.Linear(2048, args.train_class_num)
        )
    # from efficientnet_pytorch import EfficientNet
    # model = EfficientNet.from_pretrained('efficientnet-b0')
    # model = EfficientNet.from_pretrained(,num_classes=args.train_class_num)
    if args.arch == 'EfficientNet_B3':
        net = torchvision.models.efficientnet_b3(pretrained=True).to(device)
        net.classifier= nn.Sequential(
            nn.Linear(1536, 256),
            nn.ReLU(),
            nn.Dropout(p=0.4),
            nn.Linear(256, args.train_class_num),

            # nn.Dropout(p=0.4, inplace=True),
            # nn.Linear(1024, args.train_class_num),
        )

    if device == 'cuda':
        net = torch.nn.DataParallel(net)
        cudnn.benchmark = True
    if args.resume!=None:
        # Load checkpoint.
        if os.path.isfile(args.resume):
            print('==> Resuming from checkpoint..')

            #for cpu load cuda model
            checkpoint = torch.load(args.resume,map_location=torch.device('cpu'))
            net.load_state_dict({k.replace('module.', ''): v for k, v in checkpoint['net'].items()})

            #for gpu load cuda model for cpu load cpu model
            # checkpoint = torch.load(args.resume)
            # net.load_state_dict(checkpoint['net'])


            # best_acc = checkpoint['acc']
            # print("BEST_ACCURACY: "+str(best_acc))
            start_epoch = checkpoint['epoch']
            logger = Logger(os.path.join(args.checkpoint, 'log.txt'), resume=True)
        else:
            print("=> no checkpoint found at '{}'".format(args.resume))
    else:
        logger = Logger(os.path.join(args.checkpoint, 'log.txt'))
        logger.set_names(['Epoch', 'Learning Rate', 'Train Loss','Train Acc.', 'Test Loss', 'Test Acc.'])

    criterion = nn.CrossEntropyLoss()
    # criterion = LabelSmoothSoftmaxCE(lb_pos=0.9, lb_neg=5e-3)
    # criterion = LabelSmoothingLoss(classes=args.train_class_num, smoothing=0.1)
    # criterion = FocalLoss(alpha=0.25)


    optimizer = optim.SGD(net.parameters(), lr=args.lr, momentum=0.9, weight_decay=5e-4)
    # optimizer = optim.RAdam(net.parameters(),lr=args.lr,betas=(0.9, 0.999), eps=1e-8,weight_decay=5e-4)
    # scheduler = lr_scheduler.ReduceLROnPlateau(optimizer, mode='max', factor=0.7, patience=3, verbose=True)
    scheduler = lr_scheduler.ReduceLROnPlateau(optimizer, mode='min', factor=0.2, patience=2, verbose=False)
    scheduler = lr_scheduler.CosineAnnealingWarmRestarts(optimizer, T_0=3, T_mult=2)
    scheduler = lr_scheduler.CosineAnnealingWarmRestarts(optimizer, T_0=2, T_mult=2,eta_min = 1e-5)

    scheduler = lr_scheduler.StepLR(optimizer, step_size=8, gamma=0.5)

    # epoch=0
    best_ac=0
    if not args.evaluate:
        for epoch in range(start_epoch, args.es):
            print('\nEpoch: %d   Learning rate: %f' % (epoch+1, optimizer.param_groups[0]['lr']))
            # adjust_learning_rate(optimizer, epoch, args.lr, step=20)
            train_loss, train_acc = train(net, trainloader, optimizer, criterion, device, train_classes)
            if epoch == args.es - 1:
                save_model(net, None, epoch, os.path.join(args.checkpoint,'last_model.pth'))
            test_loss, test_acc = 0, 0
            try:
                test_loss, test_acc = test(epoch, net, trainloader, testloader, criterion, device, test_classes)
            except:
                pass
            # scheduler.step(test_loss)
            scheduler.step(train_loss)

            if best_ac<test_acc:
                best_ac=test_acc
                print("The best Acc: ",best_ac)
                # save_model(net, None, epoch, os.path.join(args.checkpoint, 'best_model.pth'))
                torch.save(net.state_dict(), os.path.join(args.checkpoint, 'best_model.pth'))
                # save_model(net, best_ac, epoch, os.path.join(args.checkpoint, 'best_model.pth'))
            #
            logger.append([epoch+1, optimizer.param_groups[0]['lr'], train_loss, train_acc, test_loss, test_acc])
            # plot_feature(net, trainloader, device, args.plotfolder,train_classes, epoch=epoch,
            #              plot_class_num=args.train_class_num, maximum=args.plot_max, plot_quality=args.plot_quality)
            # if (epoch+1)%20==0:
            #     try:
            #         test(epoch, net, trainloader, testloader, criterion, device,test_classes)
            #     except:
            #         pass
    test(99999, net, trainloader, testloader, criterion, device, test_classes)
    # plot_feature(net, testloader, device, args.plotfolder,train_classes, epoch="test",
    #              plot_class_num=args.train_class_num+1, maximum=args.plot_max, plot_quality=args.plot_quality)
    logger.close()

# Training
def train(net,trainloader,optimizer,criterion,device,train_classes):
    net.train()
    train_loss = 0
    correct = 0
    total = 0
    for batch_idx, (inputs, targets) in enumerate(trainloader):
        onehot_targets_index=[train_classes.index(i) for i in targets]
        targets=torch.LongTensor(onehot_targets_index)

        inputs, targets = inputs.to(device), targets.to(device)
        optimizer.zero_grad()
        outputs = net(inputs)

        # onehot_targets=torch.zeros((outputs.shape[0],outputs.shape[1]))
        # onehot_targets[range(outputs.shape[0]), onehot_targets_index]=1

        loss = criterion(outputs, targets)
        # loss = torch.nn.functional.cross_entropy(outputs, targets)
        loss.backward()
        optimizer.step()

        train_loss += loss.item()
        _, predicted = outputs.max(1)
        total += targets.size(0)
        correct += predicted.eq(targets).sum().item()

        progress_bar(batch_idx, len(trainloader), 'Loss: %.3f | Acc: %.3f%% (%d/%d)'
            % (train_loss/(batch_idx+1), 100.*correct/total, correct, total))
    return train_loss/(batch_idx+1), correct/total



def test(epoch, net, trainloader, testloader, criterion, device, test_classes):
    net.eval()

    test_loss = 0
    correct = 0
    total = 0

    scores, labels = [], []
    with torch.no_grad():
        for batch_idx, (inputs, targets) in enumerate(testloader):
            onehot_targets_index = [test_classes.index(i) for i in targets]
            targets = torch.LongTensor(onehot_targets_index)

            # image_2 = transforms.RandomAffine(degrees=0, translate=(0.05, 0.05))(inputs).to(device)
            # image_3 = transforms.RandomHorizontalFlip()(inputs).to(device)
            # image_4 = Cutout(probability=0.5, size=64, mean=[0.0, 0.0, 0.0])(inputs).to(device)
            # image_5 = transforms.RandomVerticalFlip()(inputs).to(device)

            inputs, targets = inputs.to(device), targets.to(device)


            # output1 = net(inputs)
            # output2 = net(image_2)
            # output3 = net(image_3)
            # output4 = net(image_4)
            # output5 = net(image_5)


            outputs = net(inputs)
            # outputs = (output1+output2+output3+output4+output5)/5


            # loss = criterion(outputs, targets)
            # test_loss += loss.item()
            _, predicted = outputs.max(1)

            scores.append(outputs)
            labels.append(targets)

            total += targets.size(0)
            correct += predicted.eq(targets).sum().item()

            progress_bar(batch_idx, len(testloader))

    # Get the prdict results.
    scores = torch.cat(scores,dim=0).cpu().numpy()
    labels = torch.cat(labels,dim=0).cpu().numpy()
    scores = np.array(scores)[:, np.newaxis, :]
    labels = np.array(labels)

    if args.train_class_num != args.test_class_num:
        # Fit the weibull distribution from training data.
        print("Fittting Weibull distribution...")
        _, mavs, dists = compute_train_score_and_mavs_and_dists(args.train_class_num, trainloader, device, net, test_classes)
        categories = list(range(0, args.train_class_num))
        weibull_model = fit_weibull(mavs, dists, categories, args.weibull_tail, "euclidean")

        pred_softmax, pred_softmax_threshold, pred_openmax = [], [], []
        score_softmax, score_openmax = [], []
        for score in scores:
            so, ss = openmax(weibull_model, categories, score,
                             0.5, args.weibull_alpha, "euclidean")
            # print(f"so  {so} \n ss  {ss}")# openmax_prob, softmax_prob
            pred_softmax.append(np.argmax(ss))
            pred_softmax_threshold.append(np.argmax(ss) if np.max(ss) >= args.weibull_threshold else args.train_class_num)
            pred_openmax.append(np.argmax(so) if np.max(so) >= args.weibull_threshold else args.train_class_num)

            score_softmax.append(ss)
            score_openmax.append(so)

        print("Evaluation...")
        # test_loss += criterion(torch.Tensor(score_softmax), torch.from_numpy(labels))
        test_loss += criterion(torch.Tensor(score_openmax), torch.from_numpy(labels))

        eval_softmax = Evaluation(pred_softmax, labels, score_softmax)
        eval_softmax_threshold = Evaluation(pred_softmax_threshold, labels, score_softmax)
        eval_openmax = Evaluation(pred_openmax, labels, score_openmax)

        torch.save(eval_softmax, os.path.join(args.checkpoint, 'eval_softmax.pkl'))
        torch.save(eval_softmax_threshold, os.path.join(args.checkpoint, 'eval_softmax_threshold.pkl'))
        torch.save(eval_openmax, os.path.join(args.checkpoint, 'eval_openmax.pkl'))


        print(f"Softmax accuracy is %.3f" % (eval_softmax.accuracy))
        print(f"Softmax F1 is %.3f" % (eval_softmax.f1_measure))
        print(f"Softmax f1_macro is %.3f" % (eval_softmax.f1_macro))
        print(f"Softmax f1_macro_weighted is %.3f" % (eval_softmax.f1_macro_weighted))
        print(f"Softmax area_under_roc is %.3f" % (eval_softmax.area_under_roc))
        print(f"_________________________________________")

        print(f"SoftmaxThreshold accuracy is %.3f" % (eval_softmax_threshold.accuracy))
        print(f"SoftmaxThreshold F1 is %.3f" % (eval_softmax_threshold.f1_measure))
        print(f"SoftmaxThreshold f1_macro is %.3f" % (eval_softmax_threshold.f1_macro))
        print(f"SoftmaxThreshold f1_macro_weighted is %.3f" % (eval_softmax_threshold.f1_macro_weighted))
        print(f"SoftmaxThreshold area_under_roc is %.3f" % (eval_softmax_threshold.area_under_roc))
        print(f"_________________________________________")

        print(f"OpenMax accuracy is %.3f" % (eval_openmax.accuracy))
        print(f"OpenMax F1 is %.3f" % (eval_openmax.f1_measure))
        print(f"OpenMax f1_macro is %.3f" % (eval_openmax.f1_macro))
        print(f"OpenMax f1_macro_weighted is %.3f" % (eval_openmax.f1_macro_weighted))
        print(f"OpenMax area_under_roc is %.3f" % (eval_openmax.area_under_roc))
        print(f"_________________________________________")

        with open(os.path.join(args.checkpoint, "garbage.csv"),"ab") as f:
            np.savetxt(f,np.array([epoch]))
            np.savetxt(f, np.array([eval_softmax.f1_measure, eval_softmax.f1_macro,
                                    eval_softmax.f1_macro_weighted,
                                    eval_softmax.area_under_roc]).reshape(1, 4),
                       fmt='%.4f')
            np.savetxt(f, np.array([eval_softmax_threshold.f1_measure,
                                    eval_softmax_threshold.f1_macro,
                                    eval_softmax_threshold.f1_macro_weighted,
                                    eval_softmax_threshold.area_under_roc
                                    ]).reshape(1, 4),
                                    fmt='%.4f')
            np.savetxt(f, eval_softmax_threshold.confusion_matrix, fmt='%d')
            np.savetxt(f, np.array([eval_openmax.f1_measure, eval_openmax.f1_macro,
                                    eval_openmax.f1_macro_weighted,
                                    eval_openmax.area_under_roc]).reshape(1, 4),
                                    fmt='%.4f')
            np.savetxt(f, eval_openmax.confusion_matrix, fmt='%d')
    else:
        def softmax(x):
            e_x = np.exp(x - np.max(x))
            return e_x / e_x.sum()

        pred_softmax,score_softmax=[],[]
        for score in scores:
            softmax_prob = softmax(np.array(score.ravel()))
            pred_softmax.append(np.argmax(softmax_prob))
            score_softmax.append(softmax_prob)

        eval_softmax = Evaluation(pred_softmax, labels, score_softmax)
        print(f"Softmax accuracy is %.3f" % (eval_softmax.accuracy))
        print(f"Softmax F1 is %.3f" % (eval_softmax.f1_measure))
        print(f"Softmax f1_macro is %.3f" % (eval_softmax.f1_macro))
        print(f"Softmax f1_macro_weighted is %.3f" % (eval_softmax.f1_macro_weighted))
        print(f"Softmax area_under_roc is %.3f" % (eval_softmax.area_under_roc))
        print(f"_________________________________________")

        with open(os.path.join(args.checkpoint, "garbage_closed.csv"),"ab") as f:
            np.savetxt(f,np.array([epoch]))
            np.savetxt(f, np.array([eval_softmax.f1_measure, eval_softmax.f1_macro,
                                    eval_softmax.f1_macro_weighted,
                                    eval_softmax.area_under_roc]).reshape(1, 4),
                       fmt='%.4f')
            np.savetxt(f, eval_softmax.confusion_matrix, fmt='%d')

    return test_loss/(batch_idx+1), correct/total

def save_model(net, acc, epoch, path):
    print('Saving..')
    state = {
        'net': net.state_dict(),
        'testacc': acc,
        'epoch': epoch,
    }
    # torch.save(state, path)
    torch.save(net.state_dict(), path)

if __name__=="__main__":
    main()

efficientnet.py

'''
python3.7
-*- coding: UTF-8 -*-
@Project -> File   ：pythonProject -> efficientNet
@IDE    ：PyCharm
@Author ：YangShouWei
@USER: 
@Date   ：2022/3/15 21:41:59
@LastEditor:
'''

import math
import copy
from functools import partial
from collections import OrderedDict
from typing import Optional, Callable

import torch
from torch import nn
from torch import Tensor
from torch.nn import functional as F

def _make_divisible(ch, divisior=8, min_ch=None):
    """
    This function is taken from the original tf repo.
    It ensures that all layers have a channel number that is divisible by 8
    """
    if min_ch is None:
        min_ch = divisior
    new_ch = max(min_ch, int(ch + divisior / 2) // divisior * divisior)
    # Make sure that round down does not go down by more than 10%
    if new_ch < 0.9 * ch:
        new_ch += divisior
    return new_ch

def drop_path(x, drop_prob: float = 0., training:bool = False):
    """
    Drop paths (Stochastic Depth) per sample (when applied in main path of residual blocks).

    This function is taken from the rwightman
    """
    if drop_prob == 0. or not training:
        return x
    keep_prob = 1 - drop_prob
    shape = (x.shape[0],) + (1,) * (x.ndim - 1) # work with diff dim tensor, not just 2D ConvNets
    random_tensor = keep_prob + torch.rand(shape, dtype=x.dtype, device=x.device)
    random_tensor.floor_() #binarize
    output = x.div(keep_prob) * random_tensor
    return output

class DropPath(nn.Module):
    """
    Drop paths (Stochastic Depth) per sample (when applied in main path of residual blocks).
    """
    def __init__(self, drop_prob=None):
        super(DropPath, self).__init__()
        self.drop_prob = drop_prob

    def forward(self, x):
        return drop_path(x, self.drop_prob, self.training)


class ConvBNActivation(nn.Sequential):
    def __init__(self,
                 in_planes: int,
                 out_planes:int,
                 kernel_size : int = 3,
                 stride: int = 1,
                 groups: int = 1,
                 norm_layer: Optional[Callable[..., nn.Module]] = None,
                 activation_layer:Optional[Callable[..., nn.Module]] = None):
        padding = (kernel_size - 1) // 2
        if norm_layer is None:
            norm_layer = nn.BatchNorm2d
        if activation_layer is None:
            activation_layer = nn.SiLU

        super(ConvBNActivation, self).__init__(nn.Conv2d(in_channels=in_planes,
                                               out_channels=out_planes,
                                               kernel_size=kernel_size,
                                               stride=stride,
                                               padding=padding,
                                               groups=groups,
                                               bias=False),
                                               norm_layer(out_planes),
                                               activation_layer())










class SqueezeExcitation(nn.Module):
    def __init__(self,
                 input_c:int, # block input channel
                 expand_c:int, # block expand channel
                 squeeze_factor:int = 4):
        super(SqueezeExcitation, self).__init__()
        squeeze_c = input_c // squeeze_factor
        self.fc1 = nn.Conv2d(expand_c,squeeze_c, 1)
        self.ac1 = nn.SiLU()
        self.fc2 = nn.Conv2d(squeeze_c, expand_c, 1)
        self.ac2 = nn.Sigmoid()

    def forward(self,  x:Tensor):
        scale = F.adaptive_avg_pool2d(x, output_size=(1, 1))
        scale = self.fc1(scale)
        scale = self.ac1(scale)
        scale = self.fc2(scale)
        scale = self.ac2(scale)

        return scale * x

class InvertedResidualConfig:
    #kernel_size, in_channel, out_channel, exp_ratio, strides, use_SE, drop_connect_rate
    def __init__(self,
                 kernel: int,
                 input_c: int,
                 out_c: int,
                 expanded_ratio: int, # 1 or 6
                 stride: int,          # 1 or 2
                 use_se: bool,          # True
                 drop_rate: float,
                 index: str,           #1a, 2a, 2b, ...
                 width_coefficient:float):
        self.input_c = self.adjust_channels(input_c, width_coefficient)
        self.kernel = kernel
        self.expanded_c = self.input_c * expanded_ratio
        self.out_c =self.adjust_channels(out_c, width_coefficient)
        self.use_se = use_se
        self.stride = stride
        self.drop_rate = drop_rate
        self.index = index

    @staticmethod # 静态方法
    def adjust_channels(channels: int, width_coefficient: float):
        return _make_divisible(channels * width_coefficient, 8) # 通道数乘以倍率因子然后取最接近8的倍数的数


class InvertedResidual(nn.Module):
    def __init__(self,
                 cnf:InvertedResidualConfig,
                 norm_layer: Callable[..., nn.Module]):
        super(InvertedResidual, self).__init__()

        if cnf.stride not in [1, 2]:
            raise ValueError("illegal stride value")
        self.use_res_connect = (cnf.stride == 1 and cnf.input_c == cnf.out_c) # 判断是否使用残差连接
        layers = OrderedDict()
        activation_layer = nn.SiLU


        # expand
        if cnf.expanded_c != cnf.input_c:
            layers.update({"expand_conv": ConvBNActivation(cnf.input_c,
                                                           cnf.expanded_c,
                                                           kernel_size=1,
                                                           norm_layer=norm_layer,
                                                           activation_layer=activation_layer)})

        # depthwise
        layers.update({"dwconv":ConvBNActivation(cnf.expanded_c,
                                                 cnf.expanded_c,
                                                 kernel_size=cnf.kernel,
                                                 stride=cnf.stride,
                                                 groups=cnf.expanded_c,
                                                 norm_layer=norm_layer,
                                                 activation_layer=activation_layer)})

        if cnf.use_se:
            layers.update({"se": SqueezeExcitation(cnf.input_c,
                                                   cnf.expanded_c)})

        #project
        layers.update({"project_conv": ConvBNActivation(cnf.expanded_c,
                                                        cnf.out_c,
                                                        kernel_size=1,
                                                        norm_layer=norm_layer,
                                                        activation_layer=nn.Identity)}) # identity表示不做任何处理


        self.block = nn.Sequential(layers)
        self.out_channels = cnf.out_c
        self.is_strided = cnf.stride > 1

        #只有在使用shortcut连接时才使用dropout层
        if self.use_res_connect and cnf.drop_rate > 0:
            self.dropout = DropPath(cnf.drop_rate)
        else:
            self.dropout = nn.Identity()



    def forward(self, x:Tensor) -> Tensor:
        result = self.block(x)
        result = self.dropout(result)
        if self.use_res_connect:
            result += x

        return result





class EfficientNet(nn.Module):
    def __init__(self,
                 width_coefficient: float,
                 depth_coefficient: float,
                 num_classes: int = 1000,
                 dropout_rate: float = 0.2,
                 drop_connect_rate: float = 0.2,
                 block: Optional[Callable[..., nn.Module]] = None,
                 norm_layer :Optional[Callable[..., nn.Module]] = None):
        super(EfficientNet, self).__init__()

        # kernel_size, in_channel, out_channel, exp_ratio, strides, use_SE, drop_connect_rate, repeats
        deafault_cnf = [[3, 32, 16, 1, 1, True, drop_connect_rate, 1],
                        [3, 16, 24, 6, 2, True, drop_connect_rate, 2],
                        [5, 24, 40, 6, 2, True, drop_connect_rate, 2],
                        [3, 40, 80, 6, 2, True, drop_connect_rate, 3],
                        [5, 80, 112, 6, 1, True, drop_connect_rate, 3],
                        [5, 112, 192, 6, 2, True, drop_connect_rate, 4],
                        [3, 192, 320, 6, 1, True, drop_connect_rate, 1],]
        def round_repeats(repeats):
            """Round number of repeats based on depth multiplier."""
            return int(math.ceil(depth_coefficient * repeats))

        if block is None:
            block = InvertedResidual

        if norm_layer is None:
            norm_layer = partial(nn.BatchNorm2d, eps=1e-3, momentum=0.1)

        adjust_channels = partial(InvertedResidualConfig.adjust_channels,
                                  width_coefficient=width_coefficient)

        #bneck inverted_residual_setting
        bneck_conf = partial(InvertedResidualConfig, width_coefficient=width_coefficient)


        b = 0
        num_blocks = float(sum(round_repeats(i[-1]) for i in deafault_cnf))
        inverted_residual_setting = []
        for stage, args in enumerate(deafault_cnf):
            cnf = copy.copy(args)
            for i in range(round_repeats(cnf.pop(-1))):
                if i > 0:
                    # stride equal 1 expcept first cnf
                    cnf[-3] = 1 #strides
                    cnf[1] = cnf[2]  # input_channel equal output_channel

                cnf[-1] = args[-2] * b / num_blocks # update dropout ratio
                index = str(stage + 1) + chr(i + 97) # 1a, 2a, 2b
                inverted_residual_setting.append(bneck_conf(*cnf, index))
                b += 1


        #create layers
        layers = OrderedDict()

        # first conv
        layers.update({'stem_conv': ConvBNActivation(in_planes=3,
                                                     out_planes=adjust_channels(32),
                                                     kernel_size=3,
                                                     stride=2,
                                                     norm_layer=norm_layer)})
        # building inverted residual blocks
        for cnf in inverted_residual_setting:
            layers.update({cnf.index: block(cnf, norm_layer)})

        # build top
        last_conv_input_c = inverted_residual_setting[-1].out_c
        last_conv_output_c = adjust_channels(1280)
        layers.update({"top": ConvBNActivation(in_planes=last_conv_input_c,
                                               out_planes=last_conv_output_c,
                                               kernel_size=1,
                                               norm_layer=norm_layer
                                               )})
        self.features = nn.Sequential(layers)
        self.avgpool = nn.AdaptiveAvgPool2d(1)

        classifier = []
        if dropout_rate > 0:
            classifier.append(nn.Dropout(p=dropout_rate, inplace=True))
        classifier.append(nn.Linear(last_conv_output_c, num_classes))
        self.classifier = nn.Sequential(*classifier)

        # initial weights
        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                nn.init.kaiming_normal_(m.weight, mode="fan_out")
                if m.bias is not None:
                    nn.init.zeros_(m.bias)
            elif isinstance(m, nn.BatchNorm2d):
                nn.init.ones_(m.weight)
                nn.init.zeros_(m.bias)
            elif isinstance(m, nn.Linear):
                nn.init.normal_(m.weight, 0, 0.01)
                nn.init.zeros_(m.bias)

    def _forward_impl(self, x:Tensor):
        x = self.features(x)
        x = self.avgpool(x)
        x = torch.flatten(x, 1)
        x = self.classifier(x)

        return x

    def forward(self, x:Tensor) -> Tensor:
        return self._forward_impl(x)


def efficientnet_b0(num_classes=1000):
    return EfficientNet(width_coefficient=1.0, depth_coefficient=1.1, dropout_rate=0.2, num_classes=num_classes)


def efficientnet_b1(num_classes=1000):
    return EfficientNet(width_coefficient=1.0, depth_coefficient=1.1, dropout_rate=0.2, num_classes=num_classes)


def efficientnet_b2(num_classes=1000):
    return EfficientNet(width_coefficient=1.1, depth_coefficient=1.2, dropout_rate=0.3, num_classes=num_classes)


def efficientnet_b3(num_classes=1000):
    return EfficientNet(width_coefficient=1.2, depth_coefficient=1.4, dropout_rate=0.3, num_classes=num_classes)


def efficientnet_b4(num_classes=1000):
    return EfficientNet(width_coefficient=1.4, depth_coefficient=1.8, dropout_rate=0.4, num_classes=num_classes)


def efficientnet_b5(num_classes=1000):
    return EfficientNet(width_coefficient=1.6, depth_coefficient=2.2, dropout_rate=0.4, num_classes=num_classes)


def efficientnet_b6(num_classes=1000):
    return EfficientNet(width_coefficient=1.8, depth_coefficient=2.6, dropout_rate=0.5, num_classes=num_classes)


def efficientnet_b7(num_classes=1000):
    return EfficientNet(width_coefficient=2.0, depth_coefficient=3.1, dropout_rate=0.5, num_classes=num_classes)

Openmax.py

import numpy as np
import scipy.spatial.distance as spd
import torch

import libmr





def calc_distance(query_score, mcv, eu_weight, distance_type='eucos'):
    if distance_type == 'eucos':
        query_distance = spd.euclidean(mcv, query_score) * eu_weight + \
            spd.cosine(mcv, query_score)
    elif distance_type == 'euclidean':
        query_distance = spd.euclidean(mcv, query_score)
    elif distance_type == 'cosine':
        query_distance = spd.cosine(mcv, query_score)
    else:
        print("distance type not known: enter either of eucos, euclidean or cosine")
    return query_distance


def fit_weibull(means, dists, categories, tailsize=20, distance_type='eucos'):
    """
    Input:
        means (C, channel, C)
        dists (N_c, channel, C) * C
    Output:
        weibull_model : Perform EVT based analysis using tails of distances and save
                        weibull model parameters for re-adjusting softmax scores
    """
    weibull_model = {}
    for mean, dist, category_name in zip(means, dists, categories):
        weibull_model[category_name] = {}
        weibull_model[category_name]['distances_{}'.format(distance_type)] = dist[distance_type]
        weibull_model[category_name]['mean_vec'] = mean
        weibull_model[category_name]['weibull_model'] = []
        for channel in range(mean.shape[0]):
            mr = libmr.MR()
            tailtofit = np.sort(dist[distance_type][channel, :])[-tailsize:]
            mr.fit_high(tailtofit, len(tailtofit))
            weibull_model[category_name]['weibull_model'].append(mr)

    return weibull_model


def query_weibull(category_name, weibull_model, distance_type='eucos'):
    return [weibull_model[category_name]['mean_vec'],
            weibull_model[category_name]['distances_{}'.format(distance_type)],
            weibull_model[category_name]['weibull_model']]


def compute_openmax_prob(scores, scores_u):
    prob_scores, prob_unknowns = [], []
    for s, su in zip(scores, scores_u):
        channel_scores = np.exp(s)
        channel_unknown = np.exp(np.sum(su))

        total_denom = np.sum(channel_scores) + channel_unknown
        prob_scores.append(channel_scores / total_denom)
        prob_unknowns.append(channel_unknown / total_denom)

    # Take channel mean
    scores = np.mean(prob_scores, axis=0)
    unknowns = np.mean(prob_unknowns, axis=0)
    modified_scores = scores.tolist() + [unknowns]
    return modified_scores


def softmax(x):
    e_x = np.exp(x - np.max(x))
    return e_x / e_x.sum()


def openmax(weibull_model, categories, input_score, eu_weight, alpha=10, distance_type='eucos'):
    """Re-calibrate scores via OpenMax layer
    Output:
        openmax probability and softmax probability
    """
    nb_classes = len(categories)

    ranked_list = input_score.argsort().ravel()[::-1][:alpha]
    alpha_weights = [((alpha + 1) - i) / float(alpha) for i in range(1, alpha + 1)]
    omega = np.zeros(nb_classes)
    omega[ranked_list] = alpha_weights

    scores, scores_u = [], []
    for channel, input_score_channel in enumerate(input_score):
        score_channel, score_channel_u = [], []
        for c, category_name in enumerate(categories):
            mav, dist, model = query_weibull(category_name, weibull_model, distance_type)
            channel_dist = calc_distance(input_score_channel, mav[channel], eu_weight, distance_type)
            wscore = model[channel].w_score(channel_dist)
            modified_score = input_score_channel[c] * (1 - wscore * omega[c])#v^i(x)=v(x)*(1-welbull *(alpha-i)/alpha)
            score_channel.append(modified_score)
            score_channel_u.append(input_score_channel[c] - modified_score)#v^0(x)=sum(vi(x)*(1-wi(x)))

        scores.append(score_channel)
        scores_u.append(score_channel_u)

    scores = np.asarray(scores)
    scores_u = np.asarray(scores_u)

    openmax_prob = np.array(compute_openmax_prob(scores, scores_u))
    softmax_prob = softmax(np.array(input_score.ravel()))
    return openmax_prob, softmax_prob


def compute_channel_distances(mavs, features, eu_weight=0.5):
    """
    Input:
        mavs (channel, C)
        features: (N, channel, C)
    Output:
        channel_distances: dict of distance distribution from MAV for each channel.
    """
    eucos_dists, eu_dists, cos_dists = [], [], []
    for channel, mcv in enumerate(mavs):  # Compute channel specific distances
        eu_dists.append([spd.euclidean(mcv, feat[channel]) for feat in features])
        cos_dists.append([spd.cosine(mcv, feat[channel]) for feat in features])
        eucos_dists.append([spd.euclidean(mcv, feat[channel]) * eu_weight +
                            spd.cosine(mcv, feat[channel]) for feat in features])

    return {'eucos': np.array(eucos_dists), 'cosine': np.array(cos_dists), 'euclidean': np.array(eu_dists)}


def compute_train_score_and_mavs_and_dists(train_class_num,trainloader, device, net, test_classes):
    scores = [[] for _ in range(train_class_num)]
    with torch.no_grad():
        for batch_idx, (inputs, targets) in enumerate(trainloader):
            onehot_targets_index = [test_classes.index(i) for i in targets]
            targets = torch.LongTensor(onehot_targets_index)
            inputs, targets = inputs.to(device), targets.to(device)

            # this must cause error for cifar10
            outputs = net(inputs)

            for score, t in zip(outputs, targets):
                # print(f"torch.argmax(score) is {torch.argmax(score)}, t is {t}")
                if torch.argmax(score) == t:
                    scores[t].append(score.unsqueeze(dim=0).unsqueeze(dim=0))
    scores = [torch.cat(x).cpu().numpy() for x in scores]  # (N_c, 1, C) * C
    mavs = np.array([np.mean(x, axis=0) for x in scores])  # (C, 1, C)
    dists = [compute_channel_distances(mcv, score) for mcv, score in zip(mavs, scores)]
    return scores, mavs, dists

evaluation.py

import numpy as np
import matplotlib.pyplot as plt
from sklearn.metrics import confusion_matrix, f1_score, \
    classification_report, precision_recall_fscore_support, roc_auc_score
from sklearn.preprocessing import OneHotEncoder
# import sklearn.metrics.ConfusionMatrixDisplay

class Evaluation(object):
    """Evaluation class based on python list"""
    def __init__(self, predict, label,prediction_scores = None):
        self.predict = predict
        self.label = label
        self.prediction_scores = prediction_scores

        self.accuracy = self._accuracy()
        self.f1_measure = self._f1_measure()
        self.f1_macro = self._f1_macro()
        self.f1_macro_weighted = self._f1_macro_weighted()
        self.precision, self.recall = self._precision_recall(average='micro')
        self.precision_macro, self.recall_macro = self._precision_recall(average='macro')
        self.precision_weighted, self.recall_weighted = self._precision_recall(average='weighted')
        self.confusion_matrix = self._confusion_matrix()
        if self.prediction_scores is not None:
            self.area_under_roc = self._area_under_roc(prediction_scores)
            pass

    def _accuracy(self) -> float:
        """
        Returns the accuracy score of the labels and predictions.
        :return: float
        """
        assert len(self.predict) == len(self.label)
        correct = (np.array(self.predict) == np.array(self.label)).sum()
        return float(correct)/float(len(self.predict))

    def _f1_measure(self) -> float:
        """
        Returns the F1-measure with a micro average of the labels and predictions.
        :return: float
        """
        assert len(self.predict) == len(self.label)
        return f1_score(self.label, self.predict, average='micro')

    def _f1_macro(self) -> float:
        """
        Returns the F1-measure with a macro average of the labels and predictions.
        :return: float
        """
        assert len(self.predict) == len(self.label)
        return f1_score(self.label, self.predict, average='macro')

    def _f1_macro_weighted(self) -> float:
        """
        Returns the F1-measure with a weighted macro average of the labels and predictions.
        :return: float
        """
        assert len(self.predict) == len(self.label)
        return f1_score(self.label, self.predict, average='weighted')

    def _precision_recall(self, average) -> (float, float):
        """
        Returns the precision and recall scores for the label and predictions. Observes the average type.

        :param average: string, [None (default), ‘micro’, ‘macro’, ‘samples’, ‘weighted’].
            For explanations of each type of average see the documentation for
            `sklearn.metrics.precision_recall_fscore_support`
        :return: float, float: representing the precision and recall scores respectively
        """
        assert len(self.predict) == len(self.label)
        precision, recall, _, _ = precision_recall_fscore_support(self.label, self.predict, average=average)
        return precision, recall

    def _area_under_roc(self, prediction_scores: np.array = None, multi_class='ovo') -> float:
        """
        Area Under Receiver Operating Characteristic Curve

        :param prediction_scores: array-like of shape (n_samples, n_classes). The multi-class ROC curve requires
            prediction scores for each class. If not specified, will generate its own prediction scores that assume
            100% confidence in selected prediction.
        :param multi_class: {'ovo', 'ovr'}, default='ovo'
            'ovo' computes the average AUC of all possible pairwise combinations of classes.
            'ovr' Computes the AUC of each class against the rest.
        :return: float representing the area under the ROC curve
        """
        label, predict = self.label, self.predict
        one_hot_encoder = OneHotEncoder(sparse=False, handle_unknown='ignore')
        one_hot_encoder.fit(np.array(label).reshape(-1, 1))
        true_scores = one_hot_encoder.transform(np.array(label).reshape(-1, 1))
        if prediction_scores is None:
            prediction_scores = one_hot_encoder.transform(np.array(predict).reshape(-1, 1))
        # assert prediction_scores.shape == true_scores.shape

        # return roc_auc_score(true_scores, prediction_scores, multi_class=multi_class)
        return roc_auc_score(true_scores, prediction_scores)

    def _confusion_matrix(self, normalize=None) -> np.array:
        """
        Returns the confusion matrix corresponding to the labels and predictions.

        :param normalize: {‘true’, ‘pred’, ‘all’}, default=None.
            Normalizes confusion matrix over the true (rows), predicted (columns) conditions or all the population.
            If None, confusion matrix will not be normalized.
        :return:
        """
        assert len(self.predict) == len(self.label)
        # return confusion_matrix(self.label, self.predict, normalize=normalize)
        return confusion_matrix(self.label, self.predict)

    def plot_confusion_matrix(self, labels: [str] = None, normalize=None, ax=None, savepath=None) -> None:
        """

        :param labels: [str]: label names
        :param normalize: {‘true’, ‘pred’, ‘all’}, default=None.
            Normalizes confusion matrix over the true (rows), predicted (columns) conditions or all the population.
            If None, confusion matrix will not be normalized.
        :param ax: matplotlib.pyplot axes to draw the confusion matrix on. Will generate new figure/axes if None.
        :return:
        """
        conf_matrix = self._confusion_matrix(normalize)  # Evaluate the confusion matrix
        # display = ConfusionMatrixDisplay(conf_matrix, display_labels=labels)  # Generate the confusion matrix display

        # Formatting for the plot
        if labels:
            xticks_rotation = 'vertical'
        else:
            xticks_rotation = 'horizontal'

        # display.plot(include_values=True, cmap=plt.cm.get_cmap('Blues'), xticks_rotation=xticks_rotation, ax=ax)
        if savepath is None:
            plt.show()
        else:
            plt.savefig(savepath, bbox_inches='tight', dpi=200)
        plt.close()


if __name__ == '__main__':
    predict = [1, 2, 3, 4, 5, 3, 3, 2, 2, 5, 6, 6, 4, 3, 2, 4, 5, 6, 6, 3, 2]
    label =   [2, 5, 3, 4, 5, 3, 2, 2, 4, 6, 6, 6, 3, 3, 2, 5, 5, 6, 6, 3, 3]

    eval = Evaluation(predict, label)
    print('Accuracy:', f"%.3f" % eval.accuracy)
    print('F1-measure:', f'{eval.f1_measure:.3f}')
    print('F1-macro:', f'{eval.f1_macro:.3f}')
    print('F1-macro (weighted):', f'{eval.f1_macro_weighted:.3f}')
    print('precision:', f'{eval.precision:.3f}')
    print('precision (macro):', f'{eval.precision_macro:.3f}')
    print('precision (weighted):', f'{eval.precision_weighted:.3f}')
    print('recall:', f'{eval.recall:.3f}')
    print('recall (macro):', f'{eval.recall_macro:.3f}')
    print('recall (weighted):', f'{eval.recall_weighted:.3f}')

    # Generate "random prediction score" to test feeding in prediction score from NN
    test_one_hot_encoder = OneHotEncoder(sparse=False, handle_unknown='ignore')
    test_one_hot_encoder.fit(np.array(label).reshape(-1, 1))
    rand_prediction_scores = 2 * test_one_hot_encoder.transform(np.array(predict).reshape(-1, 1))  # One hot
    rand_prediction_scores += np.random.rand(*rand_prediction_scores.shape)
    # rand_prediction_scores /= rand_prediction_scores.sum(axis=1)[:, None]
    # print('Area under ROC curve (with 100% confidence in prediction):', f'{eval.area_under_roc():.3f}')
    # print('Area under ROC curve (variable probability across classes):',
    #       f'{eval.area_under_roc(prediction_scores=rand_prediction_scores):.3f}')
    # print(eval.confusion_matrix)
    label_names = ["bird","bog","perople","horse","cat", "unknown"]
    eval.plot_confusion_matrix(normalize="true",labels=label_names)
    # print("运行到这了")
    print(classification_report(label, predict, digits=3))

cifarutils.py

'''Some helper functions for PyTorch, including:
    - get_mean_and_std: calculate the mean and std value of dataset.
    - msr_init: net parameter initialization.
    - progress_bar: progress bar mimic xlua.progress.
'''
import os
import sys
import time
import errno
import shutil
import torch
import torch.nn as nn
import torch.nn.init as init
import torchvision.utils as vutils

__all__=["get_mean_and_std","progress_bar","format_time",
         'adjust_learning_rate', 'AverageMeter','Logger','mkdir_p', 'save_binary_img', 'save_model']

def get_mean_and_std(dataset):
    '''Compute the mean and std value of dataset.'''
    dataloader = torch.utils.data.DataLoader(dataset, batch_size=1, shuffle=True, num_workers=2)
    mean = torch.zeros(3)
    std = torch.zeros(3)
    print('==> Computing mean and std..')
    for inputs, targets in dataloader:
        for i in range(3):
            mean[i] += inputs[:,i,:,:].mean()
            std[i] += inputs[:,i,:,:].std()
    mean.div_(len(dataset))
    std.div_(len(dataset))
    return mean, std

def init_params(net):
    '''Init layer parameters.'''
    for m in net.modules():
        if isinstance(m, nn.Conv2d):
            init.kaiming_normal(m.weight, mode='fan_out')
            if m.bias:
                init.constant(m.bias, 0)
        elif isinstance(m, nn.BatchNorm2d):
            init.constant(m.weight, 1)
            init.constant(m.bias, 0)
        elif isinstance(m, nn.Linear):
            init.normal(m.weight, std=1e-3)
            if m.bias:
                init.constant(m.bias, 0)


# _, term_width = os.popen('stty size', 'r').read().split()
# term_width = int(term_width)

TOTAL_BAR_LENGTH = 65.
last_time = time.time()
begin_time = last_time
def progress_bar(current, total, msg=None):
    global last_time, begin_time
    if current == 0:
        begin_time = time.time()  # Reset for new bar.

    cur_len = int(TOTAL_BAR_LENGTH*current/total)
    rest_len = int(TOTAL_BAR_LENGTH - cur_len) - 1

    sys.stdout.write(' [')
    for i in range(cur_len):
        sys.stdout.write('=')
    sys.stdout.write('>')
    for i in range(rest_len):
        sys.stdout.write('.')
    sys.stdout.write(']')

    cur_time = time.time()
    step_time = cur_time - last_time
    last_time = cur_time
    tot_time = cur_time - begin_time

    L = []
    L.append('  Step: %s' % format_time(step_time))
    L.append(' | Tot: %s' % format_time(tot_time))
    if msg:
        L.append(' | ' + msg)

    msg = ''.join(L)
    sys.stdout.write(msg)
    # for i in range(term_width-int(TOTAL_BAR_LENGTH)-len(msg)-3):
    #     sys.stdout.write(' ')

    # Go back to the center of the bar.
    # for i in range(term_width-int(TOTAL_BAR_LENGTH/2)+2):
    #     sys.stdout.write('\b')
    sys.stdout.write(' %d/%d ' % (current+1, total))

    if current < total-1:
        sys.stdout.write('\r')
    else:
        sys.stdout.write('\n')
    sys.stdout.flush()

def format_time(seconds):
    days = int(seconds / 3600/24)
    seconds = seconds - days*3600*24
    hours = int(seconds / 3600)
    seconds = seconds - hours*3600
    minutes = int(seconds / 60)
    seconds = seconds - minutes*60
    secondsf = int(seconds)
    seconds = seconds - secondsf
    millis = int(seconds*1000)

    f = ''
    i = 1
    if days > 0:
        f += str(days) + 'D'
        i += 1
    if hours > 0 and i <= 2:
        f += str(hours) + 'h'
        i += 1
    if minutes > 0 and i <= 2:
        f += str(minutes) + 'm'
        i += 1
    if secondsf > 0 and i <= 2:
        f += str(secondsf) + 's'
        i += 1
    if millis > 0 and i <= 2:
        f += str(millis) + 'ms'
        i += 1
    if f == '':
        f = '0ms'
    return f

def write_record(file_path,str):
    if not os.path.exists(file_path):
        # os.makedirs(file_path)
        os.system(r"touch {}".format(file_path))
    f = open(file_path, 'a')
    f.write(str)
    f.close()

def count_parameters(model,all=True):
    # If all= Flase, we only return the trainable parameters; tested
    return sum(p.numel() for p in model.parameters() if p.requires_grad or all)

def adjust_learning_rate(optimizer, epoch, lr,factor=0.1, step=30):
    """Sets the learning rate to the initial LR decayed by factor every step epochs"""
    lr = lr * (factor ** (epoch // step))
    for param_group in optimizer.param_groups:
        param_group['lr'] = lr



class ProgressMeter(object):
    def __init__(self, num_batches, meters, prefix=""):
        self.batch_fmtstr = self._get_batch_fmtstr(num_batches)
        self.meters = meters
        self.prefix = prefix

    def display(self, batch):
        entries = [self.prefix + self.batch_fmtstr.format(batch)]
        entries += [str(meter) for meter in self.meters]
        print('\t'.join(entries))

    def _get_batch_fmtstr(self, num_batches):
        num_digits = len(str(num_batches // 1))
        fmt = '{:' + str(num_digits) + 'd}'
        return '[' + fmt + '/' + fmt.format(num_batches) + ']'


def accuracy(output, target, topk=(1,)):
    """Computes the accuracy over the k top predictions for the specified values of k"""
    with torch.no_grad():
        maxk = max(topk)
        batch_size = target.size(0)

        _, pred = output.topk(maxk, 1, True, True)
        pred = pred.t()
        correct = pred.eq(target.view(1, -1).expand_as(pred))

        res = []
        for k in topk:
            correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)
            res.append(correct_k.mul_(100.0 / batch_size))
        return res


def save_checkpoint(state, is_best, netName):
    torch.save(state, './checkpoint/ckpt_imagenet32_' + netName + '_last.t7')
    if is_best:
        shutil.copyfile('./checkpoint/ckpt_imagenet32_' + netName + '_last.t7',
                        './checkpoint/ckpt_imagenet32_' + netName + '_best.t7')


class AverageMeter(object):
    """Computes and stores the average and current value"""
    def __init__(self, name, fmt=':f'):
        self.name = name
        self.fmt = fmt
        self.reset()

    def reset(self):
        self.val = 0
        self.avg = 0
        self.sum = 0
        self.count = 0

    def update(self, val, n=1):
        self.val = val
        self.sum += val * n
        self.count += n
        self.avg = self.sum / self.count

    def __str__(self):
        fmtstr = '{name} {val' + self.fmt + '} ({avg' + self.fmt + '})'
        return fmtstr.format(**self.__dict__)


class Logger(object):
    '''Save training process to log file with simple plot function.'''
    def __init__(self, fpath, title=None, resume=False):
        self.file = None
        self.resume = resume
        self.title = '' if title == None else title
        if fpath is not None:
            if resume:
                self.file = open(fpath, 'r')
                name = self.file.readline()
                self.names = name.rstrip().split('\t')
                self.numbers = {}
                for _, name in enumerate(self.names):
                    self.numbers[name] = []

                for numbers in self.file:
                    numbers = numbers.rstrip().split('\t')
                    for i in range(0, len(numbers)):
                        self.numbers[self.names[i]].append(numbers[i])
                self.file.close()
                self.file = open(fpath, 'a')
            else:
                self.file = open(fpath, 'w')

    def set_names(self, names):
        if self.resume:
            pass
        # initialize numbers as empty list
        self.numbers = {}
        self.names = names
        for _, name in enumerate(self.names):
            self.file.write(name)
            self.file.write('\t')
            self.numbers[name] = []
        self.file.write('\n')
        self.file.flush()


    def append(self, numbers):
        assert len(self.names) == len(numbers), 'Numbers do not match names'
        for index, num in enumerate(numbers):
            self.file.write("{0:.6f}".format(num))
            self.file.write('\t')
            self.numbers[self.names[index]].append(num)
        self.file.write('\n')
        self.file.flush()

    def close(self):
        if self.file is not None:
            self.file.close()

def mkdir_p(path):
    '''make dir if not exist'''
    try:
        os.makedirs(path)
    except OSError as exc:  # Python >2.5
        if exc.errno == errno.EEXIST and os.path.isdir(path):
            pass
        else:
            raise


def save_model(net, optimizer, epoch, path, **kwargs):
    state = {
        'net': net.state_dict(),
        'optimizer': optimizer.state_dict(),
        'epoch': epoch
    }
    for key, value in kwargs.items():
        state[key] = value
    torch.save(state, path)


def save_binary_img(tensor, file_path="./val.png", nrow=8, binary=False):
    # tensor [b,1,w,h]
    predicted = tensor
    if binary:
        predicted = torch.sigmoid(tensor) > 0.5
    vutils.save_image(predicted.float(), file_path,nrow=nrow)

garbage.py

'''
@File  :garbage.py
@Author:cjh
@Date  :2022/1/16 15:09
@Desc  :
'''
import pickle

import torch.nn.functional as F
import torch
import torch.nn as nn
from torch.autograd import Variable
import torchvision.models as models
from torchvision import transforms, utils
from torch.utils.data import Dataset, DataLoader
from PIL import Image
import numpy as np
import torch.optim as optim
import os
import random
import cv2
from torchvision.datasets.vision import VisionDataset

unknown_class_index=999


class GARBAGE40_Dataset(VisionDataset):
    training_file='/train.txt'
    validating_file='/validate.txt'
    testing_file='/test.txt'

    classes = ['0','1','2','3','4','5','6','7','8','9',
               '10','11','12','13','14','15','16','17','18','19',
               '20','21','22','23','24','25','26','27','28','29',
               '30', '31', '32', '33', '34', '35', '36', '37', '38', '39']
    # def get_root(self):
    #     return os.getcwd()

    def __init__(self, root, train=True, transform=None, target_transform=None,
                 train_class_num=24, test_class_num=40, includes_all_train_class=True,train_classes=None):

        super(GARBAGE40_Dataset, self).__init__(root,transform=transform,
                                                target_transform=target_transform)
        self.train=train
        if self.train:
            data_file=self.training_file
        else:
            data_file=self.testing_file
        self.ori_data,self.ori_targets=[],[]
        self.init_data(txt=root+data_file)
        self.ori_data, self.ori_targets=np.array(self.ori_data),np.array(self.ori_targets)
        self._update_open_set(train_class_num, test_class_num, includes_all_train_class,train_classes)

    def _update_open_set(self, train_class_num=24, test_class_num=40, includes_all_train_class=False,train_classes=None):
        assert train_class_num > 0 and train_class_num <= 40  # not include 10 to ensure openness.
        if includes_all_train_class:
            assert test_class_num >= train_class_num  # not include equal to ensure openness.
        class_list = list(range(len(self.classes))) #[0...39]

        # train_classes = list(range(train_class_num))#[0...23]

        if includes_all_train_class:
            rnd = np.random.RandomState(42)
            # unknown_list = list(range(train_class_num, 10))
            unknown_list=[idx for idx in range(40) if idx not in train_classes]
            test_classes = rnd.choice(unknown_list, test_class_num - train_class_num, replace=False).tolist() # 从unknown_list中随机选择(40-24)=16个项
            test_classes = train_classes + test_classes
        else:
            rnd = np.random.RandomState(42)
            test_classes = rnd.choice(class_list, test_class_num, replace=False).tolist()

        # Update self.classes
        selected_elements = [self.classes[index] for index in train_classes]
        selected_elements.append(str(unknown_class_index) + '-unknown')
        self.classes = selected_elements


        # self.classes = test_classes
        # update self.class_to_idx
        # Ignore: due to the class_to_idx property
        # self.class_to_idx = {_class: i for i, _class in enumerate(self.classes)}
        # Processing data
        if self.train:
            indexes = [i for i, x in enumerate(self.ori_targets) if x in train_classes]
            self.data = self.ori_data[indexes]
            self.targets = [self.ori_targets[i]for i in indexes]

            print(f"\tTraining data includes {train_class_num} classes, {len(self.targets)} samples.")
        else:
            indexes = [i for i, x in enumerate(self.ori_targets) if x in test_classes]
            self.data = self.ori_data[indexes]
            temp_test_classes = [x for x in test_classes if x not in train_classes]
            train_and_test_calsses = train_classes + temp_test_classes
            self.targets = [self.ori_targets[i] for i in indexes]

            for i in range(0, len(self.ori_targets)):
                if self.targets[i] in temp_test_classes:
                    self.targets[i] = unknown_class_index
            print(f"\tTesting data includes {train_class_num + 1} classes (Original {test_class_num} classes),"
                  f" {len(self.targets)} samples.")

            CTR=train_class_num
            CTU=len(temp_test_classes)
            CTA = CTR+CTU
            self.openness = 1-np.sqrt(2*CTR/(CTR+CTA))
            print(f"\tDuring testing, openness is {self.openness}.")

    # 定义读取文件的格式
    def loader(self,fn):
        path = self.root+'/'.join(fn[1:].split("/"))
        return Image.open(path).convert('RGB')

    def init_data(self,txt):
        fh = open(txt, 'r')
        for line in fh:  # 迭代该列表 #按行循环txt文本中的内
            line = line.strip('\n')
            line = line.rstrip('\n')  # 删除 本行string 字符串末尾的指定字符
            words = line.split()  # 用split将该行分割成列表  split的默认参数是空格
            self.ori_data.append(words[0])
            self.ori_targets.append(int(words[1]))

    def __getitem__(self, index):
        """
        Args:
            index (int): Index

        Returns:
            tuple: (image, target) where target is index of the target class.
        """
        fn, target = self.data[index],int(self.targets[index])
        img = self.loader(fn)  # 按照路径读取图片
        if self.transform is not None:
            img = self.transform(img)  # 数据标签转换为Tensor
        if self.target_transform is not None:
            target = self.target_transform(target)
        return img, target

    def __len__(self):
        return len(self.data)

if __name__=="__main__":
    import time
    start1 = time.perf_counter()


    # train_transforms = transforms.Compose([
    #     transforms.Resize(224),
    #     transforms.RandomResizedCrop(224, scale=(0.8, 1.0)),
    #     transforms.RandomHorizontalFlip(0.5),
    #     transforms.RandomRotation(10),
    #     transforms.ToTensor(),
    #     transforms.Normalize([0.5071, 0.4865, 0.4409], [0.2673, 0.2564, 0.2762]),
    # ])
    # test_transforms = transforms.Compose([
    #     transforms.Resize(224),
    #     transforms.RandomResizedCrop(224, scale=(0.8, 1.0)),
    #     transforms.RandomHorizontalFlip(0.5),
    #     transforms.RandomRotation(10),
    #     transforms.ToTensor(),
    #     transforms.Normalize([0.5071, 0.4865, 0.4409], [0.2673, 0.2564, 0.2762]),
    # ])

    train_transforms = transforms.Compose([
        transforms.Resize(256),
        transforms.CenterCrop(256),
        transforms.RandomAffine(degrees=0, translate=(0.05, 0.05)),
        transforms.RandomHorizontalFlip(),
        transforms.ToTensor(),
        transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
    ])
    test_transforms = transforms.Compose([
        transforms.Resize(256),
        transforms.CenterCrop(256),
        transforms.ToTensor(),
        transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
    ])
    train_class_num=24
    random.seed(42)
    train_classes = random.sample(range(0, 40), train_class_num)

    trainset = GARBAGE40_Dataset(root='../data/garbage', train=True,
                                transform=test_transforms,
                                train_class_num=train_class_num, test_class_num=40,
                                includes_all_train_class=True, train_classes=train_classes)

    # testset=GARBAGE40_Dataset(root='../data/garbage', train=False,
    #                           transform=test_transforms,
    #                 train_class_num=40, test_class_num=40,
    #                 includes_all_train_class=True,train_classes=train_classes)
    trainloader=torch.utils.data.DataLoader(trainset, batch_size=128, shuffle=True, num_workers=4)
    # testloader = torch.utils.data.DataLoader(testset, batch_size=128, shuffle=False, num_workers=4)
    for i, (data, target) in enumerate(trainloader):
        print()
    end1 = time.perf_counter()
    print("final is in : %s Seconds " % (end1 - start1))

garbage_transform.py

'''
@File  :garbage_transform.py
@Author:cjh
@Date  :2022/2/8 12:38
@Desc  :
'''
import random
import math
import torch

from PIL import Image, ImageOps, ImageFilter
from torchvision import transforms

class Resize(object):
    def __init__(self, size, interpolation=Image.BILINEAR):
        self.size = size
        self.interpolation = interpolation

    def __call__(self, img):
        # padding
        ratio = self.size[0] / self.size[1]
        w, h = img.size
        if w / h < ratio:
            t = int(h * ratio)
            w_padding = (t - w) // 2
            img = img.crop((-w_padding, 0, w+w_padding, h))
        else:
            t = int(w / ratio)
            h_padding = (t - h) // 2
            img = img.crop((0, -h_padding, w, h+h_padding))

        img = img.resize(self.size, self.interpolation)

        return img

class RandomRotate(object):
    def __init__(self, degree, p=0.5):
        self.degree = degree
        self.p = p

    def __call__(self, img):
        if random.random() < self.p:
            rotate_degree = random.uniform(-1*self.degree, self.degree)
            img = img.rotate(rotate_degree, Image.BILINEAR)
        return img

class RandomGaussianBlur(object):
    def __init__(self, p=0.5):
        self.p = p
    def __call__(self, img):
        if random.random() < self.p:
            img = img.filter(ImageFilter.GaussianBlur(
                radius=random.random()))
        return img

class Cutout(object):
    def __init__(self, probability=0.5, size=64, mean=[0.4914, 0.4822, 0.4465]):
        self.probability = probability
        self.mean = mean
        self.size = size

    def __call__(self, img):

        if random.uniform(0, 1) > self.probability:
            return img

        h = self.size
        w = self.size
        for attempt in range(100):
            area = img.size()[1] * img.size()[2]
            if w < img.size()[2] and h < img.size()[1]:
                x1 = random.randint(0, img.size()[1] - h)
                y1 = random.randint(0, img.size()[2] - w)
                if img.size()[0] == 3:
                    img[0, x1:x1 + h, y1:y1 + w] = self.mean[0]
                    img[1, x1:x1 + h, y1:y1 + w] = self.mean[1]
                    img[2, x1:x1 + h, y1:y1 + w] = self.mean[2]
                else:
                    img[0, x1:x1 + h, y1:y1 + w] = self.mean[0]
                return img
        return img

class RandomErasing(object):
    """ Randomly selects a rectangle region in an image and erases its pixels.
        'Random Erasing Data Augmentation' by Zhong et al.
        See https://arxiv.org/pdf/1708.04896.pdf
    Args:
         probability: The probability that the Random Erasing operation will be performed.
         sl: Minimum proportion of erased area against input image.
         sh: Maximum proportion of erased area against input image.
         r1: Minimum aspect ratio of erased area.
         mean: Erasing value.
    """

    def __init__(self, probability=0.5, sl=0.02, sh=0.4, r1=0.3, mean=[0.4914, 0.4822, 0.4465]):
        self.probability = probability
        self.mean = mean
        self.sl = sl
        self.sh = sh
        self.r1 = r1

    def __call__(self, img):

        if random.uniform(0, 1) > self.probability:
            return img

        for attempt in range(100):
            area = img.size()[1] * img.size()[2]

            target_area = random.uniform(self.sl, self.sh) * area
            aspect_ratio = random.uniform(self.r1, 1 / self.r1)

            h = int(round(math.sqrt(target_area * aspect_ratio)))
            w = int(round(math.sqrt(target_area / aspect_ratio)))

            if w < img.size()[2] and h < img.size()[1]:
                x1 = random.randint(0, img.size()[1] - h)
                y1 = random.randint(0, img.size()[2] - w)
                if img.size()[0] == 3:
                    img[0, x1:x1 + h, y1:y1 + w] = self.mean[0]
                    img[1, x1:x1 + h, y1:y1 + w] = self.mean[1]
                    img[2, x1:x1 + h, y1:y1 + w] = self.mean[2]
                else:
                    img[0, x1:x1 + h, y1:y1 + w] = self.mean[0]
                return img

        return img