Migliorare l’ottimizzazione e la distribuzione dell’IA con il kit OpenVINO di Intel

Migliorare l'ottimizzazione e la distribuzione dell'IA con il kit OpenVINO di Intel un'evoluzione nella performance e nell'efficienza

Introduzione

Parliamo quasi quotidianamente di AI a causa del suo crescente impatto nella sostituzione del lavoro manuale umano. Costruire software abilitati dall’AI è cresciuto rapidamente in un breve periodo di tempo. Aziende e imprese credono nell’integrazione di un’AI affidabile e responsabile nelle loro applicazioni per generare maggiori entrate. La parte più sfidante dell’integrazione dell’AI in un’applicazione è l’inferenza del modello e le risorse di calcolo utilizzate per addestrare il modello. Esistono già molte tecniche che migliorano le prestazioni ottimizzando il modello durante l’inferenza con minori risorse di calcolo. Con questo problema, Intel ha introdotto OpenVINO Toolkit, un cambiamento di gioco assoluto. OpenVINO è un toolkit open-source per l’ottimizzazione e il deployment dell’inferenza dell’AI.

Obiettivi di apprendimento

In questo articolo, comprenderemo:

Cosa è OpenVINO Toolkit e il suo scopo nell’ottimizzazione e nel deployment di modelli di inferenza dell’AI.
Esploreremo i casi d’uso pratici di OpenVINO, in particolare la sua importanza nel futuro dell’AI alla periferia.
Come implementare un progetto di rilevamento del testo in un’immagine utilizzando OpenVINO in Google Colab.
Scopriremo le funzionalità chiave e i vantaggi dell’utilizzo di OpenVINO, inclusa la compatibilità del modello e il supporto per gli acceleratori hardware e come può influenzare diverse industrie e applicazioni.

Questo articolo è stato pubblicato come parte del Data Science Blogathon.

Cosa è OpenVINO?

OpenVINO, che sta per Open Visual Inference and Neural Network Optimization, è un toolkit open-source sviluppato dal team di Intel per facilitare l’ottimizzazione dei modelli di deep learning. La visione del toolkit OpenVINO è quella di potenziare i tuoi modelli di AI di deep learning e deployare l’applicazione on-premise, on-device o nel cloud con maggiore efficienza ed efficacia.

OpenVINO Toolkit è particolarmente prezioso perché supporta molti framework di deep learning, tra cui quelli popolari come TensorFlow, PyTorch, Onnx e Caffe. Puoi addestrare i tuoi modelli utilizzando il framework preferito e poi utilizzare OpenVINO per convertirli e ottimizzarli per il deployment sugli acceleratori hardware di Intel, come CPU, GPU, FPGA e VPU.

Riguardo all’inferenza, OpenVINO Toolkit offre vari strumenti per la quantizzazione e la compressione del modello, che possono ridurre significativamente le dimensioni dei modelli di deep learning senza perdere l’accuratezza dell’inferenza.

Perché utilizzare OpenVINO?

La follia dell’AI non è attualmente intenzionata a rallentare. Con questa popolarità, è evidente che sempre più applicazioni verranno sviluppate per eseguire applicazioni di AI on-premise e on-device. Alcune delle aree sfidanti in cui spicca OpenVINO lo rendono una scelta ideale e cruciale per l’utilizzo di OpenVINO:

OpenVINO Model Zoo

OpenVINO fornisce uno zoo di modelli con deep-learning pre-addestrati per compiti come Stable Diffusion, Speech, Object detection e altro ancora. Questi modelli possono servire come punto di partenza per i tuoi progetti, risparmiando tempo e risorse.

Compatibilità del modello

OpenVINO supporta molti framework di deep learning, tra cui TensorFlow, PyTorch, ONNx e Caffe. Ciò significa che puoi utilizzare il tuo framework preferito per addestrare i tuoi modelli e poi convertirli e ottimizzarli per il deployment utilizzando OpenVINO Toolkit.

Alte prestazioni

OpenVINO è ottimizzato per l’inferenza veloce, rendendolo adatto per applicazioni in tempo reale come computer vision, robotica e dispositivi IoT. Sfrutta l’accelerazione hardware come FPGA, GPU e TPU per ottenere alto throughput e bassa latenza.

AI nel Futuro della Periferia Utilizzando Intel OpenVINO

L’IA in Edge è l’area più sfidante da affrontare. Costruire una soluzione ottimizzata per superare i vincoli hardware non è più impossibile grazie all’aiuto di OpenVINO. Il futuro dell’IA in Edge con questo Toolkit ha il potenziale per rivoluzionare diverse industrie e applicazioni.

Scopriamo come funziona OpenVINO per renderlo adatto all’IA in Edge.

Il primo passo è costruire un modello utilizzando i tuoi framework di deep-learning preferiti e convertirlo in un modello core di OpenVINO. Un’altra alternativa è utilizzare modelli pre-addestrati utilizzando lo zoo dei modelli di OpenVINO.
Una volta addestrato il modello, il passo successivo è la compressione. OpenVINO Toolkit fornisce un framework di compressione delle reti neurali (NNCF).
Model Optimizer converte il modello pre-addestrato in un formato adatto. L’ottimizzatore contiene dati IR. I dati IR si riferiscono alla rappresentazione intermedia di un modello di deep learning, che è già ottimizzato e trasformato per la distribuzione con OpenVINO. I pesi del modello sono in formato file .XML e .bin.
Alla distribuzione del modello, il motore di inferenza di OpenVINO può caricare e utilizzare i dati IR sull’hardware di destinazione, consentendo un’elaborazione veloce ed efficiente per varie applicazioni.

Con questo approccio, OpenVINO può svolgere un ruolo vitale nell’IA in Edge. Proviamo a sporcarci le mani con un progetto di codice per implementare la rilevazione del testo in un’immagine utilizzando OpenVINO Toolkit.

Rilevazione del Testo in un’Immagine Utilizzando OpenVINO Toolkit

In questa implementazione del progetto, utilizzeremo Google Colab come VoAGI per eseguire con successo l’applicazione. In questo progetto, useremo il modello horizontal-text-detection-0001 dello Zoo dei modelli di OpenVINO. Questo modello pre-addestrato rileva il testo orizzontale nelle immagini di input e restituisce un blob di dati nella forma (x_min, y_min, x_max, y_max, conf).

Implementazione del Codice Passo-Passo

Installazione

!pip install openvino

Importazione delle Librerie Necessarie

Importiamo i moduli necessari per eseguire questa applicazione. OpenVINO supporta una funzione di utilità per scaricare i pesi pre-addestrati dall’URL del codice sorgente fornito.

import urllib.requestbase = "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

Puoi verificare che notebook_utils sia stato scaricato correttamente, importiamo rapidamente i moduli rimanenti.

import openvinoimport cv2import matplotlib.pyplot as pltimport numpy as npfrom pathlib import Path

Scarica i Pesi

Inizializziamo il percorso per scaricare i file dei pesi del modello IR per la rilevazione del testo orizzontale nei formati .xml e .bin.

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_namemodel_bin_path = base_model_dir / model_bin_name

Nel frammento di codice seguente, utilizziamo tre variabili per semplificare il percorso in cui esistono i pesi del modello pre-addestrato.

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_urlmodel_bin_url =  model_zoo+algo+bin_urldownload_file(model_xml_url, model_xml_name, base_model_dir)download_file(model_bin_url, model_bin_name, base_model_dir)

Carica modello

OpenVINO fornisce una classe Core per interagire con il toolkit OpenVINO. La classe Core fornisce vari metodi e funzioni per lavorare con modelli e fare inferenza. Usa il metodo read_model e passa il percorso del model_xml. Dopo aver letto il modello, compila il modello per un dispositivo di destinazione specifico.

  core = Core() modello = core.read_model(model=model_xml_path) modello_compilato = core.compile_model(model=modello, nome_dispositivo="CPU") input_layer_ir = modello_compilato.input(0) output_layer_ir = modello_compilato.output("boxes")

Nel frammento di codice sopra, il modello compilato restituisce la forma dell’immagine di input (704,704,3), un’immagine RGB ma in formato PyTorch (1,3,704,704) dove 1 è la dimensione del batch, 3 è il numero dei canali, 704 è l’altezza e la larghezza. L’output restituisce (x_min, y_min, x_max, y_max, conf). Carichiamo ora un’immagine di input.

Carica immagine

Il peso del modello è [1,3,704,704]. Di conseguenza, è necessario ridimensionare l’immagine di input in base a questa forma. In Google Colab o nel tuo editor di codice, puoi caricare la tua immagine di input e nel nostro caso, il file immagine è denominato sample_image.jpg.

  immagine = cv2.imread("sample_image.jpg") # N,C,H,W = dimensione del batch, numero di canali, altezza, larghezza.N, C, H, W = input_layer_ir.shape # Ridimensiona l'immagine per soddisfare le dimensioni di input previste dalla rete.immagine_ridimensionata = cv2.resize(immagine, (W, H)) # Ridimensiona alla forma di input della rete.input_image = np.expand_dims(immagine_ridimensionata.transpose(2, 0, 1), 0) print("Forma dei pesi del modello:") print(input_layer_ir.shape) print("Immagine dopo il ridimensionamento:") print(input_image.shape)

Mostra l’immagine di input.

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

Inference Engine

In precedenza, abbiamo usato i pesi del modello per compilare il modello. Usa la compilazione del modello nel contesto dell’immagine di input.

  # Crea una richiesta di inferenza. caselle = modello_compilato([input_image])[output_layer_ir] # Rimuovi solo le caselle con zero. box = caselle[~np.all(caselle == 0, axis = 1)]

Predizione

Il modello compilato restituisce le caselle con le coordinate del rettangolo delimitatore. Utilizziamo il modulo cv2 per creare un rettangolo e putText per aggiungere il punteggio di confidenza sopra il testo rilevato.

  def detect_text(bgr_image, resized_image, boxes, threshold=0.3, conf_labels=True): # Ottieni la forma dell'immagine per calcolare un rapporto. (real_y, real_x), (resized_y, resized_x) = bgr_image.shape[:2], resized_image.shape[:2] rapporto_x, rapporto_y = real_x / resized_x, real_y / resized_y # Converti l'immagine dal formato BGR a RGB. immagine_rgb = cv2.cvtColor(bgr_image, cv2.COLOR_BGR2RGB) # Itera attraverso le caselle diverse da zero. for box in boxes: # Prendi un fattore di confidenza dall'ultima posizione in un array. conf = box[-1] if conf > threshold: (x_min, y_min, x_max, y_max) = [ int(max(corner_position * rapporto_y, 10)) if idx % 2 else int(corner_position * rapporto_x) for idx, corner_position in enumerate(box[:-1]) ] # Disegna un rettangolo basato sulla posizione, i parametri nella funzione rettangolo sono: # immagine, punto_iniziale, punto_fine, colore, spessore immagine_rgb = cv2.rectangle(immagine_rgb, (x_min, y_min), (x_max, y_max),(0,255, 0), 10) # Aggiungi testo all'immagine in base alla posizione e alla confidenza. if conf_labels: immagine_rgb = cv2.putText( immagine_rgb, f" {conf:.2f}", (x_min, y_min - 10), cv2.FONT_HERSHEY_SIMPLEX, 4, (255, 0, 0), 8, cv2.LINE_AA, ) return immagine_rgb

Mostra l’immagine di output

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

Conclusioni

Per concludere, abbiamo costruito con successo un progetto di rilevamento del testo in un’immagine utilizzando OpenVINO Toolkit. Il team di Intel migliora continuamente il Toolkit. OpenVINO supporta anche modelli di intelligenza artificiale generativi pre-allenati come Stable Diffusion, ControlNet, Speech-to-text e altri.

Punti chiave

OpenVINO è un’innovativa ed open source tool per potenziare i tuoi modelli di deep learning AI e distribuire l’applicazione on-premise, on-device o nel cloud.
Il principale obiettivo di OpenVINO è ottimizzare i modelli di deep learning con varie tecniche di quantizzazione e compressione dei modelli, che possono ridurre significativamente le dimensioni dei modelli senza perdere l’accuratezza dell’inferenza.
Questo Toolkit supporta anche la distribuzione di applicazioni AI su acceleratori hardware come GPU, FPGA, ASIC, TPU e altri ancora.
Diverse industrie possono adottare OpenVINO e sfruttarne il potenziale per avere un impatto sull’AI al bordo.
L’utilizzo del model zoo pre-allenato è semplice, come abbiamo implementato il rilevamento del testo nelle immagini con solo poche righe di codice.

Domande Frequenti

Il materiale mostrato in questo articolo non è di proprietà di Analytics Vidhya ed è utilizzato a discrezione dell’autore.

AI,blogathon,detection,Intel,Models,OpenVINO Toolkit

Questo articolo di intelligenza artificiale presenta POYO-1 un framework di intelligenza artificiale che decifra l’attività neurale in registrazioni su larga scala tramite deep learning.

Migliorare l’ottimizzazione e la distribuzione dell’IA con il kit OpenVINO di Intel