Comment utiliser numba.jit avec les méthodes

Question

En utilisant numba.jit en python.

Je peux convertir des fonctions normales de type JIT et exécutez:

from numba import jit 

def sum(a, b): 
    return a+b 

func = jit(sum) 
print(func(1, 2)) 

Comment faire des méthodes? Quelque chose comme ça (ça ne marche pas et je sais pourquoi).

from numba import jit 

class some_class: 
    def __init__(self, something = 0): 
     self.number = something 
    def get_num(self): 
     return self.number 

my_object = some_class(5) 
func = jit(my_object.get_num) 
print(my_object.func()) 

P.S. J'ai aussi essayé des décorateurs, ça marche mais je ne peux pas l'utiliser pour des classes importées (celles que je ne définis pas moi-même), donc je regarde ça.

Answer 1

Vous ne pouvez pas Jit lié méthodes, mais vous pouvez JIT méthodes non liées (mais seulement en mode objet):

from numba import jit 

class some_class: 
    def __init__(self, something = 0): 
     self.number = something 
    def get_num(self): 
     return self.number 
    func = jit(get_num) 

my_object = some_class(5) 
print(my_object.func()) 
# 5 

Notez que cela ne pas utiliser le mode nopython, vous ne devriez pas attendre toute accélération raisonnable. Vous pourriez faire la classe elle-même un jitclass (cela signifie que toutes les méthodes sont nopython-jitted automatiquement) mais il faut que vous tapez les attributs:

import numba as nb 

spec = [ 
    ('number', nb.int64), 
] 

@nb.jitclass(spec) 
class some_class: 
    def __init__(self, something): 
     self.number = something 
    def get_num(self): 
     return self.number 

my_object = some_class(5) 
print(my_object.get_num()) 

Mais pour les classes plus compliquées, il deviendra très difficile (voire impossible) à utiliser jitclass. Dans mon expérience, la meilleure façon est d'appeler simplement les fonctions jitted à partir de la méthode:

from numba import njit # like jit but enforces nopython-mode! 

@njit 
def my_func(val): 
    return val # this example is a bit stupid, I hope your real code does more! 

class some_class: 
    def __init__(self, something = 0): 
     self.number = something 
    def get_num(self): 
     return my_func(self.number) 

my_object = some_class(5) 
print(my_object.get_num()) 

Cela dépend de la complexité de votre classe et/ou votre méthode est l'approche à utiliser. Dans votre cas, je n'utiliserais pas du tout le numba, car il n'y a tout simplement pas assez de calcul coûteux pour compenser les frais généraux de numba et de jit. Si c'était un peu plus compliqué j'utiliserais jitclass et si c'était beaucoup plus compliqué j'utiliserais la fonction jitted qui est appelée depuis l'approche de la fonction. Personnellement, je n'utiliserais jamais jit pour une méthode car cela impliquait implicitement le mode objet, donc il est probable que la fonction jitted soit plus lente que la fonction unjitted.

Soit dit en passant: En Python vous utilisez généralement property au lieu de get_* ou set_* fonctions ...