本教程系列將從模型訓練開始，從0開始帶領你部署Yolov5模型到jetson nano上
這是本系列的第二部分內容
目錄
1.更換源
2.更改環境變數
2.2測驗CUDA
2.3安裝pip3
2 .4安裝GPU版的tensorflow
2.5安裝pycuda
3.1下載tensorrtx的原始碼
3.2模型測驗
1.更換源
Ubuntu跟Windows不同，能從官方指定的源服務器上下載安裝各種軟體,不用滿世界找，但是默認的源可能在國外，速度很慢，有
的包無法安裝，所謂換源就是更改源服務器，一般換成國內的，
簡單通俗點來說就是，如果你希望加快下載各種包的速度要做的事情
我用的一般都是清華源，也有用中科大的源
先備份本身的源，防止誤操作后無法洗掉
這里沒有用vim，gedit更加方便
sudo cp /etc/apt/sources.list /etc/apt/sources.list.bak #為防止誤操作后無法恢復，先備份原檔案sources.list
sudo gedit /etc/apt/sources.list 然后洗掉所有內容，復制以下內容，保存
deb http://mirrors.tuna.tsinghua.edu.cn/ubuntu-ports/ bionic main multiverse restricted universe
deb http://mirrors.tuna.tsinghua.edu.cn/ubuntu-ports/ bionic-security main multiverse restricted universe
deb http://mirrors.tuna.tsinghua.edu.cn/ubuntu-ports/ bionic-updates main multiverse restricted universe
deb http://mirrors.tuna.tsinghua.edu.cn/ubuntu-ports/ bionic-backports main multiverse restricted universe
deb-src http://mirrors.tuna.tsinghua.edu.cn/ubuntu-ports/ bionic main multiverse restricted universe
deb-src http://mirrors.tuna.tsinghua.edu.cn/ubuntu-ports/ bionic-security main multiverse restricted universe
deb-src http://mirrors.tuna.tsinghua.edu.cn/ubuntu-ports/ bionic-updates main multiverse restricted universe
deb-src http://mirrors.tuna.tsinghua.edu.cn/ubuntu-ports/ bionic-backports main multiverse restricted universe
別忘記更新一下哦
sudo apt-get update2.更改環境變數
在更改環境變數之前，記得確定好cuda的版本，在添加環境變數的時候，因為cuda的版本原因導致的錯誤很常見，輸入下面路徑查看cuda版本
cd /usr/local
ls如上圖所示，cuda版本為10.2，那么路徑也為cuda-10.2現在就可以添加環境變數了
sudo gedit ~/.bashrc在文本的最后添加以下三行：
export PATH=/usr/local/cuda-10.2/bin:$PATH
export LD_LIBRARY_PATH=/usr/local/cuda/lib64:$LD_LIBRARY_PATH
export CUDA_HOME=$CUDA_HOME:/usr/local/cuda-10.2
重新執行.bashrc檔案，可以直接生效；
source ~/.bashrc輸入nvcc -V命令測驗環境變數是否正確
nvcc -V 
2.2測驗CUDA
依次輸入下面的命令測驗cuda
cd /usr/src/cudnn_samples_v8/mnistCUDNN
sudo make
sudo chmod a+x mnistCUDNN
./mnistCUDNN
等待片刻后，出現test passed表明成功（如下圖）
2.3安裝pip3
可能有同學要問了，pip是個啥，其實這不重要，你可以把他當作一個下載器，pip是Python 的包管理器，python已經來到了3.0版本，如果用pip的話，下載下來的包會保存在python2.7版本的路徑下，總之，最后用pip3來下載安裝python的各類包，避免后期出現麻煩
sudo apt-get install python3-pip python3-dev如果在使用的程序中出現報不能匯入’main’錯誤
打開路徑 "/usr/bin/"下的pip3檔案，
將內容
from pip import main
if __name__ == '__main__':
sys.exit(main())
修改為
from pip import __main__
if __name__ == '__main__':
sys.exit(__main__._main())2 .4安裝GPU版的tensorflow
首先得安裝一些依賴
sudo apt-get install libhdf5-serial-dev hdf5-tools安裝GPU版本的tensorflow
pip3 install --extra-index-url https://developer.download.nvidia.com/compute/redist/jp/v42 tensorflow-gpu==1.13.1+nv19.3 --user如果說你對自己安裝的tensorflow版本不太放心，或者在下載程序中網路斷開的話，不妨用下面的代碼測驗一下
import tensorflow as tf
with tf.device('/cpu:0'):
a = tf.constant([1.0,2.0,3.0],shape=[3],name='a')
b = tf.constant([1.0,2.0,3.0],shape=[3],name='b')
with tf.device('/gpu:1'):
c = a+b
sess = tf.Session(config=tf.ConfigProto(allow_soft_placement=True,log_device_placement=True))
sess.run(tf.global_variables_initializer())
print(sess.run(c))
安裝一些機器學習常用的庫
sudo apt-get install python3-numpy
sudo apt-get install python3-scipy
sudo apt-get install python3-pandas
sudo apt-get install python3-matplotlib
sudo apt-get install python3-sklearn
2.5安裝pycuda
pycuda-2019.1.2點擊下載pycuda2019版本pycuda-2019.1.2 這里有pycuda的github原始碼，里面有各種pycuda版本，但是可能會出現一些版本不兼容的問題
https://github.com/inducer/pycuda
下載完成后來到下載好的路徑下，終端打開，依次輸入下解壓安裝
tar zxvf pycuda-2019.1.2.tar.gz
cd pycuda-2019.1.2/
python3 configure.py --cuda-root=/usr/local/cuda-10.2
sudo python3 setup.py install
安裝程序中出現類似下圖中的內容可以暫時忽略
稍作等待幾分鐘，直到出現安裝完成
3.1下載tensorrtx的原始碼
很高興你能來到這里，到這里已經完成了一半，是不是覺得很麻煩，別擔心，當你完成了部署結果一定會讓你很興奮的
進入tensorrtx的官網，下載你訓練時對應的yolov5的版本，點擊左上角的master-->tags-->yolov5
如：yolov5-4.0版本的模型，要下載yolo5版本的tensorrtx進行部署，否則在生成引擎檔案時會出現報錯
點擊右邊綠色的Code，然后Download ZIP
下載完成后，來到下載目錄下，輸入以下命令解壓,我這里是v5.0版本
unzip tensorrtx-yolov5-v5.0.zip
把之前訓練的模型生成的wts權重檔案放到tensorrtx的yolov5檔案夾中
沒有wts檔案只是想體驗強大的jetson nano的同學可以先下載一下我的五類垃圾分類權重檔案
鏈接: https://pan.baidu.com/s/1nciB7Xn1vXj9ZfBAoj39Bw 提取碼: r74h
來到tensorrtx的yolov5檔案夾，打開yololayer.h的代碼，修改CLASS_NUM
創建進入檔案夾build并cmake ..
mkdir build
cd build
cmake ..
make -j6
生成引擎檔案
sudo ./yolov5 -s ../best.wts best.engine s 這一段模型引擎生成的命令解釋如下
sudo ./yolov5 -s/ [.wts檔案路徑] [.engine檔案名稱] [s/m/l/x/s6/m6/l6/x6 or c/c6 gd gw]
稍作等待后，出現Build engine successfully！表示生成完成，這時build檔案夾里面會多出一個best.engine檔案
3.2模型測驗
到這里，恭喜你已經完成了模型的部署，我們放自己根據官方的yolov5_trt改的代碼來測驗一下
是不是很棒！
"""
# Yolov5 基于pytorch，修改起來更加方便快捷；
# yolov5自帶anchor生成器，自動為你的資料集生成最優化的anchor；
# yolov5的整體AP比yolov4更高，
"""
import ctypes
import os
import random
import sys
import threading
import time
# 安裝串口函式庫 sudo pip3 install pyserial
import serial as ser # 匯入串口庫
import cv2
import numpy as np # 構造ndarray物件
import pycuda.autoinit
import pycuda.driver as cuda
import tensorrt as trt
from time import sleep
# from jetcam.csi_camera import CSICamera
# import torch
# import torchvision#在nano上安裝這兩個庫是有些麻煩的特別是torchvision，
INPUT_W = 640
INPUT_H = 640
CONF_THRESH = 0.8 # 概率閾值
IOU_THRESHOLD = 0.1
# 定義畫框函式
def plot_one_box(x, img, color=None, label=None, line_thickness=None):
'''
description: Plots one bounding box on image img,
this function comes from YoLov5 project.
param:
x: a box likes [x1,y1,x2,y2]
img: a opencv image object
label: str
line_thickness: int
return:
no return
'''
# img, result_boxes, result_scores, result_classid = yolov5_wrapper.infer(img)
# img = draw_boxes(img, result_boxes, result_scores, result_classid)
tl = (
line_thickness or round(0.002 * (img.shape[0] + img.shape[1]) / 2) + 1
) # line/font thickness
color = color or [random.randint(0, 255) for _ in range(3)]
c1, c2 = (int(x[0]), int(x[1])), (int(x[2]), int(x[3]))
cv2.rectangle(img, c1, c2, color, thickness=tl, lineType=cv2.LINE_AA)
# print("left:(" + str(c1[0]) + "," + str(c1[1]) +")","right:(" + str(c2[0]) + "," + str(c2[1])+ ")")
a = int(c1[0])
b = int(c2[0])
c = int(c1[1])
d = int(c2[1])
x1 = (b + a) / 2
x = int(x1)
y1 = (d + c) / 2
y = int(y1)
r = label[2:6] #rate
sleep(0.0009)
c =str(label[0]) #class
# print(c)
# if(c == 0):
# r0 = label[2:6]
# elif(c == 1):
# r1 = label[2:6]
# elif(c == 2):
# r2 = label[2:6]
# elif(c == 3):
# r3 = label[2:6]
# elif(c == 4):
# r4 = label[2:6]
# # output_str = ('[' + str(x) + ',' + str(y) + ',' +str(c) + ']'+'\r\n')
# if(c == 3 or r3>r0 or r3>r2 or r3>r1 or r3>r4):
# print('[' + str(x) + ',' + str(y) + ',' +str(3) + ']'+'\r\n')
# else:
# print(r)
# print(x,y)
#se.write(str(label))
#print(label[0])
#print(r)#label rate
#se.write((int(x) + ',' + int(y) + ',' +int(label[0]) + '\r\n').encode())
# output_str = ('[' + str(x) + ',' + str(y) + ',' +str(label[0]) + ']'+'\r\n')
# print(output_str)
# print(r)
# se.write(output_str.encode())
# sleep(0.0009)
# se.write((x + y + '\r\n').encode())
if label:
tf = max(tl - 1, 1) # font thickness
t_size = cv2.getTextSize(label, 0, fontScale=tl / 3, thickness=tf)[0]
c2 = c1[0] + t_size[0], c1[1] - t_size[1] - 3
cv2.rectangle(img, c1, c2, color, -1, cv2.LINE_AA) # filled
cv2.putText(
img,
label,
(c1[0], c1[1] - 2),
0,
tl / 3,
[225, 255, 255],
thickness=tf,
lineType=cv2.LINE_AA,
)
return x, y
# 畫框函式
def draw_boxes(image_raw, result_boxes, result_scores, result_classid):
max_scores = -1
max_index = -1
max_x,max_y = -1,-1
for i in range(len(result_boxes)):
box = result_boxes[i]
x, y = plot_one_box(
box,
image_raw,
label="{}:{:.2f}".format(
categories[int(result_classid[i])], result_scores[i]
)
)
# print(result_classid[i])
# se.write((str(x) + ',' + str(y) + ',' + str(result_classid[i]) + '\r\n').encode())
# global max_score
if result_boxes.all() > max_scores:
max_scores = result_scores[i]
max_index = i
max_x, max_y = x, y
if max_scores != -1:
c = int(result_classid[max_index])
output_str = ('[' + str(x) + ',' + str(y) + ',' +str(c) + ']'+'\r\n')
print(output_str)
se.write(output_str.encode())
sleep(0.0009)
return image_raw
# yolov5模型轉到TensorRT中推理
# 定義yolov5轉trt的類 start
class YoLov5TRT(object):
"""
description: A YOLOv5 class that warps TensorRT ops, preprocess and postprocess ops.
"""
def __init__(self, engine_file_path):
# Create a Context on this device,
self.ctx = cuda.Device(0).make_context()
stream = cuda.Stream()
TRT_LOGGER = trt.Logger(trt.Logger.INFO)
runtime = trt.Runtime(TRT_LOGGER)
# Deserialize the engine from file
with open(engine_file_path, "rb") as f:
engine = runtime.deserialize_cuda_engine(f.read())
context = engine.create_execution_context()
host_inputs = []
cuda_inputs = []
host_outputs = []
cuda_outputs = []
bindings = []
for binding in engine:
size = trt.volume(engine.get_binding_shape(binding)) * engine.max_batch_size
dtype = trt.nptype(engine.get_binding_dtype(binding))
# Allocate host and device buffers
host_mem = cuda.pagelocked_empty(size, dtype)
cuda_mem = cuda.mem_alloc(host_mem.nbytes)
# Append the device buffer to device bindings.
bindings.append(int(cuda_mem))
# Append to the appropriate list.
if engine.binding_is_input(binding):
host_inputs.append(host_mem)
cuda_inputs.append(cuda_mem)
else:
host_outputs.append(host_mem)
cuda_outputs.append(cuda_mem)
# Store
self.stream = stream
self.context = context
self.engine = engine
self.host_inputs = host_inputs
self.cuda_inputs = cuda_inputs
self.host_outputs = host_outputs
self.cuda_outputs = cuda_outputs
self.bindings = bindings
# 釋放引擎，釋放GPU顯存，釋放CUDA流
def __del__(self):
print("delete object to release memory")
def infer(self, input_image_path):
threading.Thread.__init__(self)
# Make self the active context, pushing it on top of the context stack.
self.ctx.push()
# Restore
stream = self.stream
context = self.context
engine = self.engine
host_inputs = self.host_inputs
cuda_inputs = self.cuda_inputs
host_outputs = self.host_outputs
cuda_outputs = self.cuda_outputs
bindings = self.bindings
# Do image preprocess
input_image, image_raw, origin_h, origin_w = self.preprocess_image(
input_image_path
)
# Copy input image to host buffer
np.copyto(host_inputs[0], input_image.ravel())
start = time.time()
# Transfer input data to the GPU.
cuda.memcpy_htod_async(cuda_inputs[0], host_inputs[0], stream)
# Run inference.
context.execute_async(bindings=bindings, stream_handle=stream.handle)
# Transfer predictions back from the GPU.
cuda.memcpy_dtoh_async(host_outputs[0], cuda_outputs[0], stream)
# Synchronize the stream
stream.synchronize()
end = time.time()
# Remove any context from the top of the context stack, deactivating it.
self.ctx.pop()
# Here we use the first row of output in that batch_size = 1
output = host_outputs[0]
# Do postprocess
result_boxes, result_scores, result_classid = self.post_process(
output, origin_h, origin_w
)
# Draw rectangles and labels on the original image
# for i in range(len(result_boxes)):
# box = result_boxes[i]
# plot_one_box(
# box,
# image_raw,
# label="{}:{:.2f}".format(
# categories[int(result_classid[i])], result_scores[i]
# ),
# )
# parent, filename = os.path.split(input_image_path)
# save_name = os.path.join(parent, "output_" + filename)
## Save image
# cv2.imwrite(save_name, image_raw)
# print('{:.2f}ms, saving {}'.format((end - start) * 1000, save_name))
return image_raw, result_boxes, result_scores, result_classid
def destroy(self):
# Remove any context from the top of the context stack, deactivating it.
self.ctx.pop()
def preprocess_image(self, image_raw):
"""
description: Read an image from image path, convert it to RGB,
resize and pad it to target size, normalize to [0,1],
transform to NCHW format.
param:
input_image_path: str, image path
return:
image: the processed image
image_raw: the original image
h: original height
w: original width
"""
h, w, c = image_raw.shape
image = cv2.cvtColor(image_raw, cv2.COLOR_BGR2RGB)
# Calculate widht and height and paddings
r_w = INPUT_W / w
r_h = INPUT_H / h
if r_h > r_w:
tw = INPUT_W
th = int(r_w * h)
tx1 = tx2 = 0
ty1 = int((INPUT_H - th) / 2)
ty2 = INPUT_H - th - ty1
else:
tw = int(r_h * w)
th = INPUT_H
tx1 = int((INPUT_W - tw) / 2)
tx2 = INPUT_W - tw - tx1
ty1 = ty2 = 0
# Resize the image with long side while maintaining ratio
image = cv2.resize(image, (tw, th))
# Pad the short side with (128,128,128)
image = cv2.copyMakeBorder(
image, ty1, ty2, tx1, tx2, cv2.BORDER_CONSTANT, (128, 128, 128)
)
image = image.astype(np.float32)
# Normalize to [0,1]
image /= 255.0
# HWC to CHW format:
image = np.transpose(image, [2, 0, 1])
# CHW to NCHW format
image = np.expand_dims(image, axis=0)
# Convert the image to row-major order, also known as "C order":
image = np.ascontiguousarray(image)
return image, image_raw, h, w
def xywh2xyxy(self, origin_h, origin_w, x):
"""
description: Convert nx4 boxes from [x, y, w, h] to [x1, y1, x2, y2] where xy1=top-left, xy2=bottom-right
param:
origin_h: height of original image
origin_w: width of original image
x: A boxes tensor, each row is a box [center_x, center_y, w, h]
return:
y: A boxes tensor, each row is a box [x1, y1, x2, y2]
"""
y = np.zeros_like(x)
# y = torch.zeros_like(x) if isinstance(x, torch.Tensor) else np.zeros_like(x)
r_w = INPUT_W / origin_w
r_h = INPUT_H / origin_h
if r_h > r_w:
y[:, 0] = x[:, 0] - x[:, 2] / 2
y[:, 2] = x[:, 0] + x[:, 2] / 2
y[:, 1] = x[:, 1] - x[:, 3] / 2 - (INPUT_H - r_w * origin_h) / 2
y[:, 3] = x[:, 1] + x[:, 3] / 2 - (INPUT_H - r_w * origin_h) / 2
y /= r_w
else:
y[:, 0] = x[:, 0] - x[:, 2] / 2 - (INPUT_W - r_h * origin_w) / 2
y[:, 2] = x[:, 0] + x[:, 2] / 2 - (INPUT_W - r_h * origin_w) / 2
y[:, 1] = x[:, 1] - x[:, 3] / 2
y[:, 3] = x[:, 1] + x[:, 3] / 2
y /= r_h
return y
# 往YoLov5TRT這個類中加入一個方法，此處是用numpy的方式實作nms
def nms(self, boxes, scores, iou_threshold=IOU_THRESHOLD): # 非極大值抑制，是目標檢測框架中的后處理模塊
# 空間距離結合并交比(IOU)完成聚類劃分
x1 = boxes[:, 0]
y1 = boxes[:, 1]
x2 = boxes[:, 2]
y2 = boxes[:, 3]
areas = (y2 - y1 + 1) * (x2 - x1 + 1)
scores = scores
keep = []
index = scores.argsort()[::-1]
while index.size > 0:
i = index[0] # every time the first is the biggst, and add it directly
keep.append(i)
x11 = np.maximum(x1[i], x1[index[1:]]) # calculate the points of overlap
y11 = np.maximum(y1[i], y1[index[1:]])
x22 = np.minimum(x2[i], x2[index[1:]])
y22 = np.minimum(y2[i], y2[index[1:]])
w = np.maximum(0, x22 - x11 + 1) # the weights of overlap
h = np.maximum(0, y22 - y11 + 1) # the height of overlap
overlaps = w * h
ious = overlaps / (areas[i] + areas[index[1:]] - overlaps)
idx = np.where(ious <= iou_threshold)[0]
index = index[idx + 1] # because index start from 1
# print(overlaps)
# print(x1)
# sleep(1)
return keep
# 把nms的結果賦值給indices變數，改寫post_process函式
def post_process(self, output, origin_h, origin_w):
"""
description: postprocess the prediction
param:
output: A tensor likes [num_boxes,cx,cy,w,h,conf,cls_id, cx,cy,w,h,conf,cls_id, ...]
origin_h: height of original image
origin_w: width of original image
return:
result_boxes: finally boxes, a boxes tensor, each row is a box [x1, y1, x2, y2]
result_scores: finally scores, a tensor, each element is the score correspoing to box
result_classid: finally classid, a tensor, each element is the classid correspoing to box
"""
# Get the num of boxes detected
num = int(output[0])
# Reshape to a two dimentional ndarray
pred = np.reshape(output[1:], (-1, 6))[:num, :]
# to a torch Tensor
# pred = torch.Tensor(pred).cuda()#去掉這行，用torchvision庫中的nms方法來完成非極大值抑制，
# Get the boxes
boxes = pred[:, :4]
# Get the scores
scores = pred[:, 4]
# Get the classid
classid = pred[:, 5]
# Choose those boxes that score > CONF_THRESH
si = scores > CONF_THRESH
boxes = boxes[si, :]
scores = scores[si]
classid = classid[si]
# Trandform bbox from [center_x, center_y, w, h] to [x1, y1, x2, y2]
boxes = self.xywh2xyxy(origin_h, origin_w, boxes)
# Do nms
# 去掉cpu方法，因為ndarray沒有這個方法
# indices = torchvision.ops.nms(boxes, scores, iou_threshold=IOU_THRESHOLD).cpu()
# result_boxes = boxes[indices, :].cpu()
# result_scores = scores[indices].cpu()
# result_classid = classid[indices].cpu()
indices = self.nms(boxes, scores, IOU_THRESHOLD)
result_boxes = boxes[indices, :]
result_scores = scores[indices]
result_classid = classid[indices]
# print(result_boxes)
# print(result_classid)
return result_boxes, result_scores, result_classid
class myThread(threading.Thread):
def __init__(self, func, args):
threading.Thread.__init__(self)
self.func = func
self.args = args
def run(self):
self.func(*self.args)
# 攝像頭檢測
def detect_camera(camera, yolov5_wrapper):
# def detect_camera(x,camera, yolov5_wrapper):
count = 0
# c1, c2 = (int(x[0]), int(x[1])), (int(x[2]), int(x[3]))
# cv2.rectangle(img, c1, c2, color, thickness=tl, lineType=cv2.LINE_AA)
# print("left:(" + str(c1[0]) + "," + str(c1[1]) +")","right:(" + str(c2[0]) + "," + str(c2[1])+ ")")
# x = str(c1[0])
# y = str(c1[1])
# print(x)
# 開始回圈檢測
while True:
# img = camera.read()#CSI攝像頭
ret, img = camera.read() # usb攝像頭用這個
img, result_boxes, result_scores, result_classid = yolov5_wrapper.infer(img)
img = draw_boxes(img, result_boxes, result_scores, result_classid)
count = count + 1
cv2.imshow("result", img) # 顯示結果
if cv2.waitKey(1) == ord('q'):
break
# 定義攝像頭函式
def main_camera():
camera = cv2.VideoCapture(0) # usb攝像頭用這個
# camera = CSICamera(capture_device=0, width=640, height=480)
# load custom plugins
camera.set(3, 640)
camera.set(4, 480)
PLUGIN_LIBRARY = "build/libmyplugins.so"
ctypes.CDLL(PLUGIN_LIBRARY)
engine_file_path = "build/yolov5s.engine"
# YoLov5TRT instance
yolov5_wrapper = YoLov5TRT(engine_file_path)
print("start detection!")
detect_camera(camera, yolov5_wrapper)
# camera.release() # 使用cv方法打開攝像頭才需要這句
cv2.destroyAllWindows()
print("\nfinish!")
if __name__ == "__main__":
# load custom plugins 修改成你build出來的引擎的相對路徑
PLUGIN_LIBRARY = "build/libmyplugins.so"
ctypes.CDLL(PLUGIN_LIBRARY)
engine_file_path = "build/yolov5s.engine"
se = ser.Serial('/dev/ttyTHS1', 115200, timeout=0.5) # 設定使用的引腳、波特率和超時時間 8接R,10接T
# load coco labels
# categories = ['battery', 'orange', 'bottle', 'paper_cup', 'spitball'] # 垃圾種類
categories = ['0', '1', '2', '3', '4'] # 垃圾種類
# a YoLov5TRT instance
# yolov5_wrapper = YoLov5TRT(engine_file_path)
# input_image_paths = ["samples/zidane.jpg", "samples/bus.jpg"]
# for input_image_path in input_image_paths:
# # create a new thread to do inference
# thread1 = myThread(yolov5_wrapper.infer, [input_image_path])
# thread1.start()
# thread1.join()
#writen by lyj
## destroy the instance
# yolov5_wrapper.destroy()
main_camera()
#context.pop()
參考文章
jetson nano安裝pycuda！！！_帥的發光發亮的博客-CSDN博客_jetson nano安裝pycuda
(26條訊息) Jetson Nano配置與使用（5）cuda測驗及tensorflow gpu安裝_u013617229的博客-CSDN博客
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/335555.html
標籤：python