Utiliser Cython avec Jupyter Notebook

C'est une note parce que j'ai trouvé que je pouvais essayer Cython avec Jupyter Notebook (iPython Notebook) plus facilement que prévu. Cython accélère le traitement en compilant avant l'exécution et en tapant statiquement.

(Le fichier .ipynb de cet article a été téléchargé sur Github ici.)

</ i> Environnement

L'environnement que j'ai essayé est le suivant. J'essaye sur Mac et Anaconda. Si Anaconda est installé, aucune préparation spéciale n'est requise.

Python 3.5.1 |Anaconda custom (x86_64)| (default, Jun 15 2016, 16:14:02) 
[GCC 4.2.1 Compatible Apple LLVM 4.2 (clang-425.0.28)] on darwin 

IPython 5.0.0 

</ i> Essayons

Exécuter la commande magique pour la compilation Cython

#Autoriser la compilation des fichiers cython sur Jupyter Notebook
%load_ext Cython

Déclarer des fonctions Cython

Écrivez le code cython avec «%% cython» au début. L'exemple est utilisé dans Bases du didacticiel Cython.

# ↓ -n <nom de fichier>En ajoutant, il sera plus facile de vérifier le fichier ultérieurement.
%%cython -n test_cython_code
def fib(int n):
    cdef int i
    cdef double a=0.0, b=1.0

    for i in range(n):
        a, b = a+b, a
    return a

def primes(int kmax):
    cdef int n, k, i
    cdef int p[1000]
    result = []

    if kmax > 1000:
        kmax = 1000

    k = 0
    n = 2
    while k < kmax:
        i = 0
        while i < k and n % p[i] != 0:
            i += 1

        if i == k:
            p[k] = n
            k += 1
            result.append(n)
        n += 1
    return result

Essaie

print(fib(90))
print(primes(20))

out


2.880067194370816e+18
[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71]

l'a fait!

</ i> Comparaison de vitesse avec Python brut

Écrivons le même processus en Python brut et comparons les temps d'exécution.

import numpy as np
#Fonction Python pour la comparaison des performances
def pyfib(n):
    a, b = 0.0, 1.0
    for i in range(n):
        a, b = a+b, a
    return a

def pyprimes(kmax):
    p = np.zeros(1000)
    result = []

    #Le nombre maximum est de 1000
    if kmax > 1000:
        kmax = 1000

    k = 0
    n = 2
    while k < kmax:
        i = 0
        while i < k and n % p[i] != 0:
            i += 1

        if i == k:
            p[k] = n
            k += 1
            result.append(n)
        n += 1
    return result

Numéro de Fibonacci

#Générer et mesurer à plusieurs reprises le 1000e nombre de Fibonacci
%timeit fib(1000)
%timeit pyfib(1000)

cython est environ 50 fois plus rapide!

out


1000000 loops, best of 3: 786 ns per loop
10000 loops, best of 3: 42.5 µs per loop

Extraire un nombre premier

%timeit primes(1000)
%timeit pyprimes(1000)

out


100 loops, best of 3: 2.12 ms per loop
1 loop, best of 3: 218 ms per loop

Ce calcul est environ 100 fois plus rapide!

</ i> Essayez de l'utiliser pour Pandas Apply

1000 entiers

df = pd.DataFrame(np.arange(1, 10**4), columns=['num'] )

Vous pouvez l'utiliser simplement en spécifiant la fonction dans la fonction apply: blush:

%timeit df['fib'] = df.num.apply(fib)
%timeit df['pyfib'] = df.num.apply(pyfib)

out


10 loops, best of 3: 39.2 ms per loop
1 loop, best of 3: 2.02 s per loop
print(df.head())

out


   num  fib  pyfib
0    1  1.0    1.0
1    2  1.0    1.0
2    3  2.0    2.0
3    4  3.0    3.0
4    5  5.0    5.0

Le fichier cython compilé est stocké dans ~ / .ipython / cython. Si un nom de fichier a été spécifié avec %% cython -n <nom de fichier> au moment de la compilation, il est stocké ici avec ce nom de fichier.

</ i> Gérer ndarray

#Créer des données
rd.seed(71)
n_data = 10**5
X = pd.DataFrame(rd.normal(size=3*n_data).reshape((n_data,3)), columns=["a", "b", "c"])
print(X.shape)
print(X.head())

out


(100000, 3)
          a         b         c
0 -0.430603 -1.193928 -0.444299
1  0.489412 -0.451557  0.585696
2  1.177320 -0.965009  0.218278
3 -0.866144 -0.323006  1.412919
4 -0.712651 -1.362191 -1.705966

Ecrire du code Cython qui prend ndarray comme argument

%%cython -n sample_calc 
import numpy as np
cimport numpy as np

cpdef np.ndarray[double] sample_calc(np.ndarray col_a, np.ndarray col_b, np.ndarray col_c):
    #Vérification de type pour chaque colonne
    assert (col_a.dtype == np.float and col_b.dtype == np.float and col_c.dtype == np.float)
    
    #Vérifiez que la taille de chaque colonne est la même
    cdef Py_ssize_t n = len(col_c)
    assert (len(col_a) == len(col_b) == n)
    cdef np.ndarray[double] res = np.empty(n)
    
    # (a-b)/Faites le calcul c
    for i in range(n):
        res[i] = (col_a[i] - col_b[i])/col_c[i]
    return res

Appel du côté Python

sample_calc(X.a.values, X.b.values, X.c.values)

out


array([-1.71804336,  1.60658332,  9.81468496, ..., -0.44683095,
        0.46970409, -0.28352272])
#En comparaison
def pysample_calc(col_a, col_b, col_c):
    #Vérification de type pour chaque colonne
    assert (col_a.dtype == np.float and col_b.dtype == np.float and col_c.dtype == np.float)
    
    #Vérifiez que la taille de chaque colonne est la même
    n = len(col_c)
    assert (len(col_a) == len(col_b) == n)
    res = np.empty(n)
    
    # (a-b)/Faites le calcul c
    for i in range(n):
        res[i] = (col_a[i] - col_b[i])/col_c[i]
    return res
%timeit sample_calc(X.a.values, X.b.values, X.c.values)
%timeit pysample_calc(X.a.values, X.b.values, X.c.values)

out


100 loops, best of 3: 16.7 ms per loop
10 loops, best of 3: 37.2 ms per loop

</ i> Calculer le rapport de circonférence par la méthode de Monte Carlo

#Génération de données
rd.seed(71)
n_data = 10**7
X2 = rd.random(size=(n_data,2)).astype(np.float)
X2.dtype

Définition de la fonction Cython

%%cython -n calc_pi
import numpy as np
cimport numpy as np

cpdef np.ndarray[long]  calc_pi(np.ndarray[double, ndim=2] data):
    cdef Py_ssize_t n = len(data)
    cdef np.ndarray[long] res = np.empty(n, dtype=np.int)
    
    for i in range(n):
        res[i] = 1 if (data[i,0]**2 + data[i,1]**2) < 1 else 0
    return res

Fonction Python pour comparaison

#Fonction Python pour comparaison
def pycalc_pi(data):
    n = len(data)
    res = [1 if (data[i,0]**2 + data[i,1]**2) < 1 else 0 for i in range(n)]
    return res

Je vais le mesurer.

%time calc_pi(X2)
%time pycalc_pi(X2)

out


CPU times: user 25.2 ms, sys: 5.98 ms, total: 31.2 ms
Wall time: 31.1 ms
CPU times: user 7.7 s, sys: 46.1 ms, total: 7.75 s
Wall time: 7.75 s

Cython est beaucoup plus rapide!

#Vérifiez si les résultats sont les mêmes
np.all(res == respy)

correct!

out


True
#Calcul du rapport de circonférence
np.sum(res)/n_data*4

out


3.1413555999999998

Essayez de dessiner.

import matplotlib.pyplot as plt
%matplotlib inline
import seaborn as sns
from matplotlib.colors import LinearSegmentedColormap

sns.set(style="darkgrid", palette="muted", color_codes=True)
#dessiner
n_plot = 10**4  #Nombre de points à dessiner
plt.figure(figsize=(8,8))
plt.scatter(X2[:n_plot,0], X2[:n_plot,1], c=res[:n_plot], s=10)

plot.png

Vous jugez correctement l'intérieur et l'extérieur du cercle.

référence

Principes de base du didacticiel Cython http://omake.accense.com/static/doc-ja/cython/src/userguide/tutorial.html

O'Reilly "Cython" https://www.oreilly.co.jp/books/9784873117270/

pandas 0.18.1 documentation Enhancing Performance http://pandas.pydata.org/pandas-docs/stable/enhancingperf.html

Recommended Posts