软件版本：

tensorflow 2.3.1
pytorch 1.6.0
onnxruntime 1.8.1
cv2 4.5.3
onnx_tf 1.8.0
onnx 1.10.1
pytorch模型转onnx

import cv2
import numpy as np
import torch.onnx
import onnxruntime
import random
# 为了保证pytorch每次输出结果相同
def set_seed(seed=1):
    random.seed(seed)
    np.random.seed(seed)
    torch.manaual_seed(seed)
    torch.cuda.manaual_seed(seed)
    torch.cuda.manaual_seed_all(seed)
    os.environ['PYTHONHASHSEED'] = str(seed)
    torch.backends.cudnn.determinstic = True
    torch.backends.cudnn.benchmark = False
def get_img_batch(img_path):
    # 具体预处理过程应根据模型训练代码具体确定，保持一致
    input_size = 224
    expand_size = int(input_size/0.875)
    img = cv2.imread(img_path)
    img = img[:,:,::-1]
    w,h = img.shape[1],img.shape[0]
    # equals to: transform.Resize(int), resize short side to int, keep ratio
    if w >= h:
        ratio = w / h
        w_ = expand_size * ratio
        h_ = expand_size
    else:
        ratio = h / w
        w_ = expand_size
        h_ = expand_size * ratio
    h_,w_ = int(h_),int(w_)
    img = cv2.resize(img, (w_,h_)) # 注意顺序
    # equals to: transforms.CenterCrop(int), center square crop
    w, h = img.shape[1],img.shape[0]
    midx,midy=int(w/2),int(h/2)
    cropx,cropy=int(input_size/2),int(input_size/2)
    img = img[midy-cropy:midy+cropy, midx-cropx:midx+cropx]
    # normalize
    mean = torch.tensor([0.485*255,0.456*255,0.406*255]).view(1,3,1,1)
    std = torch.tensor([0.229*255,0.224*255,0.225*255]).view(1,3,1,1)
    img_batch = torch.from_numpy(img).float().unsqueeze(0) # 'float32' and expand dims
    img_batch = img_batch.permute(0,3,1,2)
    img_batch = img_batch.sub_(mean).div_(std)
    return img_batch
def load_torch_model(backbone_path):
    pretrained_dict = torch.load(backbone_path)
    net = models.__dict__['mobilenetv2'](width_mult=1.0)
    model_dict = net.state_dict()
    pretrained_dict = {k:v for k,v in pretrained_dict.items() if (k in model_dict)}
    model_dict.update(pretrained_dict)
    net.load_state_dict(model_dict)
    net.eval() # 重要！为了保证pytorch每次输出结果相同
    return net
def torch_to_onnx(torch_model):
    batch_size = 1
    input_shape = (3,224,224)
    x = torch.ones(batch_size, *input_shape)
    onnx_path = 'model.onnx'
    # export and save the model
    torch.onnx.export(
        torch_model,
        onnx_path,
        opset_version=12,
        input_names = ['input'],
        output_names = ['output'],
# 对比测试结果
def compare_torch_onnx(torch_model,onnx_sess,img_batch):
    sess_out = onnx_sess.run(None, {'input': img_batch.numpy()})
    sess_out = sess_out[0].flatten()
    sess_out = np.array(sess_out, dtype='float32')
    sess_out = torch.from_numpy(sess_out) # output feature
    onnx_pred = torch.nn.functional.softmax(sess_out, dim=0)
    onnx_index = np.argmax(onnx_pred).item() # output class index
    torch_pred = torch_model(img_batch).detach().flatten() # feature
    torch_pred = torch.nn.functional.softmax(torch_pred, dim=0)
    torch_pred = np.array(torch_pred, dtype='float32')
    torch_index = np,argmax(torch_pred).item() # index
    # 判断转换前后特征值差异
    np.testing.assert_almost_equal(torch_pred, onnx_pred, decimal=6)
if __name__ == '__main__':
    set_seed()
    backbone_pth = 'model.pth.tar'
    onnx_model = onnxruntime.InferenceSeesion('model.onnx', None)
    torch_model = load_torch_model(backbone_pth)
    img_path = '1.jpg'
    img_batch = get_img_batch(img_path)
    # evaluation 
onnx模型转tensorflow
 
import onnx
from onnx_tf.backend import prepare
filename = 'model.onnx'
target_file_path = './tfmodel'
# load onnx model
onnx_model = onnx.load(filename)
tf_rep = prepare(onnx_model)
# save tf model to the path
tf_rep.export_graph(target_file_path)
tensorflow模型转tflite
 
# 因为上一步保存的模型文件已经是pb格式了，所以不用先转为pb，如果不是pb格式，参考：https://blog.csdn.net/qxqxqzzz/article/details/119668426?spm=1001.2014.3001.5501
def tf_tflite():
    tf_model_path, tflite_model_path = './tfmodel', 'model.tflite'
    converter = tf.lite.TFLiteCOnverter.from_saved_model(tf_model_path)
    converter.target_spec,supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINGS,tf.lite.OpsSet.SELECT_TF_OPS]
    tflite_model = converter.convert()
    with open(tflite_model_path, 'wb') as g:
        g.write(tflite_model)
