Introductie

We praten bijna dagelijks over AI vanwege de groeiende impact ervan op het vervangen van het handmatige werk van mensen. Het bouwen van AI-software is in korte tijd snel gegroeid. Bedrijven en bedrijven geloven in het integreren van betrouwbare en verantwoorde AI in hun toepassing om meer omzet te genereren. Het meest uitdagende onderdeel van het integreren van AI in een applicatie zijn de modelinferentie en de rekenbronnen die worden gebruikt bij het trainen van het model. Er bestaan ​​al veel technieken die de prestaties verbeteren door het model tijdens inferentie te optimaliseren met minder rekenbronnen. Met deze probleemstelling introduceerde Intel de OpenVINO Toolkit, een absolute game-changer. OpenVINO is een open-source toolkit voor het optimaliseren en inzetten van AI-inferentie.

leerdoelen

In dit artikel zullen we:

• Begrijp wat de OpenVINO Toolkit is en het doel ervan bij het optimaliseren en inzetten van AI-inferentiemodellen.
• Ontdek de praktische gebruiksscenario's van OpenVINO, vooral het belang ervan in de toekomst van AI aan de rand.
• Leer hoe u een tekstdetectieproject in een afbeelding implementeert met OpenVINO in Google Colab.
• Ontdek de belangrijkste kenmerken en voordelen van het gebruik van OpenVINO, inclusief de modelcompatibiliteit en ondersteuning voor hardwareversnellers en hoe dit verschillende industrieën en toepassingen kan beïnvloeden.

Dit artikel is gepubliceerd als onderdeel van het Data Science-blogathon.

Wat is OpenVINO?

OpenVINO, wat staat voor Open visuele inferentie en neurale netwerkoptimalisatie, is een open-source toolkit ontwikkeld door het Intel-team om de optimalisatie van deep learning-modellen te vergemakkelijken. De visie van de OpenVINO-toolkit is om uw AI een boost te geven diepgaande leermodellen en implementeer de applicatie op locatie, op het apparaat of in de cloud met meer efficiëntie en effectiviteit.

OpenVINO Toolkit is bijzonder waardevol omdat het veel deep learning-frameworks ondersteunt, inclusief populaire zoals TensorFlow, PyTorch, Onnx en Caffe. U kunt uw modellen trainen met behulp van het raamwerk van uw voorkeur en vervolgens OpenVINO gebruiken om ze te converteren en te optimaliseren voor implementatie op de hardwareversnellers van Intel, zoals CPU's, GPU's, FPGA's en VPU's.

Wat inferentie betreft, biedt OpenVINO Toolkit verschillende tools voor modelkwantisering en compressie, die de omvang van deep learning-modellen aanzienlijk kunnen verkleinen zonder de nauwkeurigheid van de inferentie te verliezen.

Waarom OpenVINO gebruiken?

De rage van AI is momenteel niet in de stemming om te vertragen. Met deze populariteit is het duidelijk dat er steeds meer applicaties zullen worden ontwikkeld om AI-applicaties op locatie en op apparaten uit te voeren. Een paar van de uitdagende gebieden waarin OpenVINO uitblinkt, maken het een ideale keuze waarom het cruciaal is om OpenVINO te gebruiken:

OpenVINO Model Dierentuin

OpenVINO stelt een modeldierentuin ter beschikking vooraf getrainde deep-learningmodellen voor taken zoals stabiele diffusie, spraak, objectdetectie en meer. Deze modellen kunnen dienen als uitgangspunt voor uw projecten, waardoor u tijd en middelen bespaart.

Compatibiliteit van modellen

OpenVINO ondersteunt veel deep learning-frameworks, waaronder TensorFlow, PyTorch, ONNx en Caffe. Dit betekent dat u uw voorkeursframework kunt gebruiken om uw modellen te trainen en ze vervolgens kunt converteren en optimaliseren voor implementatie met behulp van de OpenVINO Toolkit.

high performance

OpenVINO is geoptimaliseerd voor snelle gevolgtrekkingen, waardoor het geschikt is voor realtime toepassingen zoals computervisie, robotica en IoT-apparaten. Het maakt gebruik van hardwareversnelling zoals FPGA, GPU en TPU om een ​​hoge doorvoer en lage latentie te bereiken.

AI in de Edge-toekomst met behulp van Intel OpenVINO

AI in Edge is het meest uitdagende gebied om aan te pakken. Het bouwen van een geoptimaliseerde oplossing om hardwarebeperkingen op te lossen is niet langer onmogelijk met de hulp van OpenVINO. De toekomst van AI in Edge met deze Toolkit heeft het potentieel om een ​​revolutie teweeg te brengen in verschillende industrieën en toepassingen.

Laten we eens kijken hoe OpenVINO werkt om het geschikt te maken voor AI in Edge.

• De eerste stap is het bouwen van een model met behulp van uw favoriete deep-learning-frameworks en het omzetten ervan in een OpenVINO-kernmodel. Een ander alternatief is het gebruik van vooraf getrainde modellen met behulp van de OpenVINO-modeldierentuin.
• Nadat het model is getraind, is de volgende stap compressie. OpenVINO Toolkit biedt een Neural Network-compressieframework (NNCF).
• Model Optimizer converteert het vooraf getrainde model naar een geschikt formaat. De optimizer bestaat uit IR-gegevens. IR-gegevens hebben betrekking op de Intermediaire vertegenwoordiging van een deep learning-model, dat al is geoptimaliseerd en getransformeerd voor implementatie met OpenVINO. De modelgewichten zijn in .XML- en .bin-bestandsformaat.
• Bij de implementatie van het model kan de OpenVINO Inference Engine de IR-gegevens op de doelhardware laden en gebruiken, waardoor snelle en efficiënte gevolgtrekkingen voor verschillende toepassingen mogelijk zijn.

