[PYTHON] Différence de vitesse d'exécution en fonction de la façon d'écrire la fonction Cython

Objectif

J'ai étudié comment la vitesse d'exécution change en fonction de la façon d'écrire des fonctions Cython.

Histoire

• '20 / 5/8 Première apparition Correction + '20 / 5/10 (clarifié que %% cython ou moins et% timeit ou moins sont exécutés dans différentes cellules, float64 → double, les remarques n'ont pas été vérifiées pour fonctionner dans l'environnement Jupyter, donc corrigées pour fonctionner)

Contexte

• Lors du calcul des valeurs numériques avec Python, utilisez Numpy pour accélérer. Si vous ne pouvez pas écrire facilement avec Numpy, utilisez Numba ou Cython, mais Numba peut ne pas être efficace et le temps d'exécution de Cython varie considérablement en fonction de la façon dont vous l'écrivez.
• Il est facile de penser que la saisie consiste à accélérer avec Cython, mais en réalité, il y a d'autres points à prendre en compte. Si vous ne le remarquez pas, vous pouvez rapidement conclure que "Python n'est pas du tout rapide" et que cela peut prendre du temps pour étudier d'autres langues.
• J'ai donc évalué systématiquement la différence de temps d'exécution en fonction du style d'écriture.

Méthode

• $ N $ nombre réel $ v_ {1}, \ ldots, v_ {n} $ au carré $ s = v_ {1} ^ {2} + v_ {2} ^ {2} + \ cdots + v_ { Considérons le problème du calcul de n} ^ {2} $. Pour simplifier, disons $ v_ {1} = v_ {2} = \ cdots = v_ {n} = 1.0 $, $ n = 10 ^ 6 $.
• Considérez les cinq facteurs indiqués dans le tableau ci-dessous comme des facteurs qui affectent la vitesse d'exécution. Nous avons préparé 17 types de code qui couvraient tous ces facteurs et évalué le temps d'exécution [^ 1].
• Environnement: Python 3.7 / Cython 0.29.17 / Numpy 1.18.1 / Jupyter Notebook

résultat

• ** La vitesse n'était guère augmentée uniquement en spécifiant le type, mais lorsque l'index était accessible en spécifiant le type, la vitesse était améliorée d'environ 10 à 20 fois **. L'effet d'autres facteurs était uniquement la croissance des cheveux sur l'erreur.
• Par conséquent, lors de la migration de Numpy ou Numba vers Cython, ** ce que vous vouliez vraiment écrire dans la diffusion est pour i in range (vs.shape [0]): et `vs [i] Il semble préférable d'avoir un accès à l'index sous la forme de **. ** Vous devriez éviter d'écrire '' pour v dans vs: comme s'il s'agissait d'une inclusion de liste **.

Détails

1. Préparation

Prenez la somme des carrés du prochain nombre de colonnes. Préparez deux versions de la liste Python et du tableau Numpy.

python

import numpy as np
vs_list = [1.0,]*10**6
vs_ndarray = np.ones((10**6,), dtype=np.double)

2. Python pour instruction

Les performances de la boucle for originale de Python étaient les suivantes [^ 2]. Il faut 300 à 400 ms pour obtenir la somme des carrés de 10 $ ^ 6 $ de nombres réels [^ 3]. ** En Python, il semble plus rapide d'utiliser l'itérateur docilement sans accès à l'index **.

1

def sum_py(vs):
    s = 0
    for v in vs:
        s += v
    return s

python

%timeit square_sum_py(vs_list)

2

def square_sum_py_range(vs):
    s = 0
    for i in range(len(vs)):
        s += vs[i]**2
    return s

python

%timeit square_sum_py_range(vs_list)

3. Diffusion Numpy

Sans surprise, la diffusion de Numpy peut accélérer considérablement les choses. Cependant, Cython est en fait utilisé lorsque la fonction de diffusion ne peut pas être utilisée, nous devons donc considérer d'autres méthodes ici. Vous pouvez voir que le traitement d'un tableau Numpy avec une instruction Python for le ralentit.

3

def square_sum_np(vs):
    return np.sum(vs**2)

python

%timeit square_sum_np(vs_ndarray)

4

#Fonction définie ci-dessus
%timeit square_sum_py(vs_ndarray)

5

#Fonction définie ci-dessus
%timeit square_sum_py_range(vs_ndarray)

4. Spécification du type d'argument

Alors, pensons ensuite à l'utilisation de Cython pour accélérer l'instruction for de Python. La façon de passer un tableau de bas niveau accessible en mémoire à une fonction en Cython est de spécifier le tableau Numpy directement en tant qu'argument (http://docs.cython.org/en/latest/src/tutorial/numpy). Il y a .html) et Comment spécifier une vue mémoire typée comme argument. Ici, nous allons commencer par l'ancienne méthode plus intuitive. En regardant les informations fragmentaires sur le net, il semble que seule la spécification de type soit efficace pour accélérer avec Cython. Cependant, comme vous pouvez le voir dans le tableau ci-dessous, la simple spécification des arguments de fonction dans un tableau Numpy n'est pas beaucoup plus rapide que le code Python d'origine (1) (6). À ce stade, la spécification des types d'éléments du tableau Numpy ne fait pas grand-chose (7). Bien sûr, c'est plus rapide que le code Python (4) en utilisant des tableaux Numpy, mais c'est tout, il n'y a aucune raison d'utiliser Cython.

6

%%cython
cimport numpy as np
def square_sum_cy_np(np.ndarray vs):
    cdef double v, s = 0.0
    for v in vs:
        s += v**2
    return s

python

%timeit square_sum_cy_np(vs_ndarray)

7

%%cython
cimport numpy as np
def square_sum_cy_np_typed(np.ndarray[np.double_t, ndim=1] vs):
    cdef double v, s = 0.0
    for v in vs:
        s += v**2
    return s

python

%timeit square_sum_cy_np_typed(vs_ndarray)

5. Accès à l'index

Ensuite, ce qu'il faut faire est de changer la méthode d'accès (comment écrire l'instruction for) à l'élément de tableau. L'accès à l'index sans typage d'élément est plus lent, mais l'accès à l'index avec typage d'élément est considérablement plus rapide.

8

%%cython
cimport numpy as np
def square_sum_cy_np_range(np.ndarray vs):
    cdef double s = 0.0
    for i in range(vs.shape[0]):
        s += vs[i]**2
    return s

python

%timeit square_sum_cy_np_range(vs_ndarray)

9

%%cython
cimport numpy as np
def square_sum_cy_np_typed_range(np.ndarray[np.double_t, ndim=1] vs):
    cdef double s = 0.0
    for i in range(vs.shape[0]):
        s += vs[i]**2
    return s

python

%timeit square_sum_cy_np_typed_range(vs_ndarray)

6. Omission de la fonction de contrôle

La documentation officielle décrit également comment omettre la fonction de vérification pour l'accès au tableau (10-13), mais la différence entre ne pas omettre la fonction de vérification (6-9) était légère. Il est vrai que 10 à 20% est plus rapide, mais ce n'est aussi efficace que la dernière poussée.

10

%%cython
cimport numpy as np
from cython import boundscheck, wraparound
def square_sum_cy_np_nocheck(np.ndarray vs):
    cdef double v, s = 0.0
    with boundscheck(False), wraparound(False):
        for v in vs:
            s += v**2
        return s

python

%timeit square_sum_cy_np_nocheck(vs_ndarray)

11

%%cython
cimport numpy as np
from cython import boundscheck, wraparound
def square_sum_cy_np_typed_nocheck(np.ndarray[np.double_t, ndim=1] a):
    cdef double d, s = 0.0
    with boundscheck(False), wraparound(False):
        for d in a:
            s += d**2
    return s

python

%timeit square_sum_cy_np_typed_nocheck(vs_ndarray)

12

%%cython
cimport numpy as np
from cython import boundscheck, wraparound
def square_sum_cy_np_range_nocheck(np.ndarray a):
    cdef double s = 0.0
    with boundscheck(False), wraparound(False):
        for i in range(a.shape[0]):
            s += a[i]**2
    return s

python

%timeit square_sum_cy_np_range_nocheck(vs_ndarray)

13

%%cython
cimport numpy as np
from cython import boundscheck, wraparound
def square_sum_cy_np_typed_range_nocheck(np.ndarray[np.double_t, ndim=1] a):
    cdef double s = 0.0
    with boundscheck(False), wraparound(False):
        for i in range(a.shape[0]):
            s += a[i]**2
    return s

python

%timeit square_sum_cy_np_typed_range_nocheck(vs_ndarray)

Vue mémoire typée

Une autre façon de passer un tableau de bas niveau accessible en mémoire à la fonction Cython consiste à spécifier une vue de mémoire typée comme argument. Cette méthode est recommandée dans les documents officiels. Comme vous pouvez le voir dans les résultats ci-dessous, c'est également la méthode d'accès aux éléments du tableau qui fonctionne dans ce cas.

14

%%cython
def square_sum_cy_mv(double[:] vs):
    cdef double v, s = 0.0
    for v in vs:
        s += v**2
    return s

python

%timeit square_sum_cy_np_typed_range_nocheck(vs_ndarray)

15

%%cython
def square_sum_cy_mv_range(double[:] vs):
    cdef double s = 0.0
    for i in range(vs.shape[0]):
        s += vs[i]**2
    return s

python

%timeit square_sum_cy_mv_range(vs_ndarray)

16

%%cython
from cython import boundscheck, wraparound
def square_sum_cy_mv_nocheck(double[:] vs):
    cdef double v, s = 0.0
    with boundscheck(False), wraparound(False):
        for v in vs:
            s += v**2
    return s

python

%timeit square_sum_cy_mv_nocheck(vs_ndarray)

17

%%cython
from cython import boundscheck, wraparound
def square_sum_cy_mv_range_nocheck(double[:] vs):
    cdef double s = 0.0
    with boundscheck(False), wraparound(False):
        for i in range(vs.shape[0]):
            s += vs[i]**2
    return s

python

%timeit square_sum_cy_mv_range_nocheck(vs_ndarray)

Considération

• En regardant les résultats ci-dessus, il semble préférable d'écrire quelque chose comme 15 ou 17 lorsque vous utilisez Cython pour compenser quelque chose qui ne peut pas être écrit avec Numpy. Bien sûr, la tendance sera différente selon le type de problème, mais je pense que ce domaine sera la première étape lors de l'utilisation de Cython la prochaine fois.
• Par souci, le CPU utilisé pour l'évaluation a peut-être été un peu trop lent [^ 3]. De plus, lors de l'exécution de calculs multi-parallèles à l'aide du GPU, il est nécessaire de reconsidérer depuis le début.

Remarques

• Comme indiqué dans Official Document, C l'allocation mémoire du tableau (vs) passée en argument. Si vous le spécifiez comme type, il sera légèrement plus rapide. Je ne me souciais pas de la méthode de compilation explicite, mais cela ne semble pas facile si je mets des restrictions telles que (1) calculer le tableau par rapport à l'extérieur de la fonction Cython et (2) utiliser la commande magique de Jupyter. Je n'ai pas organisé ce domaine, donc je l'ajouterai quand je le comprendrai.
• Il semble facile d'écrire ce qui suit dans un tableau multidimensionnel.

python

import numpy as np
%load_ext Cython

python

vs = np.ones((10**3,10**3), dtype=np.double)

python

%%cython
from cython import boundscheck, wraparound
cdef double square_sum(double[:, :] vs):
# def square_sum(double[:, :] vs):Même si c'est presque la même chose dans ce cas
    cdef:
        double s = 0.0
        Py_ssize_t nx = vs.shape[0]
        Py_ssize_t ny = vs.shape[1]
        Py_ssize_t i, j
    with boundscheck(False), wraparound(False):
        for i in range(nx):
            for j in range(ny):
                s += vs[i, j]**2
    return s

python

%timeit square_sum(vs)

[^ 1]: Le nombre de codes ne devient pas $ 2 \ times3 \ times2 \ times2 \ times2 = 24 $ car (1) il y a une corrélation entre les choix et (2) le code de référence est ajouté. C'est la cause. [^ 2]: Il y avait une variation maximale de ± 20% des valeurs mesurées par% timeit, mais ici nous sommes préoccupés par la différence de plusieurs à plusieurs dizaines de fois, donc je suis préoccupé par la différence de plusieurs pour cent. Non. [^ 3]: le processeur utilise Intel Celeron.