Calculer le noyau gaussien à une vitesse explosive même avec python

introduction

Écrivez le code pour calculer le noyau gaussien qui doit être calculé dans le processus gaussien, etc. à la vitesse de Bakou.

code

Écrit en Numba pour accélérer. C'est dommage que le code lui-même devienne un peu redondant en raison des restrictions imposées par Numba, mais l'effet d'accélération est énorme. Il y avait des restrictions telles que décrire en multipliant le carré afin d'accélérer avec Numba, et ne pas utiliser la fonction numpy dans la fonction définie par moi-même.

from numba import jit, void, f8
import numpy as np
import time


@jit(void(f8[:, :], f8[:, :]))
def gauss_gram_mat(x, K):
  n_points = len(x)
  n_dim = len(x[0])
  b = 0
  sgm = 0.2

  for j in range(n_points):
    for i in range(n_points):
      for k in range(n_dim):
        b = (x[i][k] - x[j][k]) / sgm
        K[i][j] += b * b


def gauss_gram_mat_normal(x, K):
  n_points = len(x)
  n_dim = len(x[0])
  b = 0
  sgm = 0.2

  for j in range(n_points):
    for i in range(n_points):
      for k in range(n_dim):
        b = (x[i][k] - x[j][k]) / sgm
        K[i][j] += b * b


n_dim = 10
n_points = 2000
x = np.random.rand(n_points, n_dim)
K = np.zeros((n_points, n_points))

start = time.time()

gauss_gram_mat(x, K)
K = np.exp(- K / 2)

print("Namba: {}".format(time.time() - start))

start = time.time()

gauss_gram_mat_normal(x, K)
K = np.exp(- K / 2)

print("Normal: {}".format(time.time() - start))

Vérification

Bien qu'il n'y ait qu'un seul motif, nous avons comparé la vitesse de calcul avec le code normal et le code de Numba en nombre de points et en nombre de dimensions mentionnés ci-dessus.

Apparemment, c'est près de 500 fois plus rapide. (Si vous utilisez la notation d'inclusion, etc., ce sera plus rapide sans Numba, mais c'est impossible jusqu'à présent.)

Numba: 0.11480522155761719
Normal: 50.70034885406494

Supplément

Je l'ai également vérifié avec Numpy.

import numpy as np
import time

n_dim = 10
n_points = 2000
sgm = 0.2
x = np.random.rand(n_points, n_dim)

now = time.time()
K = np.exp(- 0.5 * (((x - x[:, None]) / sgm) ** 2).sum(axis=2))
print("Numpy: {}".format(time.time() - start))

Le résultat est que Numba est plus rapide que Numpy.

Numpy: 0.3936312198638916