Met deze aanpak kan OpenVINO een cruciale rol spelen in AI in Edge. Laten we onze handen vuil maken met een codeproject om tekstdetectie in een afbeelding te implementeren met behulp van de OpenVINO Toolkit.

Tekstdetectie in een afbeelding met behulp van OpenVINO Toolkit

Bij deze projectimplementatie zullen we Google Colab als medium gebruiken om de applicatie succesvol te laten draaien. In dit project zullen we gebruik maken van de horizontale-tekstdetectie-0001 model uit het OpenVINO-model Zoo. Dit vooraf getrainde model detecteert horizontale tekst in invoerafbeeldingen en retourneert een klodder gegevens in de vorm (100,5). Deze reactie lijkt (x_min, y_min, x_max, y_max, conf) formaat.

Stapsgewijze code-implementatie

Installatie

!pip install openvino

Importeer vereiste bibliotheken

Laten we de vereiste modules importeren om deze applicatie uit te voeren. OpenVINO ondersteunt een utils-helperfunctie om vooraf getrainde gewichten te downloaden van de opgegeven broncode-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

U kunt verifiëren dat notebook_utils nu succesvol is gedownload. Laten we snel de resterende modules importeren.

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

Gewichten downloaden

Initialiseer het pad om IR-gegevensmodelgewichtsbestanden met horizontale tekstdetectie in .xml- en .bin-indeling te downloaden.

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

In het volgende codefragment gebruiken we drie variabelen om het pad te vereenvoudigen waar de vooraf getrainde modelgewichten bestaan.

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)

Laadmodel

OpenVINO biedt een Core-klasse voor interactie met de OpenVINO-toolkit. De klasse Core biedt verschillende methoden en functies voor het werken met modellen en het uitvoeren van gevolgtrekkingen. Gebruik read_model en geef het model_xml_path door. Nadat u het model hebt gelezen, compileert u het model voor een specifiek doelapparaat.

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")

In het bovenstaande codefragment retourneert het compatibele model de vorm van de invoerafbeelding (704,704,3), een RGB-afbeelding maar in PyTorch-indeling (1,3,704,704), waarbij 1 de batchgrootte is, 3 het aantal kanalen, 704 de hoogte en gewicht. Uitvoer retourneert (x_min, y_min, x_max, y_max, conf). Laten we nu een invoerafbeelding laden.

Laad afbeelding

Het modelgewicht is [1,3,704,704]. Daarom moet u het formaat van de invoerafbeelding overeenkomstig aanpassen aan deze vorm. In Google Colab of uw code-editor kunt u uw invoerafbeelding uploaden. In ons geval heet het afbeeldingsbestand 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)

Geef de invoerafbeelding weer.

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

Inferentiemachine

Voorheen gebruikten we modelgewichten om het model samen te stellen. Gebruik het compileren van het model in de context van de invoerafbeelding.

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

Voorspelling

Het gecompileerde_model retourneert vakken met de coördinaten van het begrenzingsvak. We gebruiken de cv2-module om een ​​rechthoek te maken en putText om de betrouwbaarheidsscore boven de gedetecteerde tekst toe te voegen.

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

Geef de uitvoerafbeelding weer

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

Conclusie

Tot slot hebben we met succes tekstdetectie in een beeldproject gebouwd met behulp van de OpenVINO Toolkit. Het Intel-team verbetert voortdurend de Toolkit. OpenVINO ondersteunt ook vooraf getrainde generatieve AI-modellen zoals Stable Diffusion, ControlNet, Speech-to-text en meer.

Key Takeaways

• OpenVINO is een baanbrekende open source-tool om uw AI-deep-learning-modellen een boost te geven en de applicatie op locatie, op het apparaat of in de cloud te implementeren.
• Het primaire doel van OpenVINO is het optimaliseren van de diepe modellen met verschillende modelkwantisering en compressie, waardoor de omvang van deep learning-modellen aanzienlijk kan worden verminderd zonder de nauwkeurigheid van de gevolgtrekkingen te verliezen.
• Deze Toolkit ondersteunt ook de implementatie van AI-applicaties op hardwareversnellers zoals GPU's, FPGA's, ASIC, TPU's en meer.
• Verschillende industrieën kunnen OpenVINO adopteren en het potentieel ervan benutten om impact te maken op AI aan de edge.
• Het gebruik van het voorgetrainde model van de dierentuin is eenvoudig omdat we met slechts een paar regels code tekstdetectie in afbeeldingen hebben geïmplementeerd.

Veelgestelde Vragen / FAQ

De in dit artikel getoonde media zijn geen eigendom van Analytics Vidhya en worden naar goeddunken van de auteur gebruikt.

Verwant

• Door SEO aangedreven content en PR-distributie. Word vandaag nog versterkt.
• PlatoData.Network Verticale generatieve AI. Versterk jezelf. Toegang hier.
• PlatoAiStream. Web3-intelligentie. Kennis versterkt. Toegang hier.
• PlatoESG. carbon, CleanTech, Energie, Milieu, Zonne, Afvalbeheer. Toegang hier.
• Plato Gezondheid. Intelligentie op het gebied van biotech en klinische proeven. Toegang hier.
• Bron: https://www.analyticsvidhya.com/blog/2023/10/intels-openvino-toolkit/