Inizia

Ottimizzazione dell'inferenza di YOLO con OpenVINO

Intel OpenVINO toolkit ecosystem overview

Introduzione#

Quando distribuisci modelli di deep learning, in particolare quelli per il rilevamento degli oggetti, come i modelli Ultralytics YOLO, di solito ottimizzi l'inferenza per la latenza (risposte rapide alle singole richieste) oppure per il throughput (molte richieste elaborate contemporaneamente). Questa guida spiega come usare il toolkit OpenVINO di Intel per entrambi gli obiettivi, dalle applicazioni consumer alle distribuzioni su larga scala.

Ottimizzazione della latenza#

L'ottimizzazione della latenza è fondamentale per le applicazioni che richiedono una risposta immediata da un singolo modello a fronte di un singolo input, come accade tipicamente negli scenari consumer. L'obiettivo è ridurre al minimo il ritardo tra l'input e il risultato dell'inferenza. Tuttavia, ottenere una latenza bassa richiede un'attenta valutazione, soprattutto quando si eseguono inferenze simultanee o si gestiscono più modelli.

Strategie chiave per ottimizzare la latenza#

  • Una sola inferenza per dispositivo: il modo più semplice per ottenere una latenza bassa è limitarsi a una sola inferenza alla volta per dispositivo. Spesso, una maggiore concorrenza aumenta la latenza.
  • Sfruttare i sottodispositivi: dispositivi come le CPU multi-socket o le GPU multi-tile possono eseguire più richieste con un aumento minimo della latenza, utilizzando i propri sottodispositivi interni.
  • Suggerimenti sulle prestazioni di OpenVINO: usare ov::LATENCY di OpenVINO per la proprietà ov::performance_mode durante la compilazione del modello semplifica la messa a punto delle prestazioni e offre un approccio indipendente dal dispositivo e a prova di futuro.

Gestione della latenza della prima inferenza#

  • Memorizzazione nella cache del modello: per limitare l'impatto dei tempi di caricamento e compilazione del modello sulla latenza, usa la cache del modello quando possibile. Negli scenari in cui non è possibile ricorrere alla cache, in genere le CPU offrono i tempi di caricamento del modello più rapidi.
  • Mappatura del modello e lettura: per ridurre i tempi di caricamento, OpenVINO ha sostituito la lettura del modello con la mappatura. Tuttavia, se il modello si trova su un'unità rimovibile o di rete, valuta l'uso di ov::enable_mmap(false) per tornare alla lettura.
  • Selezione automatica del dispositivo: questa modalità avvia l'inferenza sulla CPU e passa a un acceleratore quando è pronto, riducendo la latenza della prima inferenza.

Ottimizzazione del throughput#

Ottimizzare il throughput è fondamentale negli scenari che gestiscono molte richieste di inferenza simultaneamente, per massimizzare l'utilizzo delle risorse senza compromettere significativamente le prestazioni delle singole richieste.

Approcci per ottimizzare il throughput#

  1. Suggerimenti sulle prestazioni di OpenVINO: un metodo di alto livello e a prova di futuro per migliorare il throughput su diversi dispositivi usando i suggerimenti sulle prestazioni.

    import openvino as ov
    import openvino.properties.hint as hints
    
    core = ov.Core()
    model = core.read_model("yolo26n_openvino_model/yolo26n.xml")
    config = {hints.performance_mode: hints.PerformanceMode.THROUGHPUT}
    compiled_model = core.compile_model(model, "GPU", config)
  2. Batch e stream espliciti: un approccio più granulare che prevede batch espliciti e l'uso di stream per una messa a punto avanzata delle prestazioni.

Progettazione di applicazioni orientate al throughput#

Per massimizzare il throughput, le applicazioni dovrebbero:

  • Elaborare gli input in parallelo, sfruttando appieno le capacità del dispositivo.
  • Scomporre il flusso di dati in richieste di inferenza simultanee, pianificate per l'esecuzione parallela.
  • Usa l'API asincrona con callback per mantenere l'efficienza ed evitare che i dispositivi restino inutilizzati.

Esecuzione su più dispositivi#

La modalità multi-dispositivo di OpenVINO semplifica la scalabilità del throughput bilanciando automaticamente le richieste di inferenza tra i dispositivi, senza richiedere la gestione dei dispositivi a livello applicativo.

Miglioramenti delle prestazioni nel mondo reale#

L'implementazione delle ottimizzazioni OpenVINO con i modelli Ultralytics YOLO può offrire notevoli miglioramenti delle prestazioni. Come mostrano i benchmark, i modelli OpenVINO INT8 hanno funzionato da 2,9 a 6,0 volte più velocemente di PyTorch sulle CPU Intel Core Ultra, mentre le GPU integrate degli stessi processori hanno eseguito i modelli FP32 da 3,6 a 29,1 volte più velocemente di PyTorch sulla CPU. Il post del blog sulla serie Intel Core Ultra 3 presenta i più recenti di questi processori.

Ad esempio, sulla CPU di un Intel Core Ultra X7 358H, il modello YOLO26n INT8 ha impiegato 9,99 ms per immagine, contro i 29,28 ms di PyTorch, con un mAP50-95 pari a 0,4720 contro 0,4765 su COCO128, una lieve perdita di accuratezza.

Implementazione pratica#

Per esportare e ottimizzare il tuo modello Ultralytics YOLO per OpenVINO, usa la funzionalità di esportazione:

from ultralytics import YOLO

# Carica un modello
model = YOLO("yolo26n.pt")

# Esporta il modello nel formato OpenVINO
model.export(format="openvino", quantize=16)  # Esporta con precisione FP16

Dopo l'esportazione, puoi eseguire l'inferenza con il modello ottimizzato:

# Carica il modello OpenVINO
ov_model = YOLO("yolo26n_openvino_model/")

# Esegui l'inferenza (Ultralytics compila i modelli OpenVINO con il suggerimento sulle prestazioni LATENCY)
results = ov_model("https://ultralytics.com/images/bus.jpg", verbose=True)

Conclusione#

Ottimizzare i modelli Ultralytics YOLO con OpenVINO per ridurre la latenza o aumentare il throughput può migliorare significativamente le prestazioni della tua applicazione. La scelta tra ottimizzazione della latenza e del throughput dipende dalle esigenze specifiche dell'applicazione e dalle caratteristiche dell'ambiente di distribuzione.

Che tu stia ottimizzando per ottenere risposte in tempo reale o per massimizzare il throughput nell'elaborazione su larga scala, parti dai requisiti della tua applicazione, scegli l'indicazione prestazionale più adatta ed esegui benchmark sull'hardware di destinazione.

Domande frequenti#

  • L'ottimizzazione dei modelli Ultralytics YOLO per una latenza bassa prevede alcune strategie chiave:

    1. Una sola inferenza per dispositivo: limita le inferenze a una alla volta per dispositivo per ridurre al minimo i ritardi.
    2. Sfrutta i sottodispositivi: usa dispositivi come CPU multi-socket o GPU multi-tile, in grado di gestire più richieste con un aumento minimo della latenza.
    3. Suggerimenti sulle prestazioni di OpenVINO: usa ov::LATENCY di OpenVINO durante la compilazione del modello per una messa a punto semplificata e indipendente dal dispositivo.

    Per altri consigli pratici sull'ottimizzazione della latenza, consulta la sezione Ottimizzazione della latenza della nostra guida.

  • OpenVINO migliora il throughput dei modelli Ultralytics YOLO massimizzando l'utilizzo delle risorse del dispositivo senza sacrificare le prestazioni. Tra i principali vantaggi:

    • Suggerimenti sulle prestazioni: messa a punto semplice e di alto livello delle prestazioni su diversi dispositivi.
    • Batch e stream espliciti: messa a punto per prestazioni avanzate.
    • Esecuzione su più dispositivi: bilanciamento automatico del carico di inferenza, per semplificare la gestione a livello applicativo.

    Esempio di configurazione:

    import openvino as ov
    import openvino.properties.hint as hints
    
    core = ov.Core()
    model = core.read_model("yolo26n_openvino_model/yolo26n.xml")
    config = {hints.performance_mode: hints.PerformanceMode.THROUGHPUT}
    compiled_model = core.compile_model(model, "GPU", config)

    Scopri di più sull'ottimizzazione del throughput nella sezione Ottimizzazione del throughput della nostra guida dettagliata.

  • Per ridurre la latenza della prima inferenza, valuta queste pratiche:

    1. Memorizzazione nella cache del modello: usa la cache del modello per ridurre i tempi di caricamento e compilazione.
    2. Mappatura del modello e lettura: usa la mappatura (ov::enable_mmap(true)) per impostazione predefinita, ma passa alla lettura (ov::enable_mmap(false)) se il modello si trova su un'unità rimovibile o di rete.
    3. Selezione automatica del dispositivo: usa la modalità AUTO per avviare l'inferenza sulla CPU e passare a un acceleratore quando è pronto.

    Per strategie dettagliate sulla gestione della latenza della prima inferenza, consulta la sezione Gestione della latenza della prima inferenza.

  • Per bilanciare l'ottimizzazione della latenza e del throughput, devi comprendere le esigenze della tua applicazione:

    • Ottimizzazione della latenza: ideale per le applicazioni in tempo reale che richiedono risposte immediate (ad esempio, le app consumer).
    • Ottimizzazione del throughput: ideale per gli scenari con numerose inferenze simultanee, in cui si massimizza l'uso delle risorse (ad esempio, le distribuzioni su larga scala).

    Usare i suggerimenti sulle prestazioni di alto livello e le modalità multi-dispositivo di OpenVINO può aiutarti a trovare il giusto equilibrio. Scegli i suggerimenti sulle prestazioni di OpenVINO più adatti ai tuoi requisiti specifici.

  • Sì, i modelli Ultralytics YOLO possono essere esportati in molti altri runtime. Le opzioni includono:

    Scopri altre integrazioni nella pagina delle integrazioni Ultralytics.

Commenti2

Fai una domanda, condividi i tuoi risultati o aiuta qualcun altro.

  1. KvsoniGitHub

    Is it possible to use the in built classes and functions of ultralytics to do pre-processing and post-processing and using openVINO for the inference part?

    1. Paula DerrengerUltralytics(modificato)

      @Kvsoni hi there!

      Yes, that's possible, and the simplest way is to let Ultralytics do it all: export the model to OpenVINO and load the exported folder with YOLO. Ultralytics then handles the pre-processing (resizing, normalization), runs inference with OpenVINO, and does the post-processing (decoding the output into boxes):

      from ultralytics import YOLO
      
      model = YOLO("yolo26n.pt")
      model.export(format="openvino")  # creates 'yolo26n_openvino_model/'
      
      ov_model = YOLO("yolo26n_openvino_model/")
      results = ov_model("path/to/image.jpg")
      results[0].show()

      If you want to run the OpenVINO runtime yourself, note that YOLO model objects do not expose preprocess() or postprocess(); those steps live in the predictor classes (e.g. ultralytics.models.yolo.detect.DetectionPredictor).

      For more detailed guidance on optimizing your model with OpenVINO, including strategies for latency and throughput, please refer to our guide: Optimizing OpenVINO Inference for Ultralytics YOLO Models.

      Feel free to reach out if you have any more questions or need further assistance! 😊