230
第三章?OpenVINO? 多案例實(shí)訓(xùn)
上篇內(nèi)容我們重點(diǎn)介紹了OpenVINO? 的核心組件以及重要工具。通過系統(tǒng)學(xué)習(xí)，我們已經(jīng)掌握OpenVINO? 是如何通過模型優(yōu)化器及推理引擎實(shí)現(xiàn)推理加速功能，掌握了使用OpenVINO??開發(fā)人工智能應(yīng)用的流程。本篇我們再通過5個(gè)案例-midasnet單目深度視覺應(yīng)用、超圖片及視頻的超級分辨應(yīng)用、圖像去背景應(yīng)用、圖片風(fēng)格轉(zhuǎn)換、PaddleGan超級分辨率繼續(xù)鞏固學(xué)習(xí)成果，從而達(dá)成熟能生巧、一通百通的目標(biāo)。
我們再來回顧下AI應(yīng)用的開發(fā)流程以及推理引擎的使用流程，鞏固加深印象。
圖3-1 AI應(yīng)用開發(fā)流程
準(zhǔn)備模型，準(zhǔn)備推理，性能調(diào)試，選擇合適的軟硬件最終完成AI應(yīng)用開發(fā)。
圖3-2 openvino-api推理引擎使用流程
初始化推理引擎、讀取加載IR文件、配置輸入輸出、載入模型、準(zhǔn)備輸入數(shù)據(jù)、執(zhí)行推理、處理推理結(jié)果并顯示。
3.1midasnet單目深度估算
深度估計(jì)是從單一RGB圖像中估計(jì)場景圖像中物體的深度，是一個(gè)從二維到三維的過程。人類的視覺系統(tǒng)是天生的雙目系統(tǒng)，即使遮住一只眼睛，通過大腦的計(jì)算可以實(shí)時(shí)生成深度信息甚至空間的三維建模。對于計(jì)算機(jī)來說，深度估算則是一個(gè)較為艱難的過程。
單目深度估計(jì)在機(jī)器人、三維重建、醫(yī)學(xué)成像和自動(dòng)駕駛等方面有許多潛在的應(yīng)用。但相對于3D激光雷達(dá)及雙目攝像頭、深度攝像頭等專有設(shè)備，單目深度估算方法的硬件需求較低，因而受到了研究的熱捧，受到了更多的關(guān)注。在案例演示中，我們使用了Embodied AI基金會開發(fā)的MiDaS的神經(jīng)網(wǎng)絡(luò)模型。關(guān)于模型的更多信息請參考：Towards Robust Monocular Depth Estimation: Mixing Datasets for Zero-shot Cross-dataset Transfer。鏈接：（
https://ieeexplore.ieee.org/document/9178977)
學(xué)習(xí)目標(biāo)：
認(rèn)識單目深度估算算法及了解應(yīng)用場景
掌握推理引擎使用流程并熟練應(yīng)用
掌握不同輸入源的處理方法及推理結(jié)果展現(xiàn)方法
實(shí)訓(xùn)環(huán)節(jié)：
3.1.1?? 圖片的單目深度模型推理
作為熱身，我們先對圖片進(jìn)行推理及展示。
1、 導(dǎo)入模塊
圖3-3 vision-monodepth導(dǎo)入模塊
import?sys
import?time
from?pathlib?import?Path
import?cv2
import?matplotlib.cm
import?matplotlib.pyplot?as?plt
import?numpy?as?np
from?IPython.display?import?(
HTML,
FileLink,
Pretty,
ProgressBar,
Video,
clear_output,
display,
)
from?openvino.inference_engine?import?IECore
sys.path.append("../utils")
from?notebook_utils?import?load_image
本案例中沒有新增模塊，從某種意義上說明在中篇所學(xué)到的模塊已經(jīng)可以支撐我們開發(fā)應(yīng)用。當(dāng)然知識的海洋是無邊界的，未來還有很多可以提升效率的模塊等待我們?nèi)ヌ剿靼l(fā)現(xiàn)，甚至我們可以開發(fā)模塊為生態(tài)貢獻(xiàn)力量。
2、 設(shè)置參數(shù)及準(zhǔn)備功能函數(shù)
圖3-4 vision-monodepth設(shè)置推理引擎參數(shù)
DEVICE?=?"CPU"
MODEL_FILE?=?"model/MiDaS_small.xml"
model_xml_path?=?Path(MODEL_FILE)
在這一步驟中我們設(shè)置CPU為推理引擎設(shè)備，并且指定了模型的路徑
圖3-5 vision-monodepth定義功能函數(shù)
def?normalize_minmax(data):
"""Normalizes?the?values?in?`data`?between?0?and?1"""
return?(data?-?data.min())?/?(data.max()?-?data.min())
def?convert_result_to_image(result,?colormap="viridis"):
"""
Convert?network?result?of?floating?point?numbers?to?an?RGB?image?with
integer?values?from?0-255?by?applying?a?colormap.
`result`?is?expected?to?be?a?single?network?result?in?1,H,W?shape
`colormap`?is?a?matplotlib?colormap.
See?https://matplotlib.org/stable/tutorials/colors/colormaps.html
"""
cmap?=?matplotlib.cm.get_cmap(colormap)
result?=?result.squeeze(0)
result?=?normalize_minmax(result)
result?=?cmap(result)[:,?:,?:3]?*?255
result?=?result.astype(np.uint8)
return?result
def?to_rgb(image_data)?->?np.ndarray:
"""
Convert?image_data?from?BGR?to?RGB
"""
return?cv2.cvtColor(image_data,?cv2.COLOR_BGR2RGB)
這里定義了三個(gè)功能函數(shù)分別實(shí)現(xiàn)了歸一化處理、推理結(jié)果處理以及色彩空間轉(zhuǎn)換。便于在后續(xù)程序中使用。
3、 加載模型
圖3-6 vision-monodepth加載模型并配置輸入輸出
ie?=?IECore()
net?=?ie.read_network(model=model_xml_path,?weights=model_xml_path.with_suffix(".bin"))
exec_net?=?ie.load_network(network=net,?device_name=DEVICE)
input_key?=?list(exec_net.input_info)[0]
output_key?=?list(exec_net.outputs.keys())[0]
network_input_shape?=?exec_net.input_info[input_key].tensor_desc.dims
network_image_height,?network_image_width?=?network_input_shape[2:]
遵循OpenVINO? 推理引擎使用流程，在這一步中，完成了推理引擎初始化、讀取網(wǎng)絡(luò)模型、加載網(wǎng)絡(luò)、配置輸入輸出的操作
4、 處理輸入圖片
加載、調(diào)整大小和重塑輸入圖片，用OpenCV讀取輸入圖像，調(diào)整為網(wǎng)絡(luò)輸入尺寸，并重塑為（N,C,H,W）格式（H=高度，W=寬度，C=通道數(shù)量，N=圖像數(shù)量）
圖3-7 vision-monodepth圖片預(yù)處理
MAGE_FILE?=?"data/coco_bike.jpg"
image?=?load_image(path=IMAGE_FILE)
#?調(diào)整大小，使其成為網(wǎng)絡(luò)的輸入形狀
resized_image?=?cv2.resize(src=image,?dsize=(network_image_height,?network_image_width))
#?將圖像重塑為網(wǎng)絡(luò)輸入形狀?NCHW
input_image?=?np.expand_dims(np.transpose(resized_image,?(2,?0,?1)),?0)
5、 進(jìn)行推理
進(jìn)行推理，將結(jié)果轉(zhuǎn)換為圖像，并將其大小調(diào)整為原始圖像的形狀
圖3-8 vision-monodepth推理并處理結(jié)果
result?=?exec_net.infer(inputs={input_key:?input_image})[output_key]
#?將差異地圖的網(wǎng)絡(luò)結(jié)果轉(zhuǎn)換為圖像，顯示出
#?以顏色顯示距離
result_image?=?convert_result_to_image(result=result)
#?調(diào)整大小回到原始圖像的形狀。cv2.resize期待形狀
#?在（寬度，高度），[::-1]反轉(zhuǎn)（高度，寬度）的形狀以匹配這個(gè)
result_image?=?cv2.resize(result_image,?image.shape[:2][::-1])
6、 展示結(jié)果
圖3-9 vision-monodepth圖片推理結(jié)果展示
fig,?ax?=?plt.subplots(1,?2,?figsize=(20,?15))
ax[0].imshow(to_rgb(image))
ax[1].imshow(result_image);
從結(jié)果中我們可以看出，我們在平面圖像中通過顏色區(qū)分展示出深度效果。
3.1.2? ?視頻的單目深度模型推理
對視頻進(jìn)行推理相對于圖片推理，無論在輸入源的預(yù)處理以及結(jié)果的后處理都要復(fù)雜一些，小試牛刀之后，我們學(xué)習(xí)如何針對視頻進(jìn)行推理。
需要注意的是，對視頻進(jìn)行推理是延續(xù)圖片推理的環(huán)境，因此并沒有重復(fù)加載模塊、配置及初始化推理引擎，如果作為獨(dú)立應(yīng)用，我們還是要遵循標(biāo)準(zhǔn)的流程。導(dǎo)入模塊、配置及初始化推理引擎、輸入源預(yù)處理、進(jìn)行推理并處理結(jié)果、結(jié)果展示。
1、 配置輸入視頻
圖3-10 vision-monodepth配置輸入視頻源
VIDEO_FILE?=?"data/Coco?Walking?in?Berkeley.mp4"
#?要處理的輸入視頻的秒數(shù)。設(shè)置為0來處理
#?完整的視頻
NUM_SECONDS?=?4
#?將ADVANCE_FRAMES 設(shè)為 1，以處理輸入視頻的每一幀。
#?將ADVANCE_FRAMES設(shè)置為2，以處理每第二幀。這可以減少
#?處理視頻所需的時(shí)間
ADVANCE_FRAMES?=?2
#?設(shè)置SCALE_OUTPUT來減小結(jié)果視頻的大小
#?如果SCALE_OUTPUT是0.5，結(jié)果視頻的寬度和高度
#?將是輸入視頻寬度和高度的一半
SCALE_OUTPUT?=?0.5
#?用于視頻編碼的格式。VP09很慢。
#?但它在大多數(shù)系統(tǒng)上都能工作。
#?如果你安裝了FFMPEG，可以嘗試使用THEO編碼。
#?FOURCC?=?cv2.VideoWriter_fourcc(*"THEO")
FOURCC?=?cv2.VideoWriter_fourcc(*"vp09")
#?為輸入視頻和結(jié)果視頻創(chuàng)建路徑對象
output_directory?=?Path("output")
output_directory.mkdir(exist_ok=True)
result_video_path?=?output_directory?/?f"{Path(VIDEO_FILE).stem}_monodepth.mp4"
默認(rèn)情況下，只有前4秒、100幀被處理，以便快速得到結(jié)果。通過改變NUM_FRAMES的值可以配置要處理的視頻的幀數(shù)。如果NUM_FRAMES設(shè)置為0則表示處理完整視頻。
2、 加載視頻
圖3-11 vision-monodepth配置輸入視頻源
cap?=?cv2.VideoCapture(str(VIDEO_FILE))
ret,?image?=?cap.read()
if?not?ret:
raise?ValueError(f"The?video?at?{VIDEO_FILE}?cannot?be?read.")
input_fps?=?cap.get(cv2.CAP_PROP_FPS)
input_video_frame_height,?input_video_frame_width?=?image.shape[:2]
target_fps?=?input_fps?/?ADVANCE_FRAMES
target_frame_height?=?int(input_video_frame_height?*?SCALE_OUTPUT)
target_frame_width?=?int(input_video_frame_width?*?SCALE_OUTPUT)
cap.release()
print(
f"The?input?video?has?a?frame?width?of?{input_video_frame_width},?"
f"frame?height?of?{input_video_frame_height}?and?runs?at?{input_fps:.2f}?fps"
)
print(
"The?monodepth?video?will?be?scaled?with?a?factor?"
f"{SCALE_OUTPUT},?have?width?{target_frame_width},?"
f"?height?{target_frame_height},?and?run?at?{target_fps:.2f}?fps"
)
我們利用OpenCV函數(shù)從`VIDEO_FILE`加載視頻。打開視頻文件，讀取幀寬、幀高和幀率，并計(jì)算單深度視頻的這些屬性值，并且將參數(shù)打印出來。
3、 進(jìn)行推理并且創(chuàng)建推理結(jié)果的視頻
圖3-12 vision-monodepth推理并保存結(jié)果
#?初始化變量
input_video_frame_nr?=?0
start_time?=?time.perf_counter()
total_inference_duration?=?0
#?打開視頻文件
cap?=?cv2.VideoCapture(str(VIDEO_FILE))
#?創(chuàng)建結(jié)果視頻
out_video?=?cv2.VideoWriter(
str(result_video_path),
FOURCC,
target_fps,
(target_frame_width?*?2,?target_frame_height),
)
num_frames?=?int(NUM_SECONDS?*?input_fps)
total_frames?=?cap.get(cv2.CAP_PROP_FRAME_COUNT)?if?num_frames?==?0?else?num_frames
progress_bar?=?ProgressBar(total=total_frames)
progress_bar.display()
try:
while?cap.isOpened():
ret,?image?=?cap.read()
if?not?ret:
cap.release()
break
if?input_video_frame_nr?>=?total_frames:
break
#?只處理每一秒的幀
#?為推理準(zhǔn)備框架
#?調(diào)整大小以適應(yīng)網(wǎng)絡(luò)的輸入形狀
resized_image?=?cv2.resize(src=image,?dsize=(network_image_height,?network_image_width))
#?將圖像重塑為網(wǎng)絡(luò)輸入形狀?NCHW
input_image?=?np.expand_dims(np.transpose(resized_image,?(2,?0,?1)),?0)
#?推理
inference_start_time?=?time.perf_counter()
result?=?exec_net.infer(inputs={input_key:?input_image})[output_key]
inference_stop_time?=?time.perf_counter()
inference_duration?=?inference_stop_time?-?inference_start_time
total_inference_duration?+=?inference_duration
if?input_video_frame_nr?%?(10?*?ADVANCE_FRAMES)?==?0:
clear_output(wait=True)
progress_bar.display()
#?input_video_frame_nr?//?ADVANCE_FRAMES?給出了網(wǎng)絡(luò)已經(jīng)處理了多少個(gè)
#?網(wǎng)絡(luò)已經(jīng)處理過的幀數(shù)
display(
Pretty(
f"Processed?frame?{input_video_frame_nr?//?ADVANCE_FRAMES}"
f"/{total_frames?//?ADVANCE_FRAMES}.?"
f"Inference?time:?{inference_duration:.2f}?seconds?"
f"({1/inference_duration:.2f}?FPS)"
)
)
#?將網(wǎng)絡(luò)結(jié)果轉(zhuǎn)化為RGB圖像
result_frame?=?to_rgb(convert_result_to_image(result))
#?調(diào)整圖像和結(jié)果的大小，使其符合目標(biāo)框架的形狀
result_frame?=?cv2.resize(result_frame,?(target_frame_width,?target_frame_height))
image?=?cv2.resize(image,?(target_frame_width,?target_frame_height))
#?把圖片和結(jié)果并排放在一起
stacked_frame?=?np.hstack((image,?result_frame))
#?保存視頻
out_video.write(stacked_frame)
input_video_frame_nr?=?input_video_frame_nr?+?ADVANCE_FRAMES
cap.set(1,?input_video_frame_nr)
progress_bar.progress?=?input_video_frame_nr
progress_bar.update()
except?KeyboardInterrupt:
print("Processing?interrupted.")
finally:
clear_output()
processed_frames?=?num_frames?//?ADVANCE_FRAMES
out_video.release()
cap.release()
end_time?=?time.perf_counter()
duration?=?end_time?-?start_time
print(
f"Processed?{processed_frames}?frames?in?{duration:.2f}?seconds.?"
f"Total?FPS?(including?video?processing):?{processed_frames/duration:.2f}."
f"Inference?FPS:?{processed_frames/total_inference_duration:.2f}?"
)
print(f"Monodepth?Video?saved?to?'{str(result_video_path)}'.")
通過代碼我們可以了解針對視頻推理的完整流程，首先打開視頻文件，并且為推理結(jié)果視頻創(chuàng)建準(zhǔn)備了文件。接下來進(jìn)入循環(huán)，將每一幀圖像進(jìn)行處理后輸入到推理引擎進(jìn)行處理，并將處理結(jié)果進(jìn)行后處理寫入到文件中，如此往復(fù)將所有幀處理完成。最終將處理的幀數(shù)及處理時(shí)間打印出來。
4、 展示結(jié)果
圖3-13 vision-monodepth推理并保存結(jié)果
video?=?Video(result_video_path,?width=800,?embed=True)
if?not?result_video_path.exists():
plt.imshow(stacked_frame)
raise?ValueError("OpenCV?was?unable?to?write?the?video?file.?Showing?one?video?frame.")
else:
print(f"Showing?monodepth?video?saved?atn{result_video_path.resolve()}")
print(
"If?you?cannot?see?the?video?in?your?browser,?please?click?on?the?"
"following?link?to?download?the?video?"
)
video_link?=?FileLink(result_video_path)
video_link.html_link_str?=?"<a?href='< span="">%s'?download>%s"
display(HTML(video_link._repr_html_()))
display(video)
推理的結(jié)果視頻存放在output目錄中，并且加入了原視頻畫面，對于推理結(jié)果有更加直觀的展示。
3.1.3? ?小結(jié)
在本單元中，我們學(xué)習(xí)了利用MiDas神經(jīng)網(wǎng)絡(luò)實(shí)現(xiàn)單目深度估算的案例，并且在學(xué)習(xí)對圖片進(jìn)行推理的基礎(chǔ)上完成了對視頻的推理，進(jìn)而了解了圖片處理與視頻處理的異同點(diǎn)。單目深度估算可以利用低成本的攝像頭實(shí)現(xiàn)高成本設(shè)備的部分功能，用于自動(dòng)駕駛、三維重建、機(jī)器人識別不同領(lǐng)域。
3.2圖像的超級分辨率
圖像超分辨率（Super Resolution）是指從低分辨率（Low Resolution）圖像中恢復(fù)高分辨率（High Resolution）圖像的過程，是計(jì)算機(jī)視覺和圖像處理中一種重要的圖像處理技術(shù)。它在現(xiàn)實(shí)世界中有著廣泛的應(yīng)用，如醫(yī)療圖像分析、生物特征識別、視頻監(jiān)控與安全等實(shí)際場景中有著廣泛的應(yīng)用。隨著深度學(xué)習(xí)技術(shù)的發(fā)展，基于深度學(xué)習(xí)的圖像超分方法在多個(gè)測試任務(wù)上，取得了目前最優(yōu)的性能和效果。
本案例中超級分辨率是通過使用深度學(xué)習(xí)增加像素?cái)?shù)來提高圖像質(zhì)量的過程，教程中使用英特爾開放模型庫中single-image-super-resolution-1032模型實(shí)現(xiàn)圖像的超級分辨率功能。關(guān)于模型的論文請參考：An Attention-Based Approach for Single Image Super Resolution。（鏈接：https://arxiv.org/abs/1807.06779）
學(xué)習(xí)目標(biāo)：
了解超級分辨率模型及應(yīng)用場景
鞏固推理引擎使用流程并熟練應(yīng)用
學(xué)習(xí)圖片與視頻處理的異同點(diǎn)
學(xué)習(xí)推理結(jié)果多種展現(xiàn)方式
3.2.1?? 圖片的超級分辨率
圖片超分已經(jīng)悄無聲息的應(yīng)用在我們的生活中，例如舊照片修復(fù)提升清晰度。在下面的實(shí)踐中我們學(xué)習(xí)如何使用超分模型實(shí)現(xiàn)圖片分辨率提升。
1、 導(dǎo)入模型
圖3-14 vision-superresolution-image導(dǎo)入模塊
import?os
import?time
import?urllib
from?pathlib?import?Path
import?cv2
import?matplotlib.pyplot?as?plt
import?numpy?as?np
from?IPython.display?import?HTML,?FileLink
from?IPython.display?import?Image?as?DisplayImage
from?IPython.display?import?Pretty,?ProgressBar,?clear_output,?display
from?openvino.inference_engine?import?IECore
from?PIL?import?Image
2、 設(shè)置參數(shù)及功能函數(shù)
圖3-15 vision-superresolution-image設(shè)置參數(shù)
DEVICE?=?"CPU"
#?1032:?4x?superresolution,?1033:?3x?superresolution
MODEL_FILE?=?"model/single-image-super-resolution-1032.xml"
model_name?=?os.path.basename(MODEL_FILE)
model_xml_path?=?Path(MODEL_FILE).with_suffix(".xml")
設(shè)置CPU作為推理設(shè)備，指定使用的模型文件路徑。
圖3-16?vision-superresolution-image功能函數(shù)
def?write_text_on_image(image:?np.ndarray,?text:?str)?->?np.ndarray:
"""
Write?the?specified?text?in?the?top?left?corner?of?the?image
as?white?text?with?a?black?border.
:param?image:?image?as?numpy?arry?with?HWC?shape,?RGB?or?BGR
:param?text:?text?to?write
:return:?image?with?written?text,?as?numpy?array
"""
font?=?cv2.FONT_HERSHEY_PLAIN
org?=?(20,?20)
font_scale?=?4
font_color?=?(255,?255,?255)
line_type?=?1
font_thickness?=?2
text_color_bg?=?(0,?0,?0)
x,?y?=?org
image?=?cv2.UMat(image)
(text_w,?text_h),?_?=?cv2.getTextSize(
text,?font,?font_scale,?font_thickness
)
result_im?=?cv2.rectangle(
image,?org,?(x?+?text_w,?y?+?text_h),?text_color_bg,?-1
)
textim?=?cv2.putText(
result_im,
text,
(x,?y?+?text_h?+?font_scale?-?1),
font,
font_scale,
font_color,
font_thickness,
line_type,
)
return?textim.get()
def?load_image(path:?str)?->?np.ndarray:
"""
Loads?an?image?from?`path`?and?returns?it?as?BGR?numpy?array.
:param?path:?path?to?an?image?filename?or?url
:return:?image?as?numpy?array,?with?BGR?channel?order
"""
if?path.startswith("http"):
#?Set?User-Agent?to?Mozilla?because?some?websites?block?requests
#?with?User-Agent?Python
request?=?urllib.request.Request(
path,?headers={"User-Agent":?"Mozilla/5.0"}
)
response?=?urllib.request.urlopen(request)
array?=?np.asarray(bytearray(response.read()),?dtype="uint8")
image?=?cv2.imdecode(array,?-1)??#?Loads?the?image?as?BGR
else:
image?=?cv2.imread(path)
return?image
def?convert_result_to_image(result)?->?np.ndarray:
"""
Convert?network?result?of?floating?point?numbers?to?image?with?integer
values?from?0-255.?Values?outside?this?range?are?clipped?to?0?and?255.
:param?result:?a?single?superresolution?network?result?in?N,C,H,W?shape
"""
result?=?result.squeeze(0).transpose(1,?2,?0)
result?*=?255
result[result?<?0]?=?0
result[result?>?255]?=?255
result?=?result.astype(np.uint8)
return?result
def?to_rgb(image_data)?->?np.ndarray:
"""
Convert?image_data?from?BGR?to?RGB
"""
return?cv2.cvtColor(image_data,?cv2.COLOR_BGR2RGB)
這里定義了四個(gè)功能函數(shù)便于后續(xù)程序使用。write_text_on_image函數(shù)功能：在圖片的左上角添加注釋文字，文字顏色為白色并帶有黑色邊框。load_image函數(shù)功能：讀入圖片并且以BGR格式寫入numpy的數(shù)組中。convert_result_to_image函數(shù)功能：將推理結(jié)果轉(zhuǎn)換圖片。to_rgb函數(shù)功能：色彩空間轉(zhuǎn)換將BRG格式轉(zhuǎn)換為RGB格式。
3、 加載模型
圖3-17 vision-superresolution-image加載網(wǎng)絡(luò)模型
ie?=?IECore()
net?=?ie.read_network(str(model_xml_path))
exec_net?=?ie.load_network(network=net,?device_name=DEVICE)
#?網(wǎng)絡(luò)輸入和輸出是字典。獲取鍵的字典。
original_image_key?=?list(exec_net.input_info)[0]
bicubic_image_key?=?list(exec_net.input_info)[1]
output_key?=?list(exec_net.outputs.keys())[0]
#?獲得預(yù)期的輸入和目標(biāo)形狀。`.dims[2:]`返回高度
#?和寬度。OpenCV的resize函數(shù)期望形狀為（寬度，高度）。
#?所以我們用`[::-1]`反轉(zhuǎn)形狀，并將其轉(zhuǎn)換為一個(gè)元組
input_height,?input_width?=?tuple(
exec_net.input_info[original_image_key].tensor_desc.dims[2:]
)
target_height,?target_width?=?tuple(
exec_net.input_info[bicubic_image_key].tensor_desc.dims[2:]
)
upsample_factor?=?int(target_height?/?input_height)
print(
f"The?network?expects?inputs?with?a?width?of?{input_width},?"
f"height?of?{input_height}"
)
print(
f"The?network?returns?images?with?a?width?of?{target_width},?"
f"height?of?{target_height}"
)
print(
f"The?image?sides?are?upsampled?by?a?factor?{upsample_factor}.?"
f"The?new?image?is?{upsample_factor**2}?times?as?large?as?the?"
"original?image"
)
這個(gè)模型輸入為480x270的圖片，可以輸出1920x1080的圖片，長寬都有4倍提升。新圖片的分辨率變?yōu)樵嫉膱D像的16倍。
4、 加載圖像并顯示
圖3-18 vision-superresolution-image加載圖像
IMAGE_PATH?=?Path("data/tower.jpg")
OUTPUT_PATH?=?Path("output/")
os.makedirs(str(OUTPUT_PATH),?exist_ok=True)
full_image?=?load_image(str(IMAGE_PATH))
#?Uncomment?these?lines?to?load?a?raw?image?as?BGR
#?import?rawpy
#?with?rawpy.imread(IMAGE_PATH)?as?raw:
#?????full_image?=?raw.postprocess()[:,:,(2,1,0)]
plt.imshow(to_rgb(full_image))
print(
f"Showing?full?image?with?width?{full_image.shape[1]}?"
f"and?height?{full_image.shape[0]}"
)
需要注意的是輸入圖片盡量使用未壓縮的原始圖像（如TIFF、BMP或PNG），壓縮的圖像（如JPEG）在用超分辨率模型處理后可能會出現(xiàn)失真。
5、 裁切部分圖像用于推理
取一個(gè)網(wǎng)絡(luò)輸入尺寸的裁剪。給出裁剪的左上角的X（寬度）和Y（高度）坐標(biāo)。將CROP_FACTOR變量設(shè)置為2，以制作一個(gè)大于網(wǎng)絡(luò)輸入尺寸的作物（這只適用于1032超分辨率模型）。在傳播到網(wǎng)絡(luò)之前，作物將被降低采樣率。這對非常高分辨率的圖像很有用，因?yàn)榫W(wǎng)絡(luò)輸入尺寸的裁剪太小，無法顯示足夠的信息。它也可以改善結(jié)果。但要注意的是，如果CROP_FACTOR為2，則凈上采樣系數(shù)將減半。如果超分辨率網(wǎng)絡(luò)將圖像的邊長增加4倍，那么它就會將480x270的裁剪圖像升采樣為1920x1080。如果ROP_FACTOR為2，960x540的裁剪就會被上采樣為同樣的1920x1080：邊長是裁剪尺寸的兩倍。
圖3-19 vision-superresolution-image裁切圖像
#?將CROP_FACTOR設(shè)置為2，以獲取兩倍于輸入寬度和高度的裁剪
#?這只適用于1032(4x)超級分辨率模型!
#?將其設(shè)置為1，以獲取與輸入尺寸相同的裁剪
CROP_FACTOR?=?2
adjusted_upsample_factor?=?upsample_factor?//?CROP_FACTOR
image_id?=?"flag"??#?A?tag?to?recognize?the?saved?images
starty?=?3200
startx?=?0
#?Perform?the?crop
#?進(jìn)行裁剪
image_crop?=?full_image[
starty?:?starty?+?input_height?*?CROP_FACTOR,
startx?:?startx?+?input_width?*?CROP_FACTOR,
]
#?Show?the?cropped?image
#?顯示裁剪后的圖像
print(
f"Showing?image?crop?with?width?{image_crop.shape[1]}?and?"
f"height?{image_crop.shape[0]}."
)
plt.imshow(to_rgb(image_crop));
圖3-20 vision-superresolution-image圖像預(yù)處理
#?用雙三次插值將圖像調(diào)整到目標(biāo)形狀
bicubic_image?=?cv2.resize(
image_crop,?(target_width,?target_height),?interpolation=cv2.INTER_CUBIC
)
#?如果需要，調(diào)整圖像的大小，使之符合輸入圖像的形狀
if?CROP_FACTOR?>?1:
image_crop?=?cv2.resize(image_crop,?(input_width,?input_height))
#?將圖像從（H,W,C）重塑為（N,C,H,W）。
input_image_original?=?np.expand_dims(image_crop.transpose(2,?0,?1),?axis=0)
input_image_bicubic?=?np.expand_dims(bicubic_image.transpose(2,?0,?1),?axis=0)
根據(jù)網(wǎng)絡(luò)模型需要對輸入的圖像被調(diào)整為網(wǎng)絡(luò)輸入尺寸，并被重塑為（N,C,H,W）（H=高度，W=寬度，C=通道數(shù)，N=圖像數(shù)）。該圖像也被調(diào)整為網(wǎng)絡(luò)輸出尺寸，采用雙三次插值。這個(gè)雙三次元圖像是網(wǎng)絡(luò)的第二個(gè)輸入。
6、 推理
圖3-21 vision-superresolution-image推理并保存結(jié)果
network_result?=?exec_net.infer(
inputs={
original_image_key:?input_image_original,
bicubic_image_key:?input_image_bicubic,
}
)
#?Get?inference?result?as?numpy?array?and?reshape?to?image?shape?and?data?type
#?將推理結(jié)果作為numpy數(shù)組，并重塑為圖像形狀和數(shù)據(jù)類型
result_image?=?convert_result_to_image(network_result[output_key])
進(jìn)行推理并將推理結(jié)果轉(zhuǎn)換為RGB圖像。
7、 顯示并保存結(jié)果
圖3-22 vision-superresolution-image顯示結(jié)果
fig,?ax?=?plt.subplots(1,?2,?figsize=(30,?15))
ax[0].imshow(to_rgb(bicubic_image))
ax[1].imshow(to_rgb(result_image))
ax[0].set_title("Bicubic")
ax[1].set_title("Superresolution")
左側(cè)為雙三次插值處理的圖像，右側(cè)為超分辨模型處理的圖像。
圖3-23 vision-superresolution-image保存文件
#?在超分辨率或雙三次元圖像上添加帶有?"SUPER?"或?"BICUBIC?"的文本
image_super?=?write_text_on_image(result_image,?"SUPER")
image_bicubic?=?write_text_on_image(bicubic_image,?"BICUBIC")
#?Store?the?image?and?the?results
crop_image_path?=?Path(f"{OUTPUT_PATH.stem}/{image_id}_{adjusted_upsample_factor}x_crop.png")
superres_image_path?=?Path(f"{OUTPUT_PATH.stem}/{image_id}_{adjusted_upsample_factor}x_crop_superres.png")
bicubic_image_path?=?Path(f"{OUTPUT_PATH.stem}/{image_id}_{adjusted_upsample_factor}x_crop_bicubic.png")
cv2.imwrite(str(crop_image_path),?image_crop,?[cv2.IMWRITE_PNG_COMPRESSION,?0])
cv2.imwrite(
str(superres_image_path),?image_super,?[cv2.IMWRITE_PNG_COMPRESSION,?0]
)
cv2.imwrite(
str(bicubic_image_path),?image_bicubic,?[cv2.IMWRITE_PNG_COMPRESSION,?0]
)
print(f"Images?written?to?directory:?{OUTPUT_PATH}")
將插值圖片及超分模型處理的圖像寫入文件，保存在output目錄中。至此我們已經(jīng)有了推理結(jié)果，在接下來的內(nèi)容中，是以更友好的方式展現(xiàn)兩種圖像處理方式的差異。
8、 Gif動(dòng)畫方式展示結(jié)果
圖3-24 vision-superresolution-image動(dòng)畫展示
result_pil?=?Image.fromarray(to_rgb(image_super))
bicubic_pil?=?Image.fromarray(to_rgb(image_bicubic))
gif_image_path?=?Path(f"{OUTPUT_PATH.stem}/{image_id}_comparison_{adjusted_upsample_factor}x.gif")
result_pil.save(
fp=str(gif_image_path),
format="GIF",
append_images=[bicubic_pil],
save_all=True,
duration=1000,
loop=0,
)
#?DisplayImage(str(gif_image_path))?doesn't?work?in?Colab
DisplayImage(open(gif_image_path,?"rb").read(),?width=1920?//?2)
9、 視頻方式展現(xiàn)結(jié)果
圖3-25 vision-superresolution-images視頻展示
FOURCC?=?cv2.VideoWriter_fourcc(*"MJPG")
result_video_path?=?Path(f"{OUTPUT_PATH.stem}/{image_id}_crop_comparison_{adjusted_upsample_factor}x.avi")
video_target_height,?video_target_width?=?(
result_image.shape[0]?//?2,
result_image.shape[1]?//?2,
)
out_video?=?cv2.VideoWriter(
str(result_video_path),
FOURCC,
90,
(video_target_width,?video_target_height),
)
resized_result_image?=?cv2.resize(
result_image,?(video_target_width,?video_target_height)
)
resized_bicubic_image?=?cv2.resize(
bicubic_image,?(video_target_width,?video_target_height)
)
progress_bar?=?ProgressBar(total=video_target_width)
progress_bar.display()
for?i?in?range(video_target_width):
#?創(chuàng)建一個(gè)框架，其中左邊的部分（直到i像素寬度）包含了
#?超分辨率圖像，而右邊部分（從i像素寬度開始）包含
#?二元圖像
comparison_frame?=?np.hstack(
(
resized_result_image[:,?:i,?:],
resized_bicubic_image[:,?i:,?:],
)
)
#?在超分辨率和雙曲面部分之間創(chuàng)建一個(gè)小的黑色邊界線
#?和圖像的二元部分
comparison_frame[:,?i?-?1?:?i?+?1,?:]?=?0
out_video.write(comparison_frame)
progress_bar.progress?=?i
progress_bar.update()
out_video.release()
clear_output()
video_link?=?FileLink(result_video_path)
video_link.html_link_str?=?"<a?href='< span="">%s'?download>%s"
display(HTML(f"The?video?has?been?saved?to?{video_link._repr_html_()}"))
圖3-26 vision-superresolution-images視頻預(yù)覽
10、 全圖像超分處理
對全圖的超分辨率是通過將圖像分割成大小相等的斑塊，對每條路徑進(jìn)行超分辨率處理，然后將得到的斑塊再次拼接起來。在這個(gè)演示中，圖像邊界附近的斑塊被忽略了。如果你看到邊界問題，請調(diào)整下一個(gè)單元格中的`CROPLINES`設(shè)置
圖3-27 vision-superresolution-images全圖像分割
#?設(shè)置要從網(wǎng)絡(luò)結(jié)果中裁剪的行數(shù)，以防止
#?邊界效應(yīng)。應(yīng)該是一個(gè)>=1的整數(shù)。
CROPLINES?=?10
#?關(guān)于CROP_FACTOR的描述，請參見對圖像的一個(gè)裁剪的超級分辨率
CROP_FACTOR?=?2
full_image_height,?full_image_width?=?full_image.shape[:2]
#?計(jì)算x/y坐標(biāo)
x_coords?=?list(
range(0,?full_image_width,?input_width?*?CROP_FACTOR?-?CROPLINES?*?2)
)
while?full_image_width?-?x_coords[-1]?<?input_width?*?CROP_FACTOR:
x_coords.pop(-1)
y_coords?=?list(
range(0,?full_image_height,?input_height?*?CROP_FACTOR?-?CROPLINES?*?2)
)
while?full_image_height?-?y_coords[-1]?<?input_height?*?CROP_FACTOR:
y_coords.pop(-1)
#?計(jì)算寬度和高度以裁剪完整的圖像。整幅圖像被
#?在邊界處裁剪成輸入尺寸
crop_width?=?x_coords[-1]?+?input_width?*?CROP_FACTOR
crop_height?=?y_coords[-1]?+?input_height?*?CROP_FACTOR
#?計(jì)算目標(biāo)超分辨率圖像的寬度和高度
new_width?=?(
x_coords[-1]?*?(upsample_factor?//?CROP_FACTOR)
+?target_width
-?CROPLINES?*?2?*?(upsample_factor?//?CROP_FACTOR)
)
new_height?=?(
y_coords[-1]?*?(upsample_factor?//?CROP_FACTOR)
+?target_height
-?CROPLINES?*?2?*?(upsample_factor?//?CROP_FACTOR)
)
print(
f"The?output?image?will?have?a?width?of?{new_width}?"
f"and?a?height?of?{new_height}"
)
11、 執(zhí)行推理
代碼一次讀取圖像的一個(gè)補(bǔ)丁。每個(gè)補(bǔ)丁都被重塑為網(wǎng)絡(luò)輸入形狀，并通過雙三次插值對目標(biāo)形狀進(jìn)行升采樣。原始圖像和雙三次元圖像都會通過網(wǎng)絡(luò)傳播。網(wǎng)絡(luò)結(jié)果是一個(gè)帶有浮點(diǎn)值的numpy數(shù)組，其形狀為（1,3,1920,1080）。這個(gè)數(shù)組被轉(zhuǎn)換為形狀為(1080,1920,3)的8位圖像并寫入`full_superresolution_image`。二次元圖像被寫入`full_bic_image`進(jìn)行比較。進(jìn)度條顯示了這個(gè)過程的進(jìn)展。推理時(shí)間被測量，以及處理每個(gè)補(bǔ)丁的總時(shí)間。
圖3-28 vision-superresolution-images全圖推理
start_time?=?time.perf_counter()
patch_nr?=?0
num_patches?=?len(x_coords)?*?len(y_coords)
progress_bar?=?ProgressBar(total=num_patches)
progress_bar.display()
#?裁剪圖像以適應(yīng)輸入尺寸
full_image_crop?=?full_image.copy()[:crop_height,?:crop_width,?:]
#?創(chuàng)建目標(biāo)大小的空數(shù)組。
full_superresolution_image?=?np.empty(
(new_height,?new_width,?3),?dtype=np.uint8
)
#?創(chuàng)建目標(biāo)尺寸的雙三次插值向上采樣的圖像進(jìn)行比較
full_bicubic_image?=?cv2.resize(
full_image_crop[CROPLINES:-CROPLINES,?CROPLINES:-CROPLINES,?:],
(new_width,?new_height),
interpolation=cv2.INTER_CUBIC,
)
total_inference_duration?=?0
for?y?in?y_coords:
for?x?in?x_coords:
patch_nr?+=?1
#?對輸入圖像進(jìn)行裁剪
image_crop?=?full_image_crop[
y?:?y?+?input_height?*?CROP_FACTOR,
x?:?x?+?input_width?*?CROP_FACTOR,
]
#?用雙三次插值法將圖像調(diào)整到目標(biāo)形狀。
bicubic_image?=?cv2.resize(
image_crop,
(target_width,?target_height),
interpolation=cv2.INTER_CUBIC,
)
if?CROP_FACTOR?>?1:
image_crop?=?cv2.resize(image_crop,?(input_width,?input_height))
input_image_original?=?np.expand_dims(
image_crop.transpose(2,?0,?1),?axis=0
)
input_image_bicubic?=?np.expand_dims(
bicubic_image.transpose(2,?0,?1),?axis=0
)
#?執(zhí)行推理
inference_start_time?=?time.perf_counter()
network_result?=?exec_net.infer(
inputs={
original_image_key:?input_image_original,
bicubic_image_key:?input_image_bicubic,
}
)
inference_stop_time?=?time.perf_counter()
inference_duration?=?inference_stop_time?-?inference_start_time
total_inference_duration?+=?inference_duration
#?將推理結(jié)果重塑為圖像形狀和數(shù)據(jù)類型
result?=?network_result[output_key]
result_image?=?convert_result_to_image(result)
#?把這個(gè)補(bǔ)丁的推理結(jié)果添加到完整的超分辨率上
#?圖像
adjusted_upsample_factor?=?upsample_factor?//?CROP_FACTOR
new_y?=?y?*?adjusted_upsample_factor
new_x?=?x?*?adjusted_upsample_factor
full_superresolution_image[
new_y?:?new_y
+?target_height
-?CROPLINES?*?adjusted_upsample_factor?*?2,
new_x?:?new_x
+?target_width
-?CROPLINES?*?adjusted_upsample_factor?*?2,
]?=?result_image[
CROPLINES
*?adjusted_upsample_factor?:?-CROPLINES
*?adjusted_upsample_factor,
CROPLINES
*?adjusted_upsample_factor?:?-CROPLINES
*?adjusted_upsample_factor,
:,
]
progress_bar.progress?=?patch_nr
progress_bar.update()
if?patch_nr?%?10?==?0:
clear_output(wait=True)
progress_bar.display()
display(
Pretty(
f"Processed?patch?{patch_nr}/{num_patches}.?"
f"Inference?time:?{inference_duration:.2f}?seconds?"
f"({1/inference_duration:.2f}?FPS)"
)
)
end_time?=?time.perf_counter()
duration?=?end_time?-?start_time
clear_output(wait=True)
print(
f"Processed?{num_patches}?patches?in?{duration:.2f}?seconds.?"
f"Total?patches?per?second?(including?processing):?"
f"{num_patches/duration:.2f}.nInference?patches?per?second:?"
f"{num_patches/total_inference_duration:.2f}?"
)
12、 保存文件
圖3-29 vision-superresolution-images 保存文件
full_superresolution_image_path?=?Path(f"{OUTPUT_PATH.stem}/full_superres_{adjusted_upsample_factor}x.jpg")
full_bicubic_image_path?=?Path(f"{OUTPUT_PATH.stem}/full_bicubic_{adjusted_upsample_factor}x.jpg")
cv2.imwrite(str(full_superresolution_image_path),?full_superresolution_image)
cv2.imwrite(str(full_bicubic_image_path),?full_bicubic_image);
bicubic_link?=?FileLink(full_bicubic_image_path)
image_link?=?FileLink(full_superresolution_image_path)
bicubic_link.html_link_str?=?"<a?href='< span="">%s'?download>%s"
image_link.html_link_str?=?"<a?href='< span="">%s'?download>%s"
display(
HTML(
"The?images?are?saved?in?the?images?directory.?You?can?also?download?"
"them?by?clicking?on?these?links:"
f"
{image_link._repr_html_()}
{bicubic_link._repr_html_()}"
)
)
將超分處理的圖像與雙三元插值的圖像保存只output目錄。
至此，我們學(xué)習(xí)了通過超分模型處理圖片的完整流程，并且分別利用雙三元插值方式與超分模型方式對同一圖像進(jìn)行處理，超分模型的結(jié)果要優(yōu)于插值方式。下一節(jié)中，我們學(xué)習(xí)使用超分模型對視頻進(jìn)行處理。
3.2.2? ?視頻的超級分辨率
接上節(jié)內(nèi)容，我們使用超分模型處理視頻。
1、 導(dǎo)入模塊
圖3-30 vision-superresolution-video導(dǎo)入模塊
import?os
import?time
import?urllib
from?pathlib?import?Path
import?cv2
import?numpy?as?np
from?IPython.display?import?HTML,?FileLink,?Pretty,?ProgressBar,?Video,?clear_output,?display
from?openvino.inference_engine?import?IECore
from?pytube?import?YouTube
pytube模塊 可以從Youtube網(wǎng)站下載視頻的python庫。盡管出于監(jiān)管原因我們無法訪問該站點(diǎn)，但可以借鑒實(shí)現(xiàn)方式在尊重版權(quán)的前提下從其他站點(diǎn)下載所需要的資源。
2、 參數(shù)設(shè)置及定義功能函數(shù)
圖3-31 vision-superresolution-video參數(shù)設(shè)置
#?選擇推理設(shè)備?CPU或GPU
DEVICE?=?"CPU"
#?1032:?4x?superresolution,?1033:?3x?superresolution
MODEL_FILE?=?"model/single-image-super-resolution-1032.xml"
model_name?=?os.path.basename(MODEL_FILE)
model_xml_path?=?Path(MODEL_FILE).with_suffix(".xml")
依舊選擇CPU作為推理設(shè)備，并且使用SISR模型。
def?write_text_on_image(image:?np.ndarray,?text:?str)?->?np.ndarray:
"""
Write?the?specified?text?in?the?top?left?corner?of?the?image
as?white?text?with?a?black?border.
:param?image:?image?as?numpy?arry?with?HWC?shape,?RGB?or?BGR
:param?text:?text?to?write
:return:?image?with?written?text,?as?numpy?array
"""
font?=?cv2.FONT_HERSHEY_PLAIN
org?=?(20,?20)
font_scale?=?4
font_color?=?(255,?255,?255)
line_type?=?1
font_thickness?=?2
text_color_bg?=?(0,?0,?0)
x,?y?=?org
image?=?cv2.UMat(image)
(text_w,?text_h),?_?=?cv2.getTextSize(text,?font,?font_scale,?font_thickness)
result_im?=?cv2.rectangle(image,?org,?(x?+?text_w,?y?+?text_h),?text_color_bg,?-1)
textim?=?cv2.putText(
result_im,
text,
(x,?y?+?text_h?+?font_scale?-?1),
font,
font_scale,
font_color,
font_thickness,
line_type,
)
return?textim.get()
def?load_image(path:?str)?->?np.ndarray:
"""
Loads?an?image?from?`path`?and?returns?it?as?BGR?numpy?array.
:param?path:?path?to?an?image?filename?or?url
:return:?image?as?numpy?array,?with?BGR?channel?order
"""
if?path.startswith("http"):
#?Set?User-Agent?to?Mozilla?because?some?websites?block?requests
#?with?User-Agent?Python
request?=?urllib.request.Request(path,?headers={"User-Agent":?"Mozilla/5.0"})
response?=?urllib.request.urlopen(request)
array?=?np.asarray(bytearray(response.read()),?dtype="uint8")
image?=?cv2.imdecode(array,?-1)??#?Loads?the?image?as?BGR
else:
image?=?cv2.imread(path)
return?image
def?convert_result_to_image(result)?->?np.ndarray:
"""
Convert?network?result?of?floating?point?numbers?to?image?with?integer
values?from?0-255.?Values?outside?this?range?are?clipped?to?0?and?255.
:param?result:?a?single?superresolution?network?result?in?N,C,H,W?shape
"""
result?=?result.squeeze(0).transpose(1,?2,?0)
result?*=?255
result[result?<?0]?=?0
result[result?>?255]?=?255
result?=?result.astype(np.uint8)
return?result
這里定義了三個(gè)功能函數(shù)便于后續(xù)程序使用，也是我們所熟悉的函數(shù)實(shí)現(xiàn)。write_text_on_image函數(shù)功能：在圖片的左上角添加注釋文字，文字顏色為白色并帶有黑色邊框。load_image函數(shù)功能：讀入圖片并且以BGR格式寫入numpy的數(shù)組中。convert_result_to_image函數(shù)功能：將推理結(jié)果轉(zhuǎn)換圖片。
3、 加載網(wǎng)絡(luò)模型
圖3-32 vision-superresolution-video加載網(wǎng)絡(luò)模型
ie = IECore()
net = ie.read_network(str(model_xml_path), str(model_xml_path.with_suffix(".bin")))
exec_net = ie.load_network(network=net, device_name=DEVICE)
# 網(wǎng)絡(luò)輸入和輸出是字典。獲取鍵的字典。
original_image_key = list(exec_net.input_info)[0]
bicubic_image_key = list(exec_net.input_info)[1]
output_key = list(exec_net.outputs.keys())[0]
# 獲得預(yù)期的輸入和目標(biāo)形狀。`.dims[2:]`返回高度
# 和寬度。OpenCV的resize函數(shù)期望形狀為（寬度，高度）。
# 所以我們用`[::-1]`反轉(zhuǎn)形狀，并將其轉(zhuǎn)換為一個(gè)元組
input_height, input_width = tuple(exec_net.input_info[original_image_key].tensor_desc.dims[2:])
target_height, target_width = tuple(exec_net.input_info[bicubic_image_key].tensor_desc.dims[2:])
upsample_factor = int(target_height / input_height)
print(f"The network expects inputs with a width of {input_width}, " f"height of {input_height}")
print(f"The network returns images with a width of {target_width}, " f"height of {target_height}")
print(
f"The image sides are upsampled by a factor {upsample_factor}. "
f"The new image is {upsample_factor**2} times as large as the "
"original image"
)
初始化推理引擎，加載模型并獲得有關(guān)網(wǎng)絡(luò)輸入和輸出的信息。超級分辨率模型希望有兩個(gè)輸入。1）輸入圖像，2）輸入圖像的雙三次插值到目標(biāo)尺寸1920x1080。超分模型推理后返回1920x1800的圖像的超級分辨率。
4、 視頻參數(shù)配置
圖3-33 vision-superresolution-video視頻參數(shù)配置
VIDEO_DIR = "data"
OUTPUT_DIR = "output"
os.makedirs(str(OUTPUT_DIR), exist_ok=True)
# 要從輸入視頻中讀取的幀數(shù)。設(shè)為0則讀取所有幀。
NUM_FRAMES = 100
# 用于保存結(jié)果視頻的格式
# vp09很慢，但廣泛使用。如果你安裝了FFMPEG，你可以
# 將FOURCC改為`*"THEO"`以提高視頻寫入速度
FOURCC = cv2.VideoWriter_fourcc(*"vp09")
源視頻目錄為data文件夾，輸出目錄為output文件夾，處理100幀視頻，生成新視頻的編碼格式為vp09。
5、 下載并讀取視頻
圖3-34?vision-superresolution-video下載并讀取視頻
# 使用 pytube 來下載視頻。它下載到視頻子目錄中。
# 你也可以在那里放置一個(gè)本地視頻，并注釋掉以下幾行
VIDEO_URL = "https://www.youtube.com/watch?v=V8yS3WIkOrA"
yt = YouTube(VIDEO_URL)
# 使用`yt.streams`來查看所有可用的流。參見PyTube文檔
# https://python-pytube.readthedocs.io/en/latest/api.html 以了解高級
# 過濾選項(xiàng)
try:
os.makedirs(VIDEO_DIR, exist_ok=True)
stream = yt.streams.filter(resolution="360p").first()
filename = Path(stream.default_filename.encode("ascii", "ignore").decode("ascii")).stem
stream.download(OUTPUT_DIR, filename=filename)
print(f"Video {filename} downloaded to {OUTPUT_DIR}")
# 為輸入視頻和結(jié)果視頻創(chuàng)建路徑對象
video_path = Path(stream.get_file_path(filename, OUTPUT_DIR))
except Exception:
# 如果PyTube失敗了，使用存儲在VIDEO_DIR目錄下的本地視頻
video_path = Path(rf"{VIDEO_DIR}/CEO Pat Gelsinger on Leading Intel.mp4")
# 視頻的路徑名稱
superres_video_path = Path(f"{OUTPUT_DIR}/{video_path.stem}_superres.mp4")
bicubic_video_path = Path(f"{OUTPUT_DIR}/{video_path.stem}_bicubic.mp4")
comparison_video_path = Path(f"{OUTPUT_DIR}/{video_path.stem}_superres_comparison.mp4")
# 打開視頻，獲取尺寸和FPS
cap = cv2.VideoCapture(str(video_path))
ret, image = cap.read()
if not ret:
raise ValueError(f"The video at '{video_path}' cannot be read.")
fps = cap.get(cv2.CAP_PROP_FPS)
original_frame_height, original_frame_width = image.shape[:2]
cap.release()
print(
f"The input video has a frame width of {original_frame_width}, "
f"frame height of {original_frame_height} and runs at {fps:.2f} fps"
)
視頻文件已經(jīng)預(yù)置在data目錄下，因此在這里我們忽略下載代碼，僅關(guān)心文件配置、視頻讀取部分的代碼。從代碼中我們不難發(fā)現(xiàn)，案例運(yùn)行完成后，我們將得到三個(gè)mp4文件，超分模型實(shí)現(xiàn)的視頻文件、雙三次插值實(shí)現(xiàn)的視頻文件、以及二者效果的對比視頻。源文件讀入后從輸出信息可以得知，視頻分辨率為640x360，幀率為30FPS。
圖3-35 vision-superresolution-video準(zhǔn)備輸出文件
superres_video = cv2.VideoWriter(
str(superres_video_path),
FOURCC,
fps,
(target_width, target_height),
)
bicubic_video = cv2.VideoWriter(
str(bicubic_video_path),
FOURCC,
fps,
(target_width, target_height),
)
comparison_video = cv2.VideoWriter(
str(comparison_video_path),
FOURCC,
fps,
(target_width * 2, target_height),
)
創(chuàng)建超分辨率視頻、雙三次插值視頻和二者比較視頻。超分辨率視頻包含增強(qiáng)的視頻，用超分辨率提升采樣，插值視頻是用雙三次元插值升采樣的輸入視頻，組合視頻將雙三次元視頻和超分辨率并列在一起。
圖3-36 vision-superresolution-video執(zhí)行推理
start_time = time.perf_counter()
frame_nr = 1
total_inference_duration = 0
total_frames = cap.get(cv2.CAP_PROP_FRAME_COUNT) if NUM_FRAMES == 0 else NUM_FRAMES
progress_bar = ProgressBar(total=total_frames)
progress_bar.display()
cap = cv2.VideoCapture(str(video_path))
try:
while cap.isOpened():
ret, image = cap.read()
if not ret:
cap.release()
break
if NUM_FRAMES > 0 and frame_nr == NUM_FRAMES:
break
# 將輸入圖像調(diào)整為網(wǎng)絡(luò)形狀，并從（H,W,C）轉(zhuǎn)換為
# (N,C,H,W)
resized_image = cv2.resize(image, (input_width, input_height))
input_image_original = np.expand_dims(resized_image.transpose(2, 0, 1), axis=0)
# 調(diào)整圖像大小，用雙三次方的方法將圖像重塑為目標(biāo)形狀。
# 內(nèi)插法
bicubic_image = cv2.resize(
image, (target_width, target_height), interpolation=cv2.INTER_CUBIC
)
input_image_bicubic = np.expand_dims(bicubic_image.transpose(2, 0, 1), axis=0)
# 推理
inference_start_time = time.perf_counter()
result = exec_net.infer(
inputs={
original_image_key: input_image_original,
bicubic_image_key: input_image_bicubic,
}
)[output_key]
inference_stop_time = time.perf_counter()
inference_duration = inference_stop_time - inference_start_time
total_inference_duration += inference_duration
# 將推理結(jié)果轉(zhuǎn)化為圖像
result_frame = convert_result_to_image(result)
# 將生成的圖像和雙三次元圖像寫入視頻中
superres_video.write(result_frame)
bicubic_video.write(bicubic_image)
stacked_frame = np.hstack((bicubic_image, result_frame))
comparison_video.write(stacked_frame)
frame_nr = frame_nr + 1
# 更新進(jìn)度條和狀態(tài)信息
progress_bar.progress = frame_nr
progress_bar.update()
if frame_nr % 10 == 0:
clear_output(wait=True)
progress_bar.display()
display(
Pretty(
f"Processed frame {frame_nr}. Inference time: "
f"{inference_duration:.2f} seconds "
f"({1/inference_duration:.2f} FPS)"
)
)
except KeyboardInterrupt:
print("Processing interrupted.")
finally:
superres_video.release()
bicubic_video.release()
comparison_video.release()
end_time = time.perf_counter()
duration = end_time - start_time
print(f"Video's saved to {comparison_video_path.parent} directory.")
print(
f"Processed {frame_nr} frames in {duration:.2f} seconds. Total FPS "
f"(including video processing): {frame_nr/duration:.2f}. "
f"Inference FPS: {frame_nr/total_inference_duration:.2f}."
)
讀取視頻幀，用超分辨率增強(qiáng)它們。將超分辨率視頻、插值視頻和比較視頻保存到文件中。代碼逐幀讀取視頻。每一幀都被調(diào)整大小，重塑為網(wǎng)絡(luò)輸入形狀，并通過雙三次插值提升采樣到目標(biāo)形狀。原始圖像和雙三次插值圖像都會通過網(wǎng)絡(luò)傳播。網(wǎng)絡(luò)結(jié)果是一個(gè)帶有浮點(diǎn)值的numpy數(shù)組，其形狀為（1,3,1920,1080）。這個(gè)數(shù)組被轉(zhuǎn)換為一個(gè)8位的圖像，形狀為(1080,1920,3)并寫入`superres_video`。插值圖像被寫入`bicubic_video`進(jìn)行比較。最后，插值和結(jié)果幀并排組合，并寫入`comparison_video'。進(jìn)度條顯示了這個(gè)過程的進(jìn)展。推理時(shí)間被測量，以及處理每一幀的總時(shí)間，其中包括推理時(shí)間，以及處理和寫入視頻的時(shí)間。
6、 顯示視頻
圖3-37 vision-superresolution-video顯示結(jié)果
if not comparison_video_path.exists():
raise ValueError("The comparison video does not exist.")
else:
video_link = FileLink(comparison_video_path)
display(
HTML(
f"Showing side by side comparison. If you cannot see the video in "
"your browser, please click on the following link to download "
f"the video
{video_link._repr_html_()}"
)
)
display(Video(comparison_video_path, width=800, embed=True))
圖3-38 vision-superresolution-video視頻文件信息
通過數(shù)據(jù)可視化我們獲知通過兩種方式我們都使得分辨率得以提升，達(dá)到了1920x1280。得到了插值視頻、超分模型推理視頻以及二至對比，從對比視頻可以看出采用超分模型生成的視頻效果更加，與原始視頻相比更是有高質(zhì)量提升。
3.2.3? ?小結(jié)
通過本節(jié)的學(xué)習(xí)我們了解了圖像超級分辨率的應(yīng)用案例，通過實(shí)驗(yàn)學(xué)習(xí)了如何通過超分模型實(shí)現(xiàn)圖片分辨率提升及視頻分辨率提升。我們也可以將這個(gè)模型應(yīng)用于生活中，例如修復(fù)分辨率較差的舊照片舊視頻等等，使用深度學(xué)習(xí)模型處理的視頻比采用插值方式處理的圖像質(zhì)量要好很多。
3.3用U2Net和OpenVINO? 實(shí)現(xiàn)圖像去背景
圖像去背景（摳圖）是指準(zhǔn)確提取靜止圖片或者視頻圖片序列中的前景目標(biāo)，它是許多圖像編輯中的關(guān)鍵技術(shù)之一。該技術(shù)的研究已經(jīng)有超過20年的歷史。傳統(tǒng)的圖像去背景技術(shù)基于許多基礎(chǔ)技術(shù)例如顏色采樣（如貝葉斯方法）和近鄰梯度分析（如波松方法）或者二者融合的技術(shù)。近年來，隨著深度學(xué)習(xí)的發(fā)展，已經(jīng)有很多研究工作利用深度學(xué)習(xí)來研究摳圖并取得優(yōu)秀的效果?；诙说蕉说纳疃葘W(xué)習(xí)模型一方面可以讓整個(gè)摳圖過程完全自動(dòng)化，而且可以利用大量的數(shù)據(jù)訓(xùn)練提高模型的泛化能力。我們熟悉的PhotoShop、Word、手機(jī)相冊等應(yīng)用中都有圖像去背景技術(shù)的應(yīng)用。
關(guān)于U^2Net, U^2Net是號稱“地表最強(qiáng)”的靜態(tài)背景分割算法，是一種類似編碼-解碼（Encoder-Decoder）的網(wǎng)絡(luò)結(jié)構(gòu)。研究者在此基礎(chǔ)上，提出了新型殘差 U-block（ReSidual U-block, RSU），融合不同尺寸接受野的特征，以捕獲更多不同尺度的上下文信息。
本節(jié)將使用U^2Net與OpenVINO? 實(shí)現(xiàn)圖像的背景移除及背景變換。實(shí)訓(xùn)中基于PyTorch的U^2Net模型先轉(zhuǎn)換為ONNX及IR格式，并通過OpenVINO? 一起加載，最終實(shí)現(xiàn)推理。
關(guān)于U^2-Net的更多信息，包括源代碼和測試數(shù)據(jù)，請參見Github頁面：https://github.com/xuebinqin/U-2-Net 和研究論文U^2-Net: Going Deeper with Nested U-Structure for Salient Object Detection。（鏈接：
https://arxiv.org/pdf/2005.09007.pdf?）
學(xué)習(xí)目標(biāo)：
了解U2NET模型及圖像去背景的應(yīng)用場景
鞏固學(xué)習(xí)推理引擎使用流程并熟練應(yīng)用
鞏固學(xué)習(xí)PyTorch模型轉(zhuǎn)換為ONNX及IR文件
1、 導(dǎo)入模塊
圖3-40 vision-background-removal 導(dǎo)入模塊
import os
import sys
import time
from collections import namedtuple
from pathlib import Path
import cv2
import matplotlib.pyplot as plt
import mo_onnx
import numpy as np
import torch
from IPython.display import HTML, FileLink, display
from model.u2net import U2NET, U2NETP
from openvino.inference_engine import IECore
認(rèn)識新模塊
model.u2net 是u2net模型的python庫
在本節(jié)案例中，我們默認(rèn)使用u2net_lite模型。
2、 設(shè)置下載模型
圖3-41 vision-background-removal模型下載
IMAGE_DIR = "data"
model_config = namedtuple("ModelConfig", ["name", "url", "model", "model_args"])
u2net_lite = model_config(
"u2net_lite",
"https://drive.google.com/uc?id=1rbSTGKAE-MTxBYHd-51l2hMOQPT_7EPy",
U2NETP,
()
)
u2net = model_config(
"u2net",
"https://drive.google.com/uc?id=1ao1ovG1Qtx4b7EoskHXmi2E9rp5CHLcZ",
U2NET,
(3, 1)
)
u2net_human_seg = model_config(
"u2net_human_seg",
"https://drive.google.com/uc?id=1-Yg0cxgrNhHP-016FPdp902BR-kSsA4P",
U2NET,
(3, 1)
)
# Set u2net_model to one of the three configurations listed above
# 將u2net_model設(shè)置為上述三種配置之一
u2net_model = u2net_lite
# 下載和轉(zhuǎn)換的模型的文件名
MODEL_DIR = "model"
model_path = (
Path(MODEL_DIR)
/ u2net_model.name
/ Path(u2net_model.name).with_suffix(".pth")
)
onnx_path = model_path.with_suffix(".onnx")
ir_path = model_path.with_suffix(".xml")
原始的U^2-Net突出物體檢測模型，以及較小的U2NETP版本。原始模型支持兩組權(quán)重：突出物體檢測和人體分割。案例默認(rèn)使用u2net_lite模型。
3、 PyTorch加載原始模型
如果本地沒有模型文件將先從網(wǎng)絡(luò)下載至本地，再進(jìn)行加載模型及預(yù)訓(xùn)練的權(quán)重。
圖3-42 vision-background-removal加載模型
if not model_path.exists():
import gdown
os.makedirs(model_path.parent, exist_ok=True)
print("Start downloading model weights file... ")
with open(model_path, "wb") as model_file:
gdown.download(u2net_model.url, output=model_file)
print(f"Model weights have been downloaded to {model_path}")
# 加載模型
net = u2net_model.model(*u2net_model.model_args)
net.eval()
# Load the weights
# 加載權(quán)重
print(f"Loading model weights from: '{model_path}'")
net.load_state_dict(torch.load(model_path, map_location="cpu"))
# Save the model if it doesn't exist yet
# 如果模型還不存在，就保存它
if not model_path.exists():
print("nSaving the model")
torch.save(net.state_dict(), str(model_path))
print(f"Model saved at {model_path}")
4、 模型轉(zhuǎn)換
1） 將模型導(dǎo)出為ONNX格式，轉(zhuǎn)換過程中可忽略警告信息。
圖3-43 vision-background-removal ONNX模型轉(zhuǎn)換
if not onnx_path.exists():
dummy_input = torch.randn(1, 3, 512, 512)
torch.onnx.export(net, dummy_input, onnx_path, opset_version=11)
print(f"ONNX model exported to {onnx_path}.")
else:
print(f"ONNX model {onnx_path} already exists.")
2） 將ONNX模型轉(zhuǎn)換為IR文件
調(diào)用OpenVINO? 模型優(yōu)化工具，將ONNX模型轉(zhuǎn)換成OpenVINO IR格式，精度為FP16。模型被保存到當(dāng)前目錄。我們在模型中加入平均值，并用--scale_values對輸出的標(biāo)準(zhǔn)差進(jìn)行縮放。有了這些選項(xiàng)，在通過網(wǎng)絡(luò)傳播之前，沒有必要對輸入數(shù)據(jù)進(jìn)行標(biāo)準(zhǔn)化。平均值和標(biāo)準(zhǔn)偏差值可以在U^2-Net資源庫的dataloader文件中找到，并乘以255以支持像素值為0-255的圖像。
圖3-44 vision-background-removal IR模型轉(zhuǎn)換
# 獲取模型優(yōu)化器腳本的路徑
mo_path = str(Path(mo_onnx.__file__))
# 構(gòu)建模型優(yōu)化器的命令
# 將log_level設(shè)置為CRITICAL，以抑制本演示中可以忽略的警告。
mo_command = f""""{sys.executable}"
"{mo_path}"
--input_model "{onnx_path}"
--input_shape "[1,3, 512, 512]"
--mean_values="[123.675, 116.28 , 103.53]"
--scale_values="[58.395, 57.12 , 57.375]"
--data_type FP16
--output_dir "{model_path.parent}"
--log_level "CRITICAL"
"""
mo_command = " ".join(mo_command.split())
print("Model Optimizer command to convert the ONNX model to OpenVINO:")
print(mo_command)
if not ir_path.exists():
print("Exporting ONNX model to IR... This may take a few minutes.")
mo_result = %sx $mo_command
print("n".join(mo_result))
else:
print(f"IR model {ir_path} already exists.")
5、 加載及預(yù)處理輸入圖片
圖3-45 vision-background-removal圖片預(yù)處理
IMAGE_PATH = Path(IMAGE_DIR) / "coco_hollywood.jpg"
image = cv2.cvtColor(
cv2.imread(str(IMAGE_PATH)),
cv2.COLOR_BGR2RGB,
)
resized_image = cv2.resize(image, (512, 512))
# 將圖像形狀轉(zhuǎn)換為網(wǎng)絡(luò)所期望的形狀和數(shù)據(jù)類型
# 適用于OpenVINO IR模型。(1, 3, 512, 512)
input_image = np.expand_dims(np.transpose(resized_image, (2, 0, 1)), 0)
U^2NET的IR模型希望得到RGB格式的圖像。OpenCV讀取的是BGR格式的圖像。我們將圖像轉(zhuǎn)換為RGB格式，將其大小調(diào)整為512乘以512，并將尺寸轉(zhuǎn)為IR模型所期望的格式。
6、 執(zhí)行推理
圖3-46 vision-background-removal執(zhí)行推理
# 加載模型
ie = IECore()
net_ir = ie.read_network(model=ir_path)
exec_net_ir = ie.load_network(network=net_ir, device_name="CPU")
# Get names of input and output layers
# 獲取輸入和輸出層的名稱
input_layer_ir = next(iter(exec_net_ir.input_info))
output_layer_ir = next(iter(exec_net_ir.outputs))
# Run the Inference on the Input image...
# 在輸入圖像上運(yùn)行推理...
start_time = time.perf_counter()
res_ir = exec_net_ir.infer(inputs={input_layer_ir: input_image})
res_ir = res_ir[output_layer_ir]
end_time = time.perf_counter()
print(
f"Inference finished. Inference time: {end_time-start_time:.3f} seconds, "
f"FPS: {1/(end_time-start_time):.2f}."
)
加載IR模型并執(zhí)行推理。
7、 數(shù)據(jù)可視化
圖3-47 vision-background-removal結(jié)果可視化
# 根據(jù)圖像形狀調(diào)整網(wǎng)絡(luò)結(jié)果的大小，并將數(shù)值取整為
# 變成0（背景）和1（前景）。
# 網(wǎng)絡(luò)結(jié)果的形狀為(1,1,512,512)，np.squeeze將其轉(zhuǎn)換為(512, 512)。
resized_result = np.rint(
cv2.resize(np.squeeze(res_ir), (image.shape[1], image.shape[0]))
).astype(np.uint8)
# Create a copy of the image and set all background values to 255 (white)
# 創(chuàng)建一個(gè)圖像的副本，并將所有背景值設(shè)置為255（白色）。
bg_removed_result = image.copy()
bg_removed_result[resized_result == 0] = 255
fig, ax = plt.subplots(1, 3, figsize=(20, 7))
ax[0].imshow(image)
ax[1].imshow(resized_result, cmap="gray")
ax[2].imshow(bg_removed_result)
for a in ax:
a.axis("off")
可視化結(jié)果依次顯示了原始圖像、分割圖像以及去除背景的圖像。
8、 添加背景
在分割結(jié)果中，所有的前景像素的值為1，所有的背景像素的值為0。替換背景圖像的方法如下：
加載一個(gè)新的圖像background_image。
將此圖像的大小調(diào)整為與原始圖像相同的大小
在background_image中，將調(diào)整后的分割結(jié)果值為1的所有像素--原圖像中的前景像素--設(shè)為0。
將上一步的 bg_removed_result-原始圖像中只包含前景像素的部分--加入到 background_image中。
圖3-48 vision-background-removal添加背景
3-49 vision-background-removal結(jié)果展示
BACKGROUND_FILE = "data/wall.jpg"
OUTPUT_DIR = "output"
os.makedirs(OUTPUT_DIR, exist_ok=True)
background_image = cv2.cvtColor(cv2.imread(BACKGROUND_FILE), cv2.COLOR_BGR2RGB)
background_image = cv2.resize(
background_image, (image.shape[1], image.shape[0])
)
# 將結(jié)果中的所有前景像素設(shè)為0
# 在背景圖像中，添加去除背景的圖像
background_image[resized_result == 1] = 0
new_image = background_image + bg_removed_result
# Save the generated image
# 保存生成的圖像
new_image_path = Path(
f"{OUTPUT_DIR}/{IMAGE_PATH.stem}-{Path(BACKGROUND_FILE).stem}.jpg"
)
cv2.imwrite(str(new_image_path), cv2.cvtColor(new_image, cv2.COLOR_RGB2BGR))
# 并排顯示原始圖像和帶有新背景的圖像
fig, ax = plt.subplots(1, 2, figsize=(18, 7))
ax[0].imshow(image)
ax[1].imshow(new_image)
for a in ax:
a.axis("off")
plt.show()
# 創(chuàng)建一個(gè)下載圖片的鏈接
image_link = FileLink(new_image_path)
image_link.html_link_str = "%s"
display(
HTML(
f"The generated image {new_image_path.name} is saved in "
f"the directory {new_image_path.parent}. You can also "
"download the image by clicking on this link: "
f"{image_link._repr_html_()}"
)
)
3.4PaddleGAN與OpenVINO? 實(shí)現(xiàn)圖片動(dòng)漫化
生成式對抗網(wǎng)絡(luò)，簡稱GAN，是一種近年來大熱的深度學(xué)習(xí)模型，該模型由兩個(gè)基礎(chǔ)神經(jīng)網(wǎng)絡(luò)即生成器神經(jīng)網(wǎng)絡(luò)（Generator Neural Network） 和判別器神經(jīng)網(wǎng)絡(luò)（Discriminator Neural Network） 所組成，其中一個(gè)用于生成內(nèi)容，另一個(gè)則用于判別生成的內(nèi)容。
GAN受博弈論中的零和博弈啟發(fā)，將生成問題視作判別器和生成器這兩個(gè)網(wǎng)絡(luò)的對抗和博弈：生成器從給定噪聲中（一般是指均勻分布或者正態(tài)分布）產(chǎn)生合成數(shù)據(jù)，判別器分辨生成器的的輸出和真實(shí)數(shù)據(jù)。前者試圖產(chǎn)生更接近真實(shí)的數(shù)據(jù)，相應(yīng)地，后者試圖更完美地分辨真實(shí)數(shù)據(jù)與生成數(shù)據(jù)。由此，兩個(gè)網(wǎng)絡(luò)在對抗中進(jìn)步，在進(jìn)步后繼續(xù)對抗，由生成式網(wǎng)絡(luò)得的數(shù)據(jù)也就越來越完美，逼近真實(shí)數(shù)據(jù)，從而可以生成想要得到的數(shù)據(jù)（圖片、序列、視頻等）。
圖片動(dòng)漫化是較為流行的一種應(yīng)用，例如某些應(yīng)用中的頭像動(dòng)漫化，以及實(shí)景動(dòng)漫化等等，本節(jié)我們利用PaddleGAN中AnimeGAN模型與OpenVINO? 實(shí)現(xiàn)完成圖片動(dòng)漫化學(xué)習(xí)。
學(xué)習(xí)目標(biāo)：
了解PaddleGan AnimeGAN模型及應(yīng)用場景
鞏固學(xué)習(xí)推理引擎使用流程并熟練應(yīng)用
鞏固學(xué)習(xí)使用模型優(yōu)化器將Paddle模型轉(zhuǎn)換為IR模型
1、 導(dǎo)入模塊
圖3-50 vision-paddlegan-anime導(dǎo)入模塊
import sys
import time
import os
from pathlib import Path
import cv2
import matplotlib.pyplot as plt
import mo_onnx
import numpy as np
from IPython.display import HTML, display
from openvino.inference_engine import IECore
# PaddlePaddle需要一個(gè)C++編譯器。如果導(dǎo)入paddle軟件包失敗，請
# 安裝C++
try:
import paddle
from paddle.static import InputSpec
from ppgan.apps import AnimeGANPredictor
except NameError:
if sys.platform == "win32":
install_message = (
"To use this notebook, please install the free Microsoft "
"Visual C++ redistributable from "
"https://aka.ms/vs/16/release/vc_redist.x64.exe"
)
else:
install_message = (
"To use this notebook, please install a C++ compiler. On macOS, "
"`xcode-select --install` installs many developer tools, including C++. On Linux, "
"install gcc with your distribution's package manager."
)
display(
HTML(
f"""
Error: PaddlePaddle requires installation of C++. {install_message}"""
)
)
raise
認(rèn)識新模塊：
Paddle 百度飛槳python模塊。
2、 設(shè)置及功能函數(shù)
圖3-51?vision-paddlegan-anime設(shè)置
MODEL_DIR = "model"
MODEL_NAME = "paddlegan_anime"
os.makedirs(MODEL_DIR, exist_ok=True)
# Create filenames of the models that will be converted in this notebook.
# 創(chuàng)建將在此筆記本中轉(zhuǎn)換的模型的文件名。
model_path = Path(f"{MODEL_DIR}/{MODEL_NAME}")
ir_path = model_path.with_suffix(".xml")
onnx_path = model_path.with_suffix(".onnx")
圖3-52 vision-paddlegan-anime功能函數(shù)
def resize_to_max_width(image, max_width):
"""
Resize `image` to `max_width`, preserving the aspect ratio of the image.
"""
if image.shape[1] > max_width:
hw_ratio = image.shape[0] / image.shape[1]
new_height = int(max_width * hw_ratio)
image = cv2.resize(image, (max_width, new_height))
return image
3、 原始模型推理
圖3-53 vision-paddlegan-anime函數(shù)說明
# 這個(gè)單元將初始化AnimeGANPredictor()并從PaddlePaddle下載權(quán)重。
# 這可能需要一些時(shí)間。權(quán)重被存儲在一個(gè)緩存中，只下載一次。
predictor = AnimeGANPredictor()
# 在Jupyter筆記本中，??顯示源文件和文件串。
predictor.run??
PaddleGAN的文檔解釋了用.run()來運(yùn)行模型。讓我們用Jupyter的??快捷鍵來看看這個(gè)函數(shù)是怎么做的，以顯示該函數(shù)的文檔和來源。
4、 執(zhí)行推理
AnimeGANPredictor.run()`方法。
用OpenCV加載一個(gè)圖像，并將其轉(zhuǎn)換為RGB
2. 對圖像進(jìn)行轉(zhuǎn)換
3. 通過生成器模型傳播轉(zhuǎn)換后的圖像，并對結(jié)果進(jìn)行后處理，返回一個(gè)范圍為[0,255]的數(shù)組
4. 將結(jié)果從（C,H,W）轉(zhuǎn)置為（H,W,C）形狀
5. 將結(jié)果圖像的大小調(diào)整為原始圖像的大小
6. 選擇性地調(diào)整結(jié)果圖像的亮度
7. 保存圖像
我們可以手動(dòng)執(zhí)行這些步驟，確認(rèn)結(jié)果看起來是正確的。為了加快推理時(shí)間，在通過網(wǎng)絡(luò)傳播大型圖像之前，先調(diào)整其大小。下一個(gè)單元格的推理步驟仍然需要一些時(shí)間來執(zhí)行。如果你想跳過這一步，在下一個(gè)單元格的第一行設(shè)置`PADDLEGAN_INFERENCE = False`。
圖3-54 vision-paddlegan-anime執(zhí)行推理
PADDLEGAN_INFERENCE = True
OUTPUT_DIR = "output"
os.makedirs(OUTPUT_DIR, exist_ok=True)
# 第1步。加載圖像并轉(zhuǎn)換為RGB
image_path = Path("data/coco_bricks.png")
image = cv2.cvtColor(cv2.imread(str(image_path), flags=cv2.IMREAD_COLOR), cv2.COLOR_BGR2RGB)
## 在大圖片上進(jìn)行推理需要的時(shí)間較長。調(diào)整大小至最大寬度為600
image = resize_to_max_width(image, 600)
# 第2步。轉(zhuǎn)換圖像
transformed_image = predictor.transform(image)
input_tensor = paddle.to_tensor(transformed_image[None, ::])
if PADDLEGAN_INFERENCE:
# 第3步 推理
predictor.generator.eval()
with paddle.no_grad():
result = predictor.generator(input_tensor)
# 第4步 將推理結(jié)果轉(zhuǎn)換為圖像，步驟與以下相同
# PaddleGAN的預(yù)測器.run()函數(shù)
result_image_pg = (result * 0.5 + 0.5)[0].numpy() * 255
result_image_pg = result_image_pg.transpose((1, 2, 0))
# 第5步 調(diào)整結(jié)果圖像的大小
result_image_pg = cv2.resize(result_image_pg, image.shape[:2][::-1])
# 第6步 調(diào)整亮度
result_image_pg = predictor.adjust_brightness(result_image_pg, image)
# 第7步 保存結(jié)果圖像
anime_image_path_pg = Path(f"{OUTPUT_DIR}/{image_path.stem}_anime_pg").with_suffix(".jpg")
if cv2.imwrite(str(anime_image_path_pg), result_image_pg[:, :, (2, 1, 0)]):
print(f"The anime image was saved to {anime_image_path_pg}")
5、 原始模型輸出結(jié)果
圖3-55 vision-paddlegan-anime原始模型推理結(jié)果
if PADDLEGAN_INFERENCE:
fig, ax = plt.subplots(1, 2, figsize=(25, 15))
ax[0].imshow(image)
ax[1].imshow(result_image_pg)
else:
print("PADDLEGAN_INFERENCE is not enabled. Set PADDLEGAN_INFERENCE = True in the previous cell and run that cell to show inference results.")
6、 原始模型轉(zhuǎn)換為ONNX及IR模型
我們將PaddleGAN模型轉(zhuǎn)換為OpenVINO IR，首先用`paddle2onnx`將PaddleGAN轉(zhuǎn)換為ONNX，然后用OpenVINO? 的模型優(yōu)化器將ONNX模型轉(zhuǎn)換為IR。
1)???? 原始模型轉(zhuǎn)換為ONNX
原始模型導(dǎo)出到ONNX需要用PaddlePaddle的`InputSpec`指定一個(gè)輸入形狀，并調(diào)用`paddle.onnx.export`。我們檢查轉(zhuǎn)換后的圖像的輸入形狀，并將其作為ONNX模型的輸入形狀。導(dǎo)出到ONNX應(yīng)該不會花很長時(shí)間。如果導(dǎo)出成功，下一個(gè)單元的輸出將包括 `ONNX model saved in paddlegan_anime.onnx`。
圖3-56 vision-paddlegan-anime轉(zhuǎn)換為ONNX
target_height, target_width = transformed_image.shape[1:]
target_height, target_width
predictor.generator.eval()
x_spec = InputSpec([None, 3, target_height, target_width], "float32", "x")
paddle.onnx.export(predictor.generator, str(model_path), input_spec=[x_spec], opset_version=11)
2)???? ONNX轉(zhuǎn)換為IR文件
OpenVINO? 的IR格式允許在模型文件中存儲預(yù)處理的標(biāo)準(zhǔn)化。這樣就不再需要手動(dòng)對輸入圖像進(jìn)行規(guī)范化處理了。讓我們檢查一下.run()方法使用的變換。
圖3-57 vision-paddlegan-anime函數(shù)使用
predictor.__init__??
t = predictor.transform.transforms[0]
t.params
## 若查看ResizeToScale轉(zhuǎn)換的文檔和代碼，取消對下面一行的注釋
# t??
3）使用模型轉(zhuǎn)換器執(zhí)行轉(zhuǎn)換
通常有三種變換：調(diào)整大小、轉(zhuǎn)置和歸一化，其中歸一化使用[127.5, 127.5, 127.5]的平均值和尺度。在調(diào)用ResizeToScale類時(shí)，以(256,256)作為大小的參數(shù)。進(jìn)一步的分析表明，這就是要調(diào)整的最小尺寸。ResizeToScale變換將圖像的大小調(diào)整為參數(shù)中指定的大小。ResizeToScale參數(shù)中指定的尺寸，寬度和高度是32的倍數(shù)。
圖3-58 vision-paddlegan-anime轉(zhuǎn)換IR模型
mo = mo_onnx.__file__
python = sys.executable
onnx_path = model_path.with_suffix(".onnx")
print("Exporting ONNX model to IR... This may take a few minutes.")
! $python $mo --input_model $onnx_path --output_dir $MODEL_DIR --input_shape [1,3,$target_height,$target_width] --model_name $MODEL_NAME --data_type "FP16" --mean_values="[127.5,127.5,127.5]" --scale_values="[127.5,127.5,127.5]" --log_level "CRITICAL"
5、 使用ONNX及IR模型進(jìn)行推理
我們現(xiàn)在可以用PaddleGAN模型中的adjust_brightness()方法對模型進(jìn)行推理，但是為了在不安裝PaddleGAN的情況下使用IR模型，檢查這些函數(shù)的作用并提取它們是很有用的，將為后續(xù)的推理做準(zhǔn)備。
1)???? 準(zhǔn)備后處理功能函數(shù)
圖3-59 vision-background-removal后處理函數(shù)
平均亮度是通過一個(gè)標(biāo)準(zhǔn)公式計(jì)算出來的，見https://www.w3.org/TR/AERT/#color-contrast。為了調(diào)整亮度，要計(jì)算源圖像和目標(biāo)（動(dòng)漫）圖像之間的亮度差，并在此基礎(chǔ)上調(diào)整目標(biāo)圖像的亮度。然后，圖像被轉(zhuǎn)換為8位圖像。這些函數(shù)將其用于推斷IR模型。
圖3-60 vision-paddlegan-anime IR推理準(zhǔn)備
predictor.adjust_brightness??
predictor.calc_avg_brightness??
def calc_avg_brightness(img):
R = img[..., 0].mean()
G = img[..., 1].mean()
B = img[..., 2].mean()
brightness = 0.299 * R + 0.587 * G + 0.114 * B
return brightness, B, G, R
def adjust_brightness(dst, src):
brightness1, B1, G1, R1 = AnimeGANPredictor.calc_avg_brightness(src)
brightness2, B2, G2, R2 = AnimeGANPredictor.calc_avg_brightness(dst)
brightness_difference = brightness1 / brightness2
dstf = dst * brightness_difference
dstf = np.clip(dstf, 0, 255)
dstf = np.uint8(dstf)
return dstf
2)???? 使用IR模型推理
加載IR模型，并按照PaddleGAN模型的相同步驟進(jìn)行推理。IR模型的生成有一個(gè)輸入形狀，它是根據(jù)輸入圖像計(jì)算出來的。如果你對具有不同輸入形狀的圖像進(jìn)行推理，結(jié)果可能與PaddleGAN的結(jié)果不同。
圖3-61 vision-paddlegan-anime IR推理引擎初始化
圖3-62 vision-paddlegan-anime執(zhí)行推理
# 加載并準(zhǔn)備IR模型。
ie = IECore()
net = ie.read_network(ir_path)
exec_net = ie.load_network(net, "CPU")
input_key = next(iter(net.input_info.keys()))
output_key = next(iter(net.outputs.keys()))
# 第1步。加載一個(gè)圖像并轉(zhuǎn)換為RGB
image_path = Path("data/coco_bricks.png")
image = cv2.cvtColor(cv2.imread(str(image_path), flags=cv2.IMREAD_COLOR), cv2.COLOR_BGR2RGB)
# Step 2. Transform the image (only resize and transpose are still required)
# 第2步。對圖像進(jìn)行轉(zhuǎn)換（需要調(diào)整大小和轉(zhuǎn)置）。
resized_image = cv2.resize(image, (target_width, target_height))
input_image = resized_image.transpose(2, 0, 1)[None, :, :, :]
# Step 3. Do inference.
# 第3步 推理。
result_ir = exec_net.infer({input_key: input_image})
# Step 4. Convert the inference result to an image following the same steps as
# PaddleGAN's predictor.run() function
# 第4步 將推理結(jié)果轉(zhuǎn)換為圖像，步驟與以下相同
# PaddleGAN的預(yù)測器.run()函數(shù)
result_image_ir = (result_ir[output_key] * 0.5 + 0.5)[0] * 255
result_image_ir = result_image_ir.transpose((1, 2, 0))
# Step 5. Resize the result image
# 第5步 調(diào)整結(jié)果圖像的大小
result_image_ir = cv2.resize(result_image_ir, image.shape[:2][::-1])
# Step 6. Adjust the brightness
# 第6步 調(diào)整亮度
result_image_ir = adjust_brightness(result_image_ir, image)
# Step 7. Save the result image
# 第7步 保存結(jié)果圖像
anime_fn_ir = Path(f"{OUTPUT_DIR}/{image_path.stem}_anime_ir").with_suffix(".jpg")
if cv2.imwrite(str(anime_fn_ir), result_image_ir[:, :, (2, 1, 0)]):
print(f"The anime image was saved to {anime_fn_ir}")
3)???? 顯示結(jié)果
圖3-63 vision-paddlegan-anime結(jié)果可視化
fig, ax = plt.subplots(1, 2, figsize=(25, 15))
ax[0].imshow(image)
ax[1].imshow(result_image_ir)
ax[0].set_title("Image")
ax[1].set_title("OpenVINO IR result");
6、 性能比較
在上面的步驟中，我們使用原始模型以及IR模型進(jìn)行推理，都得到了期望的結(jié)果。現(xiàn)在測量在圖像上進(jìn)行推理所需的時(shí)間。這給出了一個(gè)性能的指示,但這并不是一個(gè)完美的測量。由于PaddleGAN模型需要相當(dāng)多的內(nèi)存來進(jìn)行推理，我們只在一個(gè)圖像上測量推理。
圖3-64 vision-paddlegan-anime 性能對比
NUM_IMAGES = 1
start = time.perf_counter()
for _ in range(NUM_IMAGES):
exec_net.infer(inputs={input_key: input_image})
end = time.perf_counter()
time_ir = end - start
print(
f"IR model in Inference Engine/CPU: {time_ir/NUM_IMAGES:.3f} "
f"seconds per image, FPS: {NUM_IMAGES/time_ir:.2f}"
)
## Uncomment the lines below to measure inference time on an Intel iGPU.
## Note that it will take some time to load the model to the GPU
## 若測量英特爾iGPU上的推理時(shí)間，取消下面的注釋，
## 注意，加載模型到GPU上需要一些時(shí)間。
# if "GPU" in ie.available_devices:
# ? ? # Loading the IR model on the GPU takes some time
# ? ? exec_net_multi = ie.load_network(net, "GPU")
# ? ? start = time.perf_counter()
# ? ? for _ in range(NUM_IMAGES):
# ? ? ? ? exec_net_multi.infer(inputs={input_key: input_image})
# ? ? end = time.perf_counter()
# ? ? time_ir = end - start
# ? ? print(
# ? ? ? ? f"IR model in Inference Engine/GPU: {time_ir/NUM_IMAGES:.3f} "
# ? ? ? ? f"seconds per image, FPS: {NUM_IMAGES/time_ir:.2f}"
# ? ? )
# else:
# ? ? print("A supported iGPU device is not available on this system.")
## PADDLEGAN_INFERENCE is defined in the section "Inference on PaddleGAN model"
## Uncomment the next line to enable a performance comparison with the PaddleGAN model
## if you disabled it earlier.
# PADDLEGAN_INFERENCE = True
if PADDLEGAN_INFERENCE:
with paddle.no_grad():
start = time.perf_counter()
for _ in range(NUM_IMAGES):
predictor.generator(input_tensor)
end = time.perf_counter()
time_paddle = end - start
print(
f"PaddleGAN model on CPU: {time_paddle/NUM_IMAGES:.3f} seconds per image, "
f"FPS: {NUM_IMAGES/time_paddle:.2f}"
)
由結(jié)果不難看出，經(jīng)過模型優(yōu)化器轉(zhuǎn)換，使用IR模型進(jìn)行推理，可以使CPU的推理性能提升20多倍。
3.5PaddleGan與OpenVINO? 實(shí)現(xiàn)圖像超級分辨率
關(guān)于GAN生成對抗網(wǎng)絡(luò)在上一節(jié)中已有介紹，這里不再贅述。本節(jié)我們利用PaddleGAN與OpenVINO? 實(shí)現(xiàn)圖像的超級分辨率。本案例將RealSR（真實(shí)世界的超級分辨率）模型從PaddlePaddle/PaddleGAN轉(zhuǎn)換為OpenVINO? 的中間表示（IR）格式，并展示了PaddleGAN和IR模型的推理結(jié)果。這個(gè)模型在小圖像（最大800x600）上處理效果較好。
關(guān)于各種PaddleGAN超分辨率模型的更多信息，見PaddleGAN的文檔。關(guān)于RealSR的更多信息，請看CVPR 2020的【研究論文】
(?https://openaccess.thecvf.com/content_CVPRW_2020/papers/w31/Ji_Real-World_Super-Resolution_via_Kernel_Estimation_and_Noise_Injection_CVPRW_2020_paper.pdf?)
學(xué)習(xí)目標(biāo)：
了解PaddleGan RealSR模型及應(yīng)用場景
鞏固學(xué)習(xí)推理引擎使用流程并熟練應(yīng)用
鞏固學(xué)習(xí)利用模型優(yōu)化器將Paddle模型轉(zhuǎn)換為IR模型
1、 導(dǎo)入模型
圖3-65 vision-paddlegan-superresolution 導(dǎo)入模塊
import sys
import time
import warnings
from pathlib import Path
import cv2
import matplotlib.pyplot as plt
import numpy as np
import paddle
from IPython.display import HTML, FileLink, ProgressBar, clear_output, display
from IPython.display import Image as DisplayImage
from openvino.inference_engine import IECore
from paddle.static import InputSpec
from PIL import Image
from ppgan.apps import RealSRPredictor
sys.path.append("../utils")
from notebook_utils import NotebookAlert
2、 環(huán)境配置
圖3-66 vision-paddlegan-superresolution 環(huán)境設(shè)置
# 下載以及轉(zhuǎn)換模型的名稱
MODEL_NAME = "paddlegan_sr"
MODEL_DIR = Path("model")
OUTPUT_DIR = Path("output")
OUTPUT_DIR.mkdir(exist_ok=True)
model_path = MODEL_DIR / MODEL_NAME
ir_path = model_path.with_suffix(".xml")
onnx_path = model_path.with_suffix(".onnx")
3、 下載權(quán)重文件
圖3-67 vision-paddlegan-superresolution 下載RealSR權(quán)重文件
# 如果模型權(quán)重沒有被下載的話, 運(yùn)行這個(gè)單元將下載模型權(quán)重文件
# 這可能需要一些時(shí)間
sr = RealSRPredictor()
4、 函數(shù)使用說明
圖3-68 vision-paddlegan-superresolution 函數(shù)使用說明
sr.run??
sr.run_image??
sr.norm??
sr.denorm??
運(yùn)行時(shí)檢查輸入是圖像還是視頻。對于圖像，它將圖像加載為rgb圖像，將其歸一化，并將其轉(zhuǎn)換為paddle張量。它通過調(diào)用self.model()加載到網(wǎng)絡(luò)中，然后進(jìn)行 "非規(guī)范化"。歸一化函數(shù)簡單地將所有圖像值除以255。這將一個(gè)整數(shù)值在0到255之間的圖像轉(zhuǎn)換為一個(gè)浮點(diǎn)值在0到1之間的圖像。然后，它將圖像值在0到255之間進(jìn)行剪切，并將圖像轉(zhuǎn)換為標(biāo)準(zhǔn)的rgb圖像，其整數(shù)值范圍為0到255。
5、 原始模型推理
若要使用PaddlePaddle模型進(jìn)行推理，請?jiān)谙旅娴膯卧裰性O(shè)置PADDLEGAN_INFERENCE為True。執(zhí)行推理會化較長時(shí)間，默認(rèn)為false。
圖3-69 vision-paddlegan-superresolution原始模型推理
# 將PADDLEGAN_INFERENCE設(shè)為True，以使用PaddlePaddle模型進(jìn)行推理。
# 對于較大的圖像，這可能需要很長的時(shí)間。
#
PADDLEGAN_INFERENCE = False
if PADDLEGAN_INFERENCE:
# load the input image and convert to tensor with input shape
# 加載輸入圖像并轉(zhuǎn)換為具有輸入形狀的張量
IMAGE_PATH = Path("data/coco_tulips.jpg")
image = cv2.cvtColor(cv2.imread(str(IMAGE_PATH)), cv2.COLOR_BGR2RGB)
input_image = image.transpose(2, 0, 1)[None, :, :, :] / 255
input_tensor = paddle.to_tensor(input_image.astype(np.float32))
if max(image.shape) > 400:
NotebookAlert(
f"This image has shape {image.shape}. Doing inference will be slow "
"and the notebook may stop responding. Set PADDLEGAN_INFERENCE to False "
"to skip doing inference on the PaddlePaddle model.",
"warning",
)
if PADDLEGAN_INFERENCE:
# Do inference, and measure how long it takes
# 進(jìn)行推理，并測量它所需的時(shí)間
print(f"Start superresolution inference for {IMAGE_PATH.name} with shape {image.shape}...")
start_time = time.perf_counter()
sr.model.eval()
with paddle.no_grad():
result = sr.model(input_tensor)
end_time = time.perf_counter()
duration = end_time - start_time
result_image = (
(result.numpy().squeeze() * 255).clip(0, 255).astype("uint8").transpose((1, 2, 0))
)
print(f"Superresolution image shape: {result_image.shape}")
print(f"Inference duration: {duration:.2f} seconds")
plt.imshow(result_image);
6、 使用IR模型推理
如上節(jié)所述，實(shí)現(xiàn)IR模型推理先將PaddlePaddle模型導(dǎo)出轉(zhuǎn)換為ONNX格式，再將ONNX格式轉(zhuǎn)換為IR格式，注意OpenVINO? 也支持直接加載ONNX格式。
1)???? 將原始模型轉(zhuǎn)換為ONNX
圖3-70 vision-paddlegan-superresolution 導(dǎo)出ONNX模型
# 忽略PaddlePaddle的警告。
# 表達(dá)式A+B的行為已經(jīng)統(tǒng)一為 elementwise_add(X, Y, axis=-1)
warnings.filterwarnings("ignore")
sr.model.eval()
# ONNX export requires an input shape in this format as parameter
# ONNX的輸出需要這種格式的輸入形狀作為參數(shù)
x_spec = InputSpec([None, 3, 299, 299], "float32", "x")
paddle.onnx.export(sr.model, str(model_path), input_spec=[x_spec], opset_version=13)
2)???? 利用模型優(yōu)化器將ONNX轉(zhuǎn)換為IR模型
圖3-71 vision-paddlegan-superresolution 生成IR文件
if not ir_path.exists():
print("Exporting ONNX model to IR... This may take a few minutes.")
! mo --input_model $onnx_path --input_shape "[1,3,299,299]" --model_name $MODEL_NAME --output_dir "$MODEL_DIR" --data_type "FP16" --log_level "CRITICAL"
3)???? 用IR模型推理
初始化推理引擎
圖3-72 vision-paddlegan-superresolution 推理引擎初始化
# 讀取網(wǎng)絡(luò)并獲得輸入和輸出名稱
ie = IECore()
net = ie.read_network(ir_path)
input_layer = next(iter(net.input_info.keys()))
output_layer = next(iter(net.outputs.keys()))
加載并顯示圖片
圖3-73 vision-paddlegan-superresolution 加載顯示圖片
# 加載并顯示圖片
IMAGE_PATH = Path("data/coco_tulips.jpg")
image = cv2.cvtColor(cv2.imread(str(IMAGE_PATH)), cv2.COLOR_BGR2RGB)
if max(image.shape) > 800:
NotebookAlert(
f"This image has shape {image.shape}. The notebook works best with images with "
"a maximum side of 800x600. Larger images may work well, but inference may "
"be slow",
"warning",
)
plt.imshow(image)
執(zhí)行推理
圖3-74 vision-paddlegan-superresolution 執(zhí)行推理
# # 根據(jù)圖像大小重塑網(wǎng)絡(luò)
net.reshape({input_layer: [1, 3, image.shape[0], image.shape[1]]})
# Load network to the CPU device (this may take a few seconds)
# 加載網(wǎng)絡(luò)到CPU（這可能需要幾秒鐘）。
exec_net = ie.load_network(net, "CPU")
# 將圖像轉(zhuǎn)換成網(wǎng)絡(luò)輸入形狀并將像素值除以255
# 見 "了解PaddleGAN模型 "部分
input_image = image.transpose(2, 0, 1)[None, :, :, :] / 255
start_time = time.perf_counter()
# Do inference
# 推理
ir_result = exec_net.infer({input_layer: input_image})
end_time = time.perf_counter()
duration = end_time - start_time
print(f"Inference duration: {duration:.2f} seconds")
顯示結(jié)果
圖3-75 vision-paddlegan-superresolution 顯示結(jié)果
# 獲得CHW格式的結(jié)果數(shù)組
result_array = ir_result[output_layer].squeeze()
# Convert array to image with same method as PaddleGAN:
# Multiply by 255, clip values between 0 and 255, convert to HWC INT8 image
# See "Investigate PaddleGAN model" section
# 用與PaddleGAN相同的方法將數(shù)組轉(zhuǎn)換為圖像。
# 乘以255，在0和255之間剪輯數(shù)值，轉(zhuǎn)換為HWC INT8圖像
# 見 "了解PaddleGAN模型 "部分
image_super = (result_array * 255).clip(0, 255).astype("uint8").transpose((1, 2, 0))
# Resize image with bicubic upsampling for comparison
# 用雙三次取樣來調(diào)整圖像大小，以便進(jìn)行比較
image_bicubic = cv2.resize(image, tuple(image_super.shape[:2][::-1]), interpolation=cv2.INTER_CUBIC)
plt.imshow(image_super)
生成對比動(dòng)畫
為了直觀地觀察插值和超分辨率圖像之間的差異，我們創(chuàng)建了一個(gè)在兩個(gè)版本之間切換的動(dòng)畫GIF。
圖3-76 vision-paddlegan-superresolution 動(dòng)畫對比
result_pil = Image.fromarray(image_super)
bicubic_pil = Image.fromarray(image_bicubic)
gif_image_path = OUTPUT_DIR / Path(IMAGE_PATH.stem + "_comparison.gif")
final_image_path = OUTPUT_DIR / Path(IMAGE_PATH.stem + "_super.png")
result_pil.save(
fp=str(gif_image_path),
format="GIF",
append_images=[bicubic_pil],
save_all=True,
duration=1000,
loop=0,
)
result_pil.save(fp=str(final_image_path), format="png")
DisplayImage(open(gif_image_path, "rb").read(), width=1920 // 2)
生成對比視頻
創(chuàng)建一個(gè)帶有 "滑塊 "的視頻，在右邊顯示插值圖像，在左邊顯示超分辨率圖像。
在視頻中，超分辨率和雙三次插值圖像的大小被調(diào)整為2倍，以提高處理速度。這給出了一個(gè)超分辨率效果的指示。該視頻被保存為.avi視頻。你可以點(diǎn)擊鏈接下載該視頻，或者直接從圖像目錄中打開，在本地播放。
圖3-77 vision-paddlegan-superresolution 視頻對比
FOURCC = cv2.VideoWriter_fourcc(*"MJPG")
IMAGE_PATH = Path(IMAGE_PATH)
result_video_path = OUTPUT_DIR / Path(f"{IMAGE_PATH.stem}_comparison_paddlegan.avi")
video_target_height, video_target_width = (
image_super.shape[0] // 2,
image_super.shape[1] // 2,
)
out_video = cv2.VideoWriter(
str(result_video_path),
FOURCC,
90,
(video_target_width, video_target_height),
)
resized_result_image = cv2.resize(image_super, (video_target_width, video_target_height))[
:, :, (2, 1, 0)
]
resized_bicubic_image = cv2.resize(image_bicubic, (video_target_width, video_target_height))[
:, :, (2, 1, 0)
]
progress_bar = ProgressBar(total=video_target_width)
progress_bar.display()
for i in range(2, video_target_width):
# 創(chuàng)建一個(gè)框架，其中左邊的部分（直到i像素寬度）包含了
# 超分辨率圖像，而右邊部分（從i像素寬度開始）包含
# 插值圖像
comparison_frame = np.hstack(
(
resized_result_image[:, :i, :],
resized_bicubic_image[:, i:, :],
)
)
# 在超分辨率和雙曲線部分之間創(chuàng)建一個(gè)小的黑色邊界線
# 和圖像的二維部分之間創(chuàng)建一個(gè)小的黑色邊界線
comparison_frame[:, i - 1 : i + 1, :] = 0
out_video.write(comparison_frame)
progress_bar.progress = i
progress_bar.update()
out_video.release()
clear_output()
video_link = FileLink(result_video_path)
video_link.html_link_str = "%s"
display(HTML(f"The video has been saved to {video_link._repr_html_()}"))
3.6本章小結(jié)
通過本章學(xué)習(xí)相信大家已經(jīng)完全掌握了OpenVINO??推理引擎以及模型優(yōu)化器的使用，通過多個(gè)筆記實(shí)操，相信大家找到了開發(fā)人工智能應(yīng)用的感覺。AI開發(fā)非難事，只要找到合適的工具，掌握恰當(dāng)?shù)姆椒ū憧梢詮氖氯斯ぶ悄軕?yīng)用開發(fā)。如果您系統(tǒng)學(xué)習(xí)完本章節(jié)后依舊沒能踏入人工智能開發(fā)的大門，那一定是本教程不夠好，也請您與我們聯(lián)絡(luò)給予反饋。如果您通過學(xué)習(xí)教程已經(jīng)開始人工智能的開發(fā)，我們歡迎您與我們聯(lián)絡(luò)，分享您的成功經(jīng)驗(yàn)，讓我們一起幫助更多的人工智能開發(fā)者學(xué)習(xí)。
如果您已經(jīng)熟練掌握通過OpenVINO?Notebook筆記開發(fā)人工智能應(yīng)用，我建議您下載OpenVINO? 開發(fā)環(huán)境探尋更多的功能，并且體驗(yàn)更加豐富的組合案例及行業(yè)應(yīng)用案例，希望對項(xiàng)目開發(fā)有所幫助。
下載鏈接：
https://www.intel.com/content/www/us/en/developer/tools/openvino-toolkit/overview.html
在當(dāng)前所有案例中，我們使用預(yù)訓(xùn)練模型進(jìn)行人工智能開發(fā)，這大大簡化了開發(fā)進(jìn)程。但是，之于AI開發(fā)全流程，還欠缺訓(xùn)練部分。在下一章節(jié)中，我們將學(xué)習(xí)從訓(xùn)練到推理再到優(yōu)化的全過程。此外，我們也將介紹如何利用DevCloud的功能加速我們硬件選型，最終實(shí)現(xiàn)利用英特爾生態(tài)資源加速人工智能產(chǎn)品進(jìn)入市場的進(jìn)程。
