The model is converted to onnx format using dynamic batch precision collapse about onnx HOT 8 OPEN

import argparse
from torch.utils.data import DataLoader
import numpy as np
from tqdm import tqdm
from dataset import tobacco_dataset
from Model.swin_transformer_DSU import *
import onnx
import onnxruntime as ort
from PIL import Image
from torchvision.transforms import transforms


parser = argparse.ArgumentParser("Training")

parser.add_argument('--image_size', type=int, default=448)
parser.add_argument('--batch_size', type=int, default=32)

args = parser.parse_args()
img_size = args.image_size
results = dict()




    knownloader = DataLoader(dataset=known_dataset, batch_size=args.batch_size, shuffle=False, num_workers=2)
    unknownloader = DataLoader(dataset=unknown_dataset, batch_size=args.batch_size, shuffle=False, num_workers=2)


    F = SwinTransformer(img_size=448, patch_size=4, in_chans=3, num_classes=1000,
                        embed_dim=128, depths=[2, 2, 18, 2], num_heads=[4, 8, 16, 32],
                        window_size=7, mlp_ratio=4., qkv_bias=True, qk_scale=None,
                        # window_size=14, mlp_ratio=4., qkv_bias=True, qk_scale=None,
                        drop_rate=0., attn_drop_rate=0., drop_path_rate=0.1,
                        norm_layer=nn.LayerNorm, ape=False, patch_norm=True,
                        use_checkpoint=False
                        # use_checkpoint=True
                        )  # the feature dim is 1024

    net = STAN_OSFGR(F, num_classes=8)

    net.load_state_dict(torch.load(weight_path[i]))

    net = net.cuda()
    net.eval()
    onnx_model_name = r"./Rmodel.onnx"
    onnx_model = onnx.load(onnx_model_name)
    onnx.checker.check_model(onnx_model)

    session = ort.InferenceSession(onnx_model_name, providers=['CUDAExecutionProvider'])
    input_name = session.get_inputs()[0].name
    output_name=session.get_outputs()[0].name


    correct_ori, total_ori = 0, 0
    correct_fp16, total_fp16 = 0, 0
    correct_fp32, total_fp32 = 0, 0
    correct_onnx,total_onnx=0,0

    torch.cuda.empty_cache()


    _pred_u, _labels = [], []
    _pred_ori, _pred_uori= [], []
    _pred_onnx,_pred_uonnx=[],[]

    batch_num = 0
    for batch_idx, (data, labels, _) in enumerate(tqdm(knownloader, desc='know')):
        img, labels = data.cuda(), labels.cuda()
        with torch.no_grad():
             outputs_LSTM = net(img)
        batch_num += 1
        predictions_ori = outputs_LSTM.data.max(1)[1]
        total_ori += labels.size(0)
        correct_ori += (predictions_ori == labels.data).sum()
        _pred_ori.append(outputs_LSTM.data.cpu().numpy())
        _labels.append(labels.data.cpu().numpy())

        input_data = img.cpu().numpy()
        outputs_onnx= session.run(None, {input_name: input_data})
        predictions_onnx=np.argmax(outputs_onnx[0],axis=1)
        total_onnx+=labels.size(0)
        correct_onnx+=(predictions_onnx==labels.data.cpu().numpy()).sum()
        _pred_onnx.append(outputs_onnx[0])



    acc_ori = float(correct_ori) * 100. / float(total_ori)
    acc_onnx=float(correct_onnx)*100. /float(total_onnx)

    print('net_ori Acc: {:.5f}'.format(acc_ori))
    print('net_onnx Acc: {:.5f}'.format(acc_onnx))