Conseils aux débutants en Python pour utiliser l'exemple Scikit-image pour eux-mêmes 8 Mesure du temps de traitement et profileur

Scikit-image, scikit-learn, lors de l'utilisation d'OpenCV-Python, le temps de traitement préoccupation. Par conséquent, dans cet article, je présenterai l'entrée à la mesure du temps de traitement et du profilage.

** Mesure du temps de traitement **

import cv2 La liaison OpenCV est déjà disponible dans un environnement sans erreur. Cv2.getTickCount (), cv2.getTickFrequency () dedans Vous pouvez utiliser pour mesurer le temps de traitement. Un exemple d'article Mesurer les performances avec OpenCV Cette fonction fonctionne de la même manière sous Windows et Linux, vous pouvez donc mesurer le temps de traitement sans compromettre la portabilité des scripts.

Sur la base des exemples qui ont été utilisés à plusieurs reprises jusqu'à présent, mesurons comment le temps de traitement change lorsque la taille de l'image d'entrée est modifiée. [Normalized Cut] (http://scikit-image.org/docs/dev/auto_examples/segmentation/plot_ncut.html#example-segmentation-plot-ncut-py) Modifions la taille de l'image d'entrée avec l'exemple de.

** Exemple: changement du temps d'exécution en fonction de la taille de l'image **

.py:ex_getTickCount.py

from skimage import data, segmentation, color
from matplotlib import pyplot as plt
import cv2

img0 = data.coffee()

x=[]
y=[]

a=1.2
for i in range(10):
    r=a**i
    newSize=(int(img0.shape[1]/r), int(img0.shape[0]/r))
    img=cv2.resize(img0, newSize)
    t1=cv2.getTickCount()
    labels1 = segmentation.slic(img, compactness=30, n_segments=400)
    out1 = color.label2rgb(labels1, img, kind='avg')
    t2=cv2.getTickCount()
    dt=(t2-t1)/cv2.getTickFrequency()
    print newSize, dt
    x.append(newSize[0])
    y.append(dt)
    
plt.figure(1)
plt.plot(x,y, "*-")
plt.xlabel("width")
plt.ylabel("time [sec]")
plt.grid(True)
plt.show()

Figure: Modification du temps d'exécution en fonction de la taille de l'image

Si vous regardez le graphique, vous pouvez voir que lorsque la largeur de l'image est doublée, le temps de traitement est quadruplé. En d'autres termes, si la largeur de l'image est divisée par deux, le temps de traitement sera de 1/4 fois. Faire en sorte que ce temps de traitement soit identique tout en conservant la même largeur de l'image, cela revient à réduire le temps de traitement de 75%. En général, une telle accélération n'est pas aisée, et dans le cas d'un traitement dans lequel l'image peut être réduite, la réduction de la taille de l'image est un standard pour raccourcir le temps de traitement.

** Exemple: modification du temps d'exécution à chaque image de la vidéo (série chronologique et histogramme) **

Tout d'abord, Astuces pour les débutants en Python pour utiliser l'exemple Scikit-image pour eux-mêmes 2 Traitez plusieurs fichiers Introduction d'un script qui traite la coupe normalisée pour chaque image. Cette fois, sur cette base, j'ai mesuré le temps de traitement dans chaque image et fait un graphique du résultat.

.py:ex_plot_ncut2_time.py

from skimage import data, io, segmentation, color
from skimage.future import graph
import cv2

def plotNcut(img):    
    labels1 = segmentation.slic(img, compactness=30, n_segments=200)
    out1 = color.label2rgb(labels1, img, kind='avg')
    
    g = graph.rag_mean_color(img, labels1, mode='similarity')
    labels2 = graph.cut_normalized(labels1, g)
    out2 = color.label2rgb(labels2, img, kind='avg')

    return out1, out2

name="768x576.avi"
cap=cv2.VideoCapture(name)
i= -1
out=open("time_data.txt", "wt")
while cap.isOpened():
    i += 1
    ret, img=cap.read()
    if ret != True:
        break
    if i>100:
        break
    [h, w] = img.shape[:2]
    img = cv2.resize(img, (w/2, h/2))
    t1=cv2.getTickCount()
    out1, out2 = plotNcut(img)
    t2=cv2.getTickCount()
    dt=(t2-t1)/cv2.getTickFrequency()
    out.write("%f\n" % dt)
    cv2.imshow("img", out1)
    cv2.waitKey(100)
    cv2.imwrite("org_%04d.png " % i,  img)
    cv2.imwrite("img_%04d.png " % i,  out1)
    print i
    
out.close()

.py:view_data.py

import numpy as np
import pylab

name="time_data.txt"

data=np.loadtxt(name)

print data

pylab.figure(1)
pylab.subplot(1,2,1)
pylab.plot(data)
pylab.ylabel("time[s]")
pylab.grid(True)
pylab.subplot(1,2,2)
pylab.hist(data)
pylab.grid(True)
pylab.xlim([3, 4])
pylab.xlabel("time[s]")
pylab.show()

En affichant la série temporelle ou l'histogramme de cette manière, il devient plus facile d'évaluer combien le temps de traitement peut changer en fonction de la scène, plutôt que de mesurer le temps de traitement une seule fois. Essayer de l'utiliser est l'un des indices pour comprendre la méthode.

** Utilisation de Profiler **

Python a un profileur dans la bibliothèque standard, vous pouvez donc profiler des scripts python quel que soit le type de système d'exploitation ou de processeur, tel que Windows ou Linux. Dans le cas de C ++, la méthode de profilage diffère selon le système d'exploitation, le type de compilateur et le type d'outil. Même si les outils portent le même nom, l'utilisation peut être extrêmement différente selon la version et vous pouvez vous sentir gêné. À cet égard, le profileur Python est Bibliothèque standard Python 26.4. Profileur Python Vous pouvez exécuter le profileur de manière simple, comme illustré dans.

Le principal point d'entrée des profileurs est la fonction globale profile.run () (ou cProfile.run ()).

Article de blog Profilage de code Python

Essayez d'imiter comment l'utiliser en regardant des exemples tels que.

Quelle est la plus grande répartition du temps de traitement dans profile.run ()? Le nombre d'appels de fonction est-il conforme aux attentes ou la fonction est-elle appelée plus que prévu? Je vérifie ces pièces.

Vous pouvez comparer le temps de fonctionnement et la répartition du même script python avec le même profileur entre la source de portage Python (par exemple, Windows) et la destination de portage python.

Le temps de traitement des fonctions OpenCV-Python (par exemple, la détection de visage et la détection de personne) varie considérablement en fonction de la façon dont OpenCV cv2.pyd utilisé est construit et si le processeur est multicœur. Cela devrait devenir clair lorsque vous le testez avec un profileur Python.

Tâche:

Conseils pour les débutants en Python pour utiliser l'exemple Scikit-image pour eux-mêmes 2 Traiter plusieurs fichiers

Basé sur l'exemple du traitement de plusieurs fichiers et du traitement dans plusieurs cadres Mesurons le temps d'exécution.

matplotlib a une fonction hist () qui facilite la création d'un histogramme. Mesurons en fait combien le temps de traitement varie et créons un histogramme.

** Article de référence **

Pourquoi detectMultiScale () est lent sur Raspberry Pi

Vérifions parallel_for

** Livres de référence **

Micha Gorelick, Ian Ozsvald, traduit par Aizo Aikawa, "High Performance Python"

À propos de la vitesse de traitement de SVM (SVC) de scikit-learn Est un exemple d'article pratique sur la mesure du temps.

Remarque: Quand j'ai réalisé que ce serait correct de remplacer la partie qui prenait trop de temps dans le traitement d'image par une image réduite, j'ai essayé de réduire la taille de l'image. Le temps de traitement a été considérablement réduit. Python a un profil simple, vous pouvez donc identifier rapidement quel processus prend du temps. Une fois que cela est identifié, n'accélérez que cette partie. Parmi les nombreuses lignes, le simple fait d'ajouter le processus de réduction de l'image à l'une d'entre elles peut augmenter la vitesse de traitement de 10 fois ou plus.

Astuce 9 Utilisation à partir du langage C