Completado por: Lu Yutian - Embajador de innovación de Intel Edge Computing
Manual oficial: Introducción al producto - Intel Digital Development Kit
Después de desempacar, podemos ver la placa y los tornillos de la columna de cobre como se muestra en la imagen. Lo primero que debemos hacer es atornillarlo a las cuatro esquinas de la placa X e insertar los tornillos desde el lado del ventilador hacia abajo. a los cuatro orificios más en las esquinas, y luego atornille los pilares de cobre y los tornillos en la parte inferior (como se muestra en la imagen), como se muestra en la figura:
A continuación, podemos encender la alimentación; solo necesita enchufar la alimentación, y después de un tiempo después de ver girar el ventilador, ¡puede ver cómo se inicia el sistema de Windows en la pantalla! Si no arranca, puedes encontrar el pequeño punto negro en el otro extremo del mismo lado que la toma de corriente y presionarlo para que arranque normalmente.
A continuación, puede realizar operaciones normales en Windows, como si usara su propia computadora (puede conectarse directamente a wifi, si la conexión falla, puede intentar reiniciar o jugar ligeramente con la antena); pero me gusta tirar, y luego le mostraré cómo reinstalarlo en el sistema ubuntu e iniciar el razonamiento del programa de aprendizaje profundo bajo el sistema ubuntu.
Mirando la documentación en caso de problemas, notamos que la instalación del sistema - Intel Digital Development Kit , decidió usar la versión de Canonical optimizada para Intel.
Aquí elijo según la CPU:
Después de seleccionar la imagen para descargar, puede elegir crear un disco de arranque o usar un inventario de software de código abierto para colocarlo en un disco U, luego reinicie la computadora y haga clic en la tecla F2 para ingresar al BIOS, y luego siga los pasos en el documento para entrar en la interfaz de instalación.
Una vez completada la instalación, reinicie para ingresar con éxito al sistema:
Por supuesto, no olvide instalar la compatibilidad con el controlador GPU al final, puede usar GPU en openvino después de la instalación.
mkdir neo && cd neo
wget https://ghproxy.com/https://github.com/intel/intel-graphics-compiler/releases/download/igc-1.0.11702.1/intel-igc-core_1.0.11702.1_amd64.1.deb
wget https://ghproxy.com/https://github.com/intel/intel-graphics-compiler/releases/download/igc-1.0.11702.1/intel-igc-opencl_1.0.11702.1_amd64.deb
wget https://ghproxy.com/https://github.com/intel/compute-runtime/releases/download/22.35.24055/intel-level-zero-gpu-dbgsym_1.3.24055_amd64.ddeb
wget https://ghproxy.com/https://github.com/intel/compute-runtime/releases/download/22.35.24055/intel-level-zero-gpu_1.3.24055_amd64.deb
wget https://ghproxy.com/https://github.com/intel/compute-runtime/releases/download/22.35.24055/intel-opencl-icd_22.35.24055_amd64.deb
wget https://ghproxy.com/https://github.com/intel/compute-runtime/releases/download/22.35.24055/libigdgmm12_22.1.3_amd64.deb
sudo dpkg -i *.debUna vez finalizada la instalación , reinicie.
Para la conveniencia de la operación, puede instalar la herramienta de control remoto en este momento para operar o ver el ip direct SSH correspondiente (recuerde instalar openssh ), pero aquí se recomienda otro gran método; puede instalar Vscode y luego usar su Túnel Complemento Para la conexión de túnel remoto (que simula la penetración de intranet), solo necesita instalar los complementos necesarios, luego abrir Vscode "Abrir acceso de túnel remoto" y luego simultáneamente en su computadora Abra Vscode , instale el complemento ssh remoto y busque los túneles remotos para acceder a la computadora correspondiente para ingresar con éxito al entorno Xboard.
Si desea acceder a la versión ubuntu de Xboard con herramientas remotas, recuerde instalar las herramientas de la siguiente manera:
sudo apt-get install lightdm selecciona lightdm
entonces
sudo dpkg-reconfigure gdm3Seleccione lightdm y luego reinicie.
A continuación, entremos en el proceso de desarrollo formal. Primero, podemos comprobar el rendimiento de Xboard a través de openvino 's benchmark_app . Primero, instale openvino .
pip install openvino-dev -i Simple Index
pip install openvino -i https://pypi.tuna.tsinghua.edu.cn/simple
Una vez completada la instalación, podemos ingresar benchmark_app -h en la línea de comando.Si aparece el siguiente resultado, significa que openvino se instaló correctamente.
A continuación, usaremos Paddle PicoDet para demostrar brevemente el proceso de uso de OpenVINO en la placa Aix . Primero, echemos un vistazo a Paddle PicoDet . Como modelo adecuado para su implementación en placas de desarrollo perimetrales, PicoDet puede garantizar una cierta precisión de mAP. En ejecución. velocidad:
Podemos combinar la herramienta de la aplicación de referencia para simplemente estimar la velocidad de ejecución final aproximada del modelo. Primero, necesitamos descargar el modelo correspondiente: https://github.com/PaddlePaddle/PaddleDetection/tree/release/2.6/configs/picodet
Vale la pena recordar que muchos operadores involucrados en el proceso de posprocesamiento no son naturalmente compatibles con el marco de razonamiento, por lo que necesitamos
Encuentre el modelo exportado sin procesamiento posterior en modelzoo , puede hacer clic en la siguiente dirección para descargarlo directamente: https://paddledet.bj.bcebos.com/deploy/Inference/picodet_xs_320_coco_lcnet_non_postprocess.tar
Después de abrir, puede ver el siguiente archivo, que es el modelo de imagen estática exportado por picodet.Gracias a la buena compatibilidad entre Paddle y OpenVINO , podemos cargar y usar directamente el modelo de imagen estática de Paddle sin convertirlo en un modelo OpenVINO ( OpenVINO IR ).
Podemos ingresar el siguiente código de prueba para obtener los resultados reales de la prueba de FPS en la GPU , lo que nos proporcionará una buena información de rendimiento inicial. Puede encontrar información de parámetros específicos en benchmark_app -h , o ir al sitio web oficial para obtener información relevante.
benchmark_app -m picodet_xs_320_coco_lcnet_non_postprocess/model.pdmodel -d GPU -api async -t 15Si la operación es exitosa, verá los siguientes resultados: (Si la operación falla y hay errores como que no se puede encontrar la tarjeta gráfica, debe reinstalar el controlador GPU mencionado al principio del artículo y reiniciar la placa Aix Debido a las fluctuaciones de la red, debe confirmar que los controladores están completos, descargados e instalados)
Se puede ver que en el caso de un uso completamente asíncrono de la inferencia de GPU , teóricamente podemos admitir al menos dos inferencias en tiempo real de video o cámara ( 320x320 ). Algunos amigos pueden pensar que el mAP del modelo PicoDet-XS es solo 23.5 es demasiado pequeño, entonces podemos usar el modelo PicoDet-S , 29.1 mAP puede satisfacer las necesidades básicas y la velocidad es relativamente aceptable:
Después de pasar la prueba de rendimiento, podemos ejecutar directamente el programa de detección correspondiente. En https://github.com/PaddlePaddle/PaddleDetection/tree/release/2.6/deploy/third_engine/demo_openvino/python , puede obtener todas las operaciones requeridas código. Podemos descargar directamente o copiar y pegar estos tres archivos en la carpeta de trabajo del Xboard.
Vale la pena señalar que el modelo picodet_xs_320_coco_lcnet_non_postprocess/model.pdmodel que usamos anteriormente pertenece a una red que no contiene ningún procesamiento posterior y requiere el uso del archivo openvino_benchmark.py para ejecutarse. Para un modelo que incluye procesamiento posterior pero no incluye NMS , debe usar el archivo openvino_infer.py para ejecutar, y también debe descargar el modelo onnx correspondiente ( con procesamiento posterior ; sin NMS) , como como: https://paddledet .bj.bcebos.com/deploy/third_engine/picodet_xs_320_lcnet_postproccesed_woNMS.onnx
Podemos poner una imagen para ser detectada en el directorio a voluntad, y modificar la configuración de la siguiente manera para ejecutarla con un solo clic:
La parte de openvino_benchmark.py que necesita ser modificada:
La parte de openvino_infer.py que necesita ser modificada:
Después de la modificación, ejecute el archivo python correspondiente directamente para ver el resultado de la detección, y el resultado se guarda en el archivo res.jpg en el directorio .
Finalmente, para demostrar el efecto de la detección de transmisión de video en tiempo real, podemos descargar un video al azar y luego ejecutar el siguiente código para iniciar la detección de transmisión de video (también puede cambiar la lectura de la transmisión de video a 0, es decir, lea la cámara local para la detección ) :
import cv2
import numpy as np
import time
import argparse
from scipy.special import softmax
from openvino.runtime import Core
from openvino_benchmark import PicoDetPostProcess,draw_box
def image_preprocess(image, re_shape):
img = cv2.resize(
image, (re_shape, re_shape), interpolation=cv2.INTER_LANCZOS4)
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
img = np.transpose(img, [2, 0, 1]) / 255
img = np.expand_dims(img, 0)
img_mean = np.array([0.485, 0.456, 0.406]).reshape((3, 1, 1))
img_std = np.array([0.229, 0.224, 0.225]).reshape((3, 1, 1))
img -= img_mean
img /= img_std
return img.astype(np.float32)
def infer(src_img,input_img):
output = compiled_model.infer_new_request({0: input_img})
result_ie = list(output.values())
test_im_shape = np.array([[320, 320]]).astype('float32')
test_scale_factor = np.array([[1, 1]]).astype('float32')
np_score_list = []
np_boxes_list = []
num_outs = int(len(result_ie) / 2)
for out_idx in range(num_outs):
np_score_list.append(result_ie[out_idx])
np_boxes_list.append(result_ie[out_idx + num_outs])
postprocess = PicoDetPostProcess(input_img.shape[2:], test_im_shape,
test_scale_factor)
np_boxes, _ = postprocess(np_score_list, np_boxes_list)
scale_x = src_img.shape[1] / input_img.shape[3]
scale_y = src_img.shape[0] / input_img.shape[2]
res_image = draw_box(src_img, np_boxes, class_label, scale_x, scale_y)
res_image = src_img
return res_image
MODEL_PATH = "picodet_xs_320_coco_lcnet_non_postprocess/model.pdmodel"
class_label= "coco_label.txt"
if __name__ == "__main__":
# openvino init
ie = Core()
net = ie.read_model(MODEL_PATJ)
compiled_model = ie.compile_model(net, 'CPU')
cap = cv2.VideoCapture("行人.mp4")
if not cap.isOpened():
print("无法打开视频流")
exit()
frame_count = 0
start_time = time.time()
while True:
ret, frame = cap.read()
input_img = image_preprocess(frame, 320)
res_img = infer(frame,input_img)
frame_count += 1
elapsed_time = time.time() - start_time
if elapsed_time > 1:
fps = frame_count / elapsed_time
print("实时帧速率 (FPS): {:.2f}".format(fps))
start_time = time.time()
frame_count = 0
if not ret:
break
cv2.imshow("Video Stream", res_img)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
cap.release()
cv2.destroyAllWindows()
A partir de esto, podemos observar que la velocidad de fotogramas se puede mantener básicamente entre 15 y 20 FPS , pero en este momento, algunos amigos querrán preguntar, ¿no medimos el resultado mucho más alto que esto en la prueba de rendimiento anterior? Sí, de hecho, el rendimiento de detección en el verdadero sentido es mucho mayor que esto, porque en este momento el cuello de botella no es la detección en sí, y es muy probable que el procesamiento posterior y la decodificación de video tomen más tiempo. Puede tomar tecnologías más profundas para resolver estos cuellos de botella técnicos (como reemplazar la decodificación dura o usar c ++ api para implementar el proceso de razonamiento, cambiar al razonamiento asíncrono OpenVINO , etc.), creo que después de usar estas operaciones, su rendimiento de detección mejorará Definitivamente ser mejor un piso.
Hasta ahora, se ha realizado todo el proceso de un Xboard simple desde el flasheo a OpenVINO . Espero que puedas seguir este tutorial para desbloquear tu experiencia OpenVINO a la perfección. ¡Te deseo una feliz exploración en el mundo de OpenVINO y Xboard!