def tflite_prediction(img_batch):
    tflite_model = 'model.tflite'
    interpreter = tf.lite.Interpreter(model_path = tflite_model)
    interpreter.allocate_tensors()
    input_details = interpreter.get_input_details()
    output_details = interpreter.get_output_details()
    interpreter,set_tensor(input_details[0]['index'], img_batch)
    interpreter.invoke()
    tflite_pred = interpreter.get_tensor(output_details[0]['index']) # output feature
    tflite_pred = tf.convert_to_tensor(tflite_pred)
    tflite_pred = tf.nn.softmax(tflite_pred)
    print(tf.argmax(tflite_pred, 1)) # output class index
				该存储库代表Ultralytics对未来的对象检测方法的开源研究，并结合了在匿名客户数据集上数千小时的培训和发展过程中汲取的经验教训和最佳实践。 所有代码和模型都在积极开发中，如有更改或删除，恕不另行通知。 使用风险自负。
 ** GPU速度使用批处理大小为32的V100 GPU测量超过5000张COCO val2017图像的平均每张图像的端到端时间，包括图像预处理，PyTorch FP16推理，后处理和NMS。 来自EfficientDet数据（批量大小为8）。
 2021年1月5日： ：nn.SiLU（）激活，记录， 集成。
 2020年8月13日： ：nn.Hardswish（）激活，数据自动下载，本机AMP。
 2020年7月23日： ：改进了模型定义，培训和mAP。
 2020年6月22日： 更新：新的刀头，减少的参数，提高的速度和mAP  。
 2020年6月19日： 作为新的默认设置，用于较小的检查点和更快的推断 。
预训练的检查站
AP VAL
AP 50
 速度V100
 FPS V100
				Pytorch训练的模型转.onnx、.pb、.h5、.tftilePytorch训练的模型转.onnx、.pb、.h5、.tftilePytorch模型导入Pytorch模型转.onnx、.pb、.h5.h5文件转.tftile文件
Pytorch训练的模型转.onnx、.pb、.h5、.tftile
由于深度学习训练出后的参数往往是保存在指定的模型中的，这在使用时将不是那么方便，同时为了减小训练出的模型所占的内存空间，通常只保存了模型的参数，而未将整个网络一起保存，这样便直接导致了保存的模型无法直接转换
				1. 搭建自己的简单二分类网络，使用pytorch训练和测试；          
2. 将pytorch训练的pth模型转换成ONNX，并编码测试；          
3. 含训练和测试数据，含训练ok的pth模型和ONNX模型，含完整python和C++实现；          
4. 使用方法：首先运行“TrainTestConvertOnnx.py”执行“训练数据读入、模型训练、模型测试、导出onnx”，再运行“TestOnnx.cpp”测试onnx（需要配置OpenCV）；
环境要求：python version >= 3.6
模型训练：python3 train.py
模型导出：python3 models/export.py --weights "xxx.pt"
转换rknn：python3 onnx_to_rknn.py
模型推理：python3 rknn_detect_yolov5.py
注意事项：如果训练尺寸不是640那么，anchors会自动聚类重新生成，生成的结果在训练时打印在控制台，或者通过动态查看torch模型类属性获取，如果anchors不对应那么结果就会出现问题。
建议：在训练时如果size不是640，那么可以先通过聚类得到anchors并将新的anchors写入到模型配置文件中，然后再训练，防止动态获取的anchors在rknn上预测不准的问题。训练参数别忘记加上 --noautoanchor
import onnx
# https://github.com/rwightman/gen-efficientnet-pytorch/blob/master/hubconf.py
model=torch.hub.load("rwightman/pytorch-image-models","mobilenetv3_large_100")
model.eval()
batch_size=1
input_shape = (3,244,244)
export_onnx_file="m.
				该存储库代表Ultralytics对未来的对象检测方法的开源研究，并结合了在匿名客户数据集上数千小时的培训和发展过程中汲取的经验教训和最佳实践。 所有代码和模型都在积极开发中，如有更改或删除，恕不另行通知。 使用风险自负。
 YOLOv5-P5 640图（单击展开）  图注释（单击以展开）
 GPU速度使用批处理大小为32的V100 GPU测量平均超过5000张COCO val2017图像的端到端时间，包括图像预处理，PyTorch FP16推理，后处理和NMS。
 来自EfficientDet数据（批量大小为8）。
 通过python test.py --task study --data coco.yaml --iou 0.7 --weights yolov5s6.pt yolov5m6.pt yolov5l6.pt yolov5x6.pt复制- python test.py --ta
				通知： 存储库现在分为两个分支：
 ：与所有模型和方法向前兼容（推荐）。 
$ git clone https://github.com/ultralytics/yolov3  # master branch (default)
 ：向后兼容原始 * .cfg模型（  :warning_selector: 不再维护）。 
$ git clone -b archive https://github.com/ultralytics/yolov3  # archive branch
 ** GPU速度使用批处理大小为32的V100 GPU测量超过5000张COCO val2017图像的平均每张图像的端到端时间，包括图像预处理，PyTorch FP16推理，后处理和NMS。 来自EfficientDet数据（批量大小为8）。
预训练的检查站
AP VAL
AP 50
 加速GPU
 FPS GPU
 4.8毫秒
 6190万
156.4B
 4.9毫秒
 6300万
让我们看看有关yolo v4（pytorch后端）的出色性能！！
更新（5/3）：增强小物品
在yolo v4中，缺少缺少对小物件的检测的缺点。 我试图解决短缺问题。 我发现解决此问题的最佳方法是在stride = 8 Yolo Layer（76 * 76）中修改对象
 您所需要做的就是设置YoloLayer small_item_enhance = True（仅效果76 * 76 head）
 for module in detector.model.modules():
    if isinstance(module,Yolo
        print('\nStarting ONNX export with onnx %s...' % onnx.__version__)
        f = opt.weights.replace('.pth', '.onnx').replace('.pt', '.onnx')   # filename
        torch.onnx.export(model, img, f, verbo
				<h3>回答1：</h3><br/>要将PyTorch的.pth模型转换为ONNX格式，可以使用以下步骤：
1. 安装ONNX包：在终端中运行`pip install onnx`来安装ONNX包。
2. 加载PyTorch模型：使用PyTorch加载模型并将其转换为ONNX格式。例如，可以使用以下代码加载PyTorch模型：
   import torch
   import torchvision
   # 加载PyTorch模型
   model = torchvision.models.resnet18(pretrained=True)
   # 将模型转换为eval模式
   model.eval()
   # 创建一个虚拟输入张量
   input_tensor = torch.randn(1, 3, 224, 224)
   # 导出模型为ONNX格式
   torch.onnx.export(model, input_tensor, "resnet18.onnx")
   在这个例子中，我们加载了一个预训练的ResNet18模型，并将其转换为ONNX格式。我们还创建了一个虚拟输入张量，它将用于导出模型。
3. 验证ONNX模型：可以使用ONNX Runtime或其他ONNX兼容的推理引擎来验证导出的ONNX模型。例如，可以使用以下代码验证导出的ResNet18模型：
   import onnx
   import onnxruntime
   # 加载ONNX模型
   onnx_model = onnx.load("resnet18.onnx")
   # 验证模型
   onnx.checker.check_model(onnx_model)
   # 创建一个ONNX Runtime会话
   ort_session = onnxruntime.InferenceSession("resnet18.onnx")
   # 运行模型
   ort_inputs = {ort_session.get_inputs()[].name: input_tensor.numpy()}
   ort_outputs = ort_session.run(None, ort_inputs)
   # 打印输出
   print(ort_outputs)
   在这个例子中，我们使用ONNX Runtime创建了一个会话，并使用虚拟输入张量运行了模型。我们还打印了模型的输出。   
<h3>回答2：</h3><br/>PyTorch是流行的深度学习框架之一，而ONNX（Open Neural Network Exchange）是一个开源的跨平台深度学习框架，可以方便地让用户在多个平台上运行模型。在机器学习和深度学习应用中，模型的转换和共享非常重要，而pth模型转ONNX模型可以更加高效地在多个平台上利用训练好的模型。本文将介绍如何使用PyTorch将pth模型转换为ONNX模型。
首先，需要安装PyTorch和ONNX。在安装好这两个框架之后，使用以下代码将pth模型转换为ONNX模型：
import torch
import onnx
# 加载pth模型
model = torch.load('model.pth')
# 将pth模型转换为onnx模型
input_names = ['input']
output_names = ['output']
dynamic_axes = {'input':{0:'batch_size'},'output':{0:'batch_size'}}
x = torch.randn(1, 3, 224, 224)
torch.onnx.export(model, x, "model.onnx", input_names=input_names, output_names=output_names, dynamic_axes=dynamic_axes)
在此代码片段中，`input_names`和`output_names`分别表示网络的输入和输出节点名称。`dynamic_axes`参数确定哪些轴是变化的，这是非常重要的，因为不同的框架可能需要特定的推理数据格式。在这个例子中，`dynamic_axes`参数将输入和输出数据的第一维指定为“batch_size”，因为第一维是数据样本数量，可能因推断过程而变化。
在代码运行完毕后，可以得到一个ONNX模型，可以将其部署到ONNX支持的设备上进行推理，例如移动设备和边缘计算设备。
需要注意的是，将pth模型转换为ONNX模型有一些限制和注意事项：
1. PyTorch支持的操作不一定是ONNX支持的。要将模型成功转换为ONNX格式，使用的PyTorch操作必须是ONNX支持的。
2. ONNX不支持大部分运行时计算。因此，如果使用了一些需要计算图中的其他参数的操作（如动态图），则不能将模型成功转换为ONNX格式。
3. 一些PyTorch操作（如Dropout）在训练和推断过程中有不同的行为。因此，需要在代码中明确指定模型的模式，以确保在转换和推理过程中得到正确的结果。
综上所述，pth模型转ONNX模型可以方便地在多个平台上部署和使用训练好的模型，需要仔细注意输入输出节点、动态轴和框架支持的操作等细节。   
<h3>回答3：</h3><br/>PyTorch是一个非常流行和广泛使用的深度学习框架。在深度学习中，常常需要将训练得到的模型转换为一种可移植的格式，如ONNX。这样可以让我们在不同的框架和设备上使用模型。
将PyTorch模型转换为ONNX需要以下步骤。
第一步是安装必要的库和工具包。我们需要安装最新版本的PyTorch和ONNX。可以在PyTorch的官方网站和ONNX的GitHub页面上找到安装说明。
第二步是准备PyTorch模型。在PyTorch中，我们可以使用torch.save将模型保存为.pth文件。这个文件包含了模型的权重和架构。
第三步是使用torch.onnx.export将模型转换为ONNX格式。这个函数需要指定PyTorch模型、输入张量和输出文件的路径。我们还可以使用其他参数来设置转换的选项，如输入和输出名称、数据类型和设备类型等。
第四步是验证转换的结果。我们可以使用ONNX Runtime或其他支持ONNX格式的框架加载模型，输入数据并进行推理。通过比较转换前后的输出，我们可以确认转换的正确性。
需要注意的是，PyTorch模型和ONNX模型在一些细节上可能存在差异。例如，PyTorch中的一些操作可能没有对应的ONNX实现，或者ONNX中的一些操作可能需要特定的属性和参数。因此，在进行模型转换时，需要了解两种格式的差异，并根据实际需求进行调整。
总之，PyTorch模型转换为ONNX格式可以让我们更加方便地在不同的框架和设备上使用模型，是深度学习工作中不可或缺的一部分。
				requests.exceptions.MissingSchema: Invalid URL 'h': No schema supplied. Perhaps you meant http://h?
					41742