Beskrivning

Vi pratar om AI nästan dagligen på grund av dess växande inverkan på att ersätta människors manuella arbete. Att bygga AI-aktiverad programvara har vuxit snabbt på kort tid. Företag och företag tror på att integrera pålitlig och ansvarsfull AI i sin applikation för att generera mer intäkter. Den mest utmanande delen av att integrera AI i en applikation är modellinferensen och beräkningsresurserna som används för att träna modellen. Många tekniker finns redan som förbättrar prestandan genom att optimera modellen under slutledning med färre beräkningsresurser. Med denna problemformulering introducerade Intel OpenVINO Toolkit, en absolut spelväxlare. OpenVINO är en verktygslåda med öppen källkod för att optimera och distribuera AI-inferens.

Inlärningsmål

I den här artikeln kommer vi att:

• Förstå vad OpenVINO Toolkit är och dess syfte med att optimera och distribuera AI-inferensmodeller.
• Utforska de praktiska användningsfallen för OpenVINO, särskilt dess betydelse i framtiden för AI vid kanten.
• Lär dig hur du implementerar ett textdetekteringsprojekt i en bild med OpenVINO i Google Colab.
• Upptäck nyckelfunktionerna och fördelarna med att använda OpenVINO, inklusive dess modellkompatibilitet och stöd för hårdvaruacceleratorer och hur det kan påverka olika branscher och applikationer.

Denna artikel publicerades som en del av Data Science Blogathon.

Vad är OpenVINO?

OpenVINO, som står för Öppna visuell slutledning och neural nätverksoptimering, är en verktygslåda med öppen källkod utvecklad av Intel-teamet för att underlätta optimering av modeller för djupinlärning. Visionen med OpenVINO-verktygslådan är att öka din AI djupinlärningsmodeller och distribuera applikationen på plats, på enheten eller i molnet med mer effektivitet och effektivitet.

OpenVINO Toolkit är särskilt värdefullt eftersom det stöder många ramar för djupinlärning, inklusive populära sådana TensorFlow, PyTorch, Onnx och Caffe. Du kan träna dina modeller med ditt föredragna ramverk och sedan använda OpenVINO för att konvertera och optimera dem för distribution på Intels hårdvaruacceleratorer, som processorer, GPU:er, FPGA:er och VPU:er.

När det gäller inferens, erbjuder OpenVINO Toolkit olika verktyg för modellkvantisering och komprimering, vilket avsevärt kan minska storleken på djupinlärningsmodeller utan att förlora slutledningsnoggrannheten.

Varför använda OpenVINO?

Vurmen med AI är för närvarande inte på humör att sakta ner. Med denna popularitet är det uppenbart att fler och fler applikationer kommer att utvecklas för att köra AI-applikationer på plats och på enheten. Några av de utmanande områden där OpenVINO utmärker sig gör det till ett idealiskt val varför det är avgörande att använda OpenVINO:

OpenVINO Model Zoo

OpenVINO förser en modell zoo med förutbildade modeller för djupinlärning för uppgifter som stabil spridning, tal, objektdetektering och mer. Dessa modeller kan tjäna som utgångspunkt för dina projekt, vilket sparar tid och resurser.

Modellkompatibilitet

OpenVINO stöder många ramverk för djupinlärning, inklusive TensorFlow, PyTorch, ONNx och Caffe. Detta innebär att du kan använda ditt föredragna ramverk för att träna dina modeller och sedan konvertera och optimera dem för distribution med hjälp av OpenVINO Toolkit.

High Performance

OpenVINO är optimerad för snabb slutledning, vilket gör den lämplig för realtidsapplikationer som datorseende, robotik och IoT-enheter. Den utnyttjar hårdvaruacceleration som FPGA, GPU och TPU för att uppnå hög genomströmning och låg latens.

AI i Edge Future med Intel OpenVINO

AI in Edge är det mest utmanande området att ta itu med. Att bygga en optimerad lösning för att lösa hårdvarubegränsningar är inte längre omöjligt med hjälp av OpenVINO. Framtiden för AI i Edge med denna Toolkit har potential att revolutionera olika industrier och applikationer.

Låt oss ta reda på hur OpenVINO fungerar för att göra den lämplig för AI i Edge.

• Det primära steget är att bygga en modell med hjälp av dina favoritramverk för djupinlärning och konvertera den till en OpenVINO-kärnmodell. Ett annat alternativ är att använda förtränade modeller med OpenVINO-modellzoo.
• När modellen väl har tränats är nästa steg komprimering. OpenVINO Toolkit tillhandahåller ett neuralt nätverkskomprimeringsramverk (NNCF).
• Model Optimizer konverterar den förtränade modellen till ett lämpligt format. Optimeraren består av IR-data. IR-data hänvisar till Mellanrepresentation av en modell för djupinlärning, som redan är optimerad och transformerad för implementering med OpenVINO. Modellvikterna är i .XML- och .bin-filformat.
• Vid modelldistribution kan OpenVINO Inference Engine ladda och använda IR-data på målhårdvaran, vilket möjliggör snabb och effektiv slutledning för olika applikationer.

Med detta tillvägagångssätt kan OpenVINO spela en viktig roll i AI i Edge. Låt oss smutsa ner händerna med ett kodprojekt för att implementera textdetektering i en bild med hjälp av OpenVINO Toolkit.

Textidentifiering i en bild med OpenVINO Toolkit

I den här projektimplementeringen kommer vi att använda Google Colab som ett medium för att köra applikationen framgångsrikt. I det här projektet kommer vi att använda horisontell-text-detektion-0001 modell från OpenVINO-modellen Zoo. Denna förtränade modell upptäcker horisontell text i inmatade bilder och returnerar en klick data i formen (100,5). Det här svaret ser ut som (x_min, y_min, x_max, y_max, conf) format.

Steg-för-steg-kodimplementering

Installation

!pip install openvino

Importera nödvändiga bibliotek

Låt oss importera de nödvändiga modulerna för att köra den här applikationen. OpenVINO stöder en hjälpfunktion för att ladda ner förtränade vikter från den medföljande källkodens URL.

import urllib.request base = "https://raw.githubusercontent.com/openvinotoolkit/openvino_notebooks"
utils_file = "/main/notebooks/utils/notebook_utils.py" urllib.request.urlretrieve( url= base + utils_file, filename='notebook_utils.py'
) from notebook_utils import download_file

Du kan verifiera att notebook_utils nu har laddats ned, låt oss snabbt importera de återstående modulerna.

import openvino import cv2
import matplotlib.pyplot as plt
import numpy as np
from pathlib import Path

Ladda ner vikter

Initiera sökvägen för att ladda ner IR-datamodellviktfiler med horisontell textdetektering i .xml- och .bin-format.

base_model_dir = Path("./model").expanduser() model_name = "horizontal-text-detection-0001"model_xml_name = f'{model_name}.xml'
model_bin_name = f'{model_name}.bin' model_xml_path = base_model_dir / model_xml_name
model_bin_path = base_model_dir / model_bin_name

I följande kodavsnitt använder vi tre variabler för att förenkla vägen där de förtränade modellvikterna finns.

model_zoo = "https://storage.openvinotoolkit.org/repositories/open_model_zoo/2022.3/models_bin/1/"
algo = "horizontal-text-detection-0001/FP32/"
xml_url = "horizontal-text-detection-0001.xml"
bin_url = "horizontal-text-detection-0001.bin" model_xml_url = model_zoo+algo+xml_url
model_bin_url = model_zoo+algo+bin_url download_file(model_xml_url, model_xml_name, base_model_dir)
download_file(model_bin_url, model_bin_name, base_model_dir)

Ladda modell

OpenVINO tillhandahåller en Core-klass för att interagera med OpenVINO-verktygslådan. Core-klassen tillhandahåller olika metoder och funktioner för att arbeta med modeller och utföra slutledningar. Använd read_model och skicka in model_xml_path. Efter att ha läst modellen kompilerar du modellen för en specifik målenhet.

core = Core() model = core.read_model(model=model_xml_path)
compiled_model = core.compile_model(model=model, device_name="CPU") input_layer_ir = compiled_model.input(0)
output_layer_ir = compiled_model.output("boxes")

I ovanstående kodavsnitt returnerar den överensstämmande modellen ingångsbildens form (704,704,3), en RGB-bild men i PyTorch-format (1,3,704,704) där 1 är batchstorleken, 3 är antalet kanaler, 704 är höjd och vikt. Utdata returnerar (x_min, y_min, x_max, y_max, conf). Låt oss ladda en ingångsbild nu.

Ladda bild

Modellens vikt är [1,3,704,704]. Följaktligen bör du ändra storlek på inmatningsbilden för att matcha denna form. I Google Colab eller din kodredigerare kan du ladda upp din indatabild, och i vårt fall heter bildfilen sample_image.jpg.

image = cv2.imread("sample_image.jpg") # N,C,H,W = batch size, number of channels, height, width.
N, C, H, W = input_layer_ir.shape # Resize the image to meet network expected input sizes.
resized_image = cv2.resize(image, (W, H)) # Reshape to the network input shape.
input_image = np.expand_dims(resized_image.transpose(2, 0, 1), 0) print("Model weights shape:")
print(input_layer_ir.shape)
print("Image after resize:")
print(input_image.shape)

Visa ingångsbilden.

plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
plt.axis("off")

Inferensmotor

Tidigare använde vi modellvikter för att sammanställa modellen. Använd kompilera modellen i kontext till ingångsbilden.

# Create an inference request.
boxes = compiled_model([input_image])[output_layer_ir] # Remove zero only boxes.
boxes = boxes[~np.all(boxes == 0, axis=1)]

Förutsägelse

Den kompilerade_modellen returnerar rutor med koordinaterna för begränsningsramen. Vi använder cv2-modulen för att skapa en rektangel och putText för att lägga till konfidenspoängen ovanför den upptäckta texten.

def detect_text(bgr_image, resized_image, boxes, threshold=0.3, conf_labels=True): # Fetch the image shapes to calculate a ratio. (real_y, real_x), (resized_y, resized_x) = bgr_image.shape[:2], resized_image.shape[:2] ratio_x, ratio_y = real_x / resized_x, real_y / resized_y # Convert image from BGR to RGB format. rgb_image = cv2.cvtColor(bgr_image, cv2.COLOR_BGR2RGB) # Iterate through non-zero boxes. for box in boxes: # Pick a confidence factor from the last place in an array. conf = box[-1] if conf > threshold: (x_min, y_min, x_max, y_max) = [ int(max(corner_position * ratio_y, 10)) if idx % 2 else int(corner_position * ratio_x) for idx, corner_position in enumerate(box[:-1]) ] # Draw a box based on the position, parameters in rectangle function are: # image, start_point, end_point, color, thickness. rgb_image = cv2.rectangle(rgb_image, (x_min, y_min), (x_max, y_max),(0,255, 0), 10) # Add text to the image based on position and confidence. if conf_labels: rgb_image = cv2.putText( rgb_image, f"{conf:.2f}", (x_min, y_min - 10), cv2.FONT_HERSHEY_SIMPLEX, 4, (255, 0, 0), 8, cv2.LINE_AA, ) return rgb_image

Visa utdatabilden

plt.imshow(detect_text(image, resized_image, boxes));
plt.axis("off")

Slutsats

Avslutningsvis har vi framgångsrikt byggt textdetektering i ett bildprojekt med hjälp av OpenVINO Toolkit. Intel-teamet förbättrar kontinuerligt Toolkit. OpenVINO stöder också förtränade Generativa AI-modeller som Stable Diffusion, ControlNet, Speech-to-text och mer.

Key Takeaways

• OpenVINO är ett spelväxlarverktyg med öppen källkod för att öka dina AI-modeller för djupinlärning och distribuera applikationen på plats, på enheten eller i molnet.
• Det primära målet med OpenVINO är att optimera de djupa modellerna med olika modellkvantisering och komprimering, vilket avsevärt kan minska storleken på modeller för djupinlärning utan att förlora slutledningsnoggrannhet.
• Det här verktygspaketet stöder även distribution av AI-applikationer på hårdvaruacceleratorer som GPU, FPGA, ASIC, TPU och mer.
• Olika branscher kan använda OpenVINO och utnyttja dess potential för att påverka AI vid kanten.
• Användningen av modellen zoo förutbildade modellen är enkel eftersom vi implementerade textdetektering i bilder med bara några rader kod.

Vanliga frågor

Medierna som visas i den här artikeln ägs inte av Analytics Vidhya och används efter författarens gottfinnande.

Relaterad

• SEO-drivet innehåll och PR-distribution. Bli förstärkt idag.
• PlatoData.Network Vertical Generative Ai. Styrka dig själv. Tillgång här.
• PlatoAiStream. Web3 Intelligence. Kunskap förstärkt. Tillgång här.
• Platoesg. Kol, CleanTech, Energi, Miljö, Sol, Avfallshantering. Tillgång här.
• PlatoHealth. Biotech och kliniska prövningar Intelligence. Tillgång här.
• Källa: https://www.analyticsvidhya.com/blog/2023/10/intels-openvino-toolkit/