Python mais rápidas com Numba

Uma parte essencial da modelagem de simulação é o tempo de execução da simulação. Grandes modelos de simulação de eventos discretos e até mesmo modelos de simulação baseados em agentes de tamanho médio consomem recursos computacionais e podem ter um tempo de execução muito longo. Isso é especialmente verdadeiro se o código-fonte estiver totalmente escrito em Python. Portanto, realizei alguns testes com Numba em Python. Partilho aqui os meus resultados. Primeiro eu executo um teste simples em uma função de teste em Python. Depois disso, resumi minhas melhorias de desempenho de tempo de execução por ter aplicado o Numba à minha estrutura de modelagem baseada em agente em Python.

Instalando o Numba em Python

O Numba pode ser instalado usando o comando pip install. Basta digitar o seguinte no seu terminal:

pip install numba

Para listas, recomendo que você use numpy (ou seja , matrizes numpy ), pois isso permitirá que você evite a lista padrão do Python . Se ainda não estiver instalado, você pode instalar o numy da mesma maneira:

pip install numpy

Agora você pode importar numpy e numba e usar numba para tornar seu código mais rápido. Para isso você pode usar o decorador @njit .

Testando a melhoria de desempenho do Numba em Python

Hora de dar uma olhada em um teste simples de melhoria de tempo de execução em Python. O código abaixo implementa o Numba para ter um programa Python mais rápido.

import numpy as np

from numba import jit

import random
import time

def rand_events(n: int) -> np.ndarray:
    ls = np.zeros(n)
    for i in range(n):
        x = random.random()
        while True:
            y = random.random()
            if x < y: 
                ls[i] = y
                break
    return ls

""" RUNTIME TEST WITHOUT NUMBA  -------------------------- """

_start_time = time.time()
vals = rand_events(10000000)
_end_time = time.time()

print(str(_end_time - _start_time))

""" RUNTIME TEST WITH NUMBA ------------------------------ """

_start_time = time.time()
jit_rand_events = jit(nopython=True)(rand_events)
vals = jit_rand_events(10000000)
_end_time = time.time()

print(str(_end_time-_start_time))

_start_time = time.time()
vals = jit_rand_events(10000000)
_end_time = time.time()

print(str(_end_time-_start_time))

No código acima, chamar jit(nopython=True) é igual ao uso do declarador @njit . Ao executar o código acima, a saída no terminal será algo semelhante ao seguinte (depende da máquina e do resultado da geração de números aleatórios)

9.1829195022583
1.2913379669189453
0,8751001358032227

Isso significa que levou 9,18 segundos para chamar a função rand_events() com n = 10.000.000. Depois de aplicar o declarador @njit e executar a função novamente, leva apenas 1,29 segundos (incluindo “jitting” da função). Sem a chamada do declarador @njit , levaria 0,87 segundos para chamar a versão “jitted” de rand_events(). Essa é uma melhoria significativa no tempo de execução.

Aplicando Numba para simulações Python mais rápidas

O Numba pode tornar as estruturas de simulação mais rápidas. Mas somente se as principais partes da estrutura forem orientadas numericamente. Além disso, o framework deve integrar numpy , pois numba entende o numpy muito bem. Em uma estrutura fortemente orientada a objetos, isso pode ser um desafio. Mas se você conseguir transformar partes computacionalmente intensivas do código em código numérico, o numba pode resultar em melhorias significativas no tempo de execução do código Python.