提升篇 | 優化 YOLOv8 以加快推理速度
作者：二旺
如果你有一塊高級GPU，使用TensorRT是最佳選擇。然而，如果你在配備Intel CPU的計算機上工作，OpenVINO是首選。
為了一項研究，我需要減少YOLOv8的推理時間。在這項研究中，我使用了自己的電腦而不是Google Colab。我的電腦有一個Intel i5（第12代）處理器，我的GPU是NVIDIA GeForce RTX 3050。這些信息很重要，因為我在一些方法中使用了CPU，在其他方法中使用了GPU。
原始模型使用情況
為了測試，我們使用了Ultralytics提供的YOLOv8n.pt模型，并使用bus.jpg圖像進行評估。我們將分析獲得的時間值和結果。要了解模型的性能，還要知道它運行在哪個設備上——無論是使用CUDA GPU還是CPU。
# cuda
import cv2
import matplotlib.pyplot as plt
from ultralytics import YOLO
import torch
yolov8model = YOLO("yolov8n.pt")
img = cv2.imread("bus.jpg")
results = yolov8model.predict(source=img, device='cuda')
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
for result in results:
boxes = result.boxes
for box in boxes:
x1, y1, x2, y2 = box.xyxy[0].tolist()
confidence = box.conf[0].item()
class_id = int(box.cls[0].item())
cv2.rectangle(img, (int(x1), int(y1)), (int(x2), int(y2)), (255, 0, 0), 2)
cv2.putText(img, f'ID: {class_id} Conf: {confidence:.2f}',
(int(x1), int(y1)-10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 0, 0), 2)
used_device = next(yolov8model.model.parameters()).device
print("Model is running on:", used_device)
plt.figure(figsize=(10, 10))
plt.imshow(img)
plt.axis('off')
plt.show()
# cpu
import cv2
import matplotlib.pyplot as plt
from ultralytics import YOLO
import torch
yolov8model = YOLO("yolov8n.pt")
img = cv2.imread("bus.jpg")
results = yolov8model.predict(source=img, device='cpu')
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
for result in results:
boxes = result.boxes
for box in boxes:
x1, y1, x2, y2 = box.xyxy[0].tolist()
confidence = box.conf[0].item()
class_id = int(box.cls[0].item())
cv2.rectangle(img, (int(x1), int(y1)), (int(x2), int(y2)), (255, 0, 0), 2)
cv2.putText(img, f'ID: {class_id} Conf: {confidence:.2f}',
(int(x1), int(y1)-10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 0, 0), 2)
plt.figure(figsize=(10, 10))
plt.imshow(img)
plt.axis('off')
plt.show()
used_device = next(yolov8model.model.parameters()).device
print("Model is running on:", used_device)
現在，我們有一個起點。具體來說，對于bus.jpg圖像，模型在CPU上的推理時間是199.7毫秒，在GPU上是47.2毫秒。
剪枝
我們使用的第一個方法是剪枝模型。剪枝改變了模型并創建了一個更高效的版本。有些方法修改了模型本身，而其他方法改變了輸入或直接影響推理。在剪枝中，模型中較不重要或影響最小的連接被移除。這導致了一個更小、更快的模型，但它可能會對準確性產生負面影響。
import torch
import torch.nn.utils.prune as prune
from ultralytics import YOLO
def prune_model(model,amount=0.3):
for module in model.modules():
if isinstance(module,torch.nn.Conv2d):
prune.l1_unstructured(module,name="weight",amount=amount)
prune.remove(module,"weight")
return model
model = YOLO("yolov8n.pt")
#results= model.val(data="coco.yaml")
#print(f"mAP50-95: {results.box.map}")
torch_model = model.model
print(torch_model)
print("Prunning model...")
pruned_torch_model = prune_model(torch_model,amount=0.1)
print("Model pruned.")
model.model =pruned_torch_model
print("Saving pruned model...")
model.save("yolov8n_trained_pruned.pt")
print("Pruned model saved.")通常，一種方法被用來比較數據集；然而，在這個例子中，使用了大約18 GB的數據集的通用yolov8n.pt模型。在這個例子中，沒有使用coco.yaml文件。
我將分享使用的GPU的結果，我們將更新比較圖，因為應用不同的參數時時間可能會改變。通常，我無法弄清楚時間為何會改變，但這可能是由于內存或其他因素。
# cuda pruned
import cv2
import matplotlib.pyplot as plt
from ultralytics import YOLO
import torch
yolov8model = YOLO("yolov8n_trained_pruned.pt")
img = cv2.imread("bus.jpg")
results = yolov8model.predict(source=img, device='cuda')
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
for result in results:
boxes = result.boxes
for box in boxes:
x1, y1, x2, y2 = box.xyxy[0].tolist()
confidence = box.conf[0].item()
class_id = int(box.cls[0].item())
cv2.rectangle(img, (int(x1), int(y1)), (int(x2), int(y2)), (255, 0, 0), 2)
cv2.putText(img, f'ID: {class_id} Conf: {confidence:.2f}',
(int(x1), int(y1)-10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 0, 0), 2)
used_device = next(yolov8model.model.parameters()).device
print("Model is running on:", used_device)
plt.figure(figsize=(10, 10))
plt.imshow(img)
plt.axis('off')
plt.show()
正如你看到的，結果有點令人困惑；ID和blob不準確。
然而，當我們比較推理時間時，剪枝模型在CPU和GPU上都比原始模型表現略好。剪枝模型的問題是它會影響結果，但它減少了模型的推理時間。
改變批量大小
在確定模型訓練或預測的批量大小時，我們模型中同時處理的幀數至關重要。我創建了一個循環來識別最優批量大小，因為增加批量大小有時可能會產生負面影響。然而，我注意到每次嘗試時最優批量大小都會改變。我嘗試平均結果，但這種方法是不充分的。為了說明我的發現，我將分享一張我的初步試驗的表格，用紅點突出顯示最優批量大小。
import cv2
import matplotlib.pyplot as plt
from ultralytics import YOLO
import torch
import time
yolov8model = YOLO("yolov8n.pt")
img = cv2.imread("bus.jpg")
img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
inference_times = []
for batch_size in range(1, 41):
start_time = time.time()
results = yolov8model.predict(source=img_rgb, device='cuda', batch=batch_size)
end_time = time.time()
inference_time = end_time - start_time
inference_times.append((batch_size, inference_time))
print(f"Batch Size: {batch_size}, Inference Time: {inference_time:.4f} seconds")
plt.figure(figsize=(10, 5))
batch_sizes = [bt[0] for bt in inference_times]
times = [bt[1] for bt in inference_times]
min_time_index = times.index(min(times))
min_batch_size = batch_sizes[min_time_index]
min_inference_time = times[min_time_index]
plt.plot(batch_sizes, times, marker='o')
plt.plot(min_batch_size, min_inference_time, 'ro', markersize=8)
plt.title('Inference Time vs. Batch Size')
plt.xlabel('Batch Size')
plt.ylabel('Inference Time (seconds)')
plt.xticks(batch_sizes)
plt.grid()
plt.show()
best_results = yolov8model.predict(source=img_rgb, device='cuda', batch=min_batch_size)
for result in best_results:
boxes = result.boxes
for box in boxes:
x1, y1, x2, y2 = box.xyxy[0].cpu().numpy()
conf = box.conf[0].cpu().numpy()
cls = int(box.cls[0].cpu().numpy())
cv2.rectangle(img, (int(x1), int(y1)), (int(x2), int(y2)), (0, 0, 255), 2)
cv2.putText(img, f'Class: {cls}, Conf: {conf:.2f}', (int(x1), int(y1) - 10),
cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 2)
plt.figure(figsize=(10, 10))
plt.imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
plt.title(f'Results with Batch Size {min_batch_size}')
plt.axis('off')
plt.show()
硬件加速方法
為了提高YOLOv8模型的性能，另一個選擇是使用硬件加速。為此目的有幾種工具可用，比如TensorRT和OpenVINO。
1.TensorRT
TensorRT是一種使用NVIDIA硬件優化推理效率的方法。在這部分中，我使用了帶有T4 GPU的Google Colab來比較標準模型和TensorRT優化模型的性能。讓我們從如何將我們的模型轉換為TensorRT格式開始。首先，我們需要將模型文件上傳到Colab，然后編寫以下代碼：
from ultralytics import YOLO
model = YOLO("yolov8n.pt")
model.export(format="engine")然后，我們使用bus.jpg測試模型，TensorRT優化模型的推理時間為6.6毫秒。相比之下，標準模型的推理時間為6.9毫秒。從結果來看，由于更先進的T4硬件，TensorRT模型的性能略優于標準模型。
import cv2
import matplotlib.pyplot as plt
from ultralytics import YOLO
import torch
yolov8model = YOLO('yolov8n.engine')
img = cv2.imread("bus.jpg")
results = yolov8model.predict(source=img, device='cuda')
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
for result in results:
boxes = result.boxes
for box in boxes:
x1, y1, x2, y2 = box.xyxy[0].tolist()
confidence = box.conf[0].item()
class_id = int(box.cls[0].item())
cv2.rectangle(img, (int(x1), int(y1)), (int(x2), int(y2)), (255, 0, 0), 2)
cv2.putText(img, f'ID: {class_id} Conf: {confidence:.2f}',
(int(x1), int(y1)-10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 0, 0), 2)
used_device = yolov8model.device
print("Model is running on:", used_device)
plt.figure(figsize=(10, 10))
plt.imshow(img)
plt.axis('off')
plt.show()
2.OpenVINO
OpenVINO是一個主要為優化模型性能而設計的套件，特別是在Intel硬件上。它可以顯著提高CPU性能，通常在常規使用中可提高多達3倍。讓我們從將我們的模型轉換為OpenVINO格式開始。
from ultralytics import YOLO
# Load a YOLOv8n PyTorch model
model = YOLO("yolov8n.pt")
# Export the model
model.export(format="openvino") # creates 'yolov8n_openvino_model/'
# Load the exported OpenVINO model
ov_model = YOLO("yolov8n_openvino_model/")
import cv2
import matplotlib.pyplot as plt
from ultralytics import YOLO
yolov8model = YOLO('yolov8n_openvino_model/', task="detect")
img = cv2.imread("bus.jpg")
results = yolov8model.predict(source=img)
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
for result in results:
boxes = result.boxes
for box in boxes:
x1, y1, x2, y2 = box.xyxy[0].tolist()
confidence = box.conf[0].item()
class_id = int(box.cls[0].item())
cv2.rectangle(img, (int(x1), int(y1)), (int(x2), int(y2)), (255, 0, 0), 2)
cv2.putText(img, f'ID: {class_id} Conf: {confidence:.2f}',
(int(x1), int(y1)-10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 0, 0), 2)
plt.figure(figsize=(10, 10))
plt.imshow(img)
plt.axis('off')
plt.show()
正如你看到的，在CPU性能上OpenVINO模型的推理時間略有下降。以下是我嘗試的不同方法的比較結果。
總之，如果你有一塊高級GPU，使用TensorRT是最佳選擇。然而，如果你在配備Intel CPU的計算機上工作，OpenVINO是首選。不同的方法會導致不同的推理時間，因此每種方法都進行了多次測試以觀察差異。
責任編輯：趙寧寧
來源：
小白玩轉Python
