Quelle est la différence entre numpy.la fft et scipy.fftpack?

Est le plus tard juste un synonyme de l'ancien, ou sont-ils deux implémentations différentes de la FFT? Lequel est le mieux?

  • Question intéressante. Les documents ne sont pas en dire beaucoup. Je viens de trouver cette citation dans le contexte des explications sur l'importation des stratégies: "Laisse envisager le cas où vous (pour quelque raison que ce soit) souhaitez comparer numpy et scipy la fft fonctions." (voir la fin de ce site). Ainsi, " ( ... ) pour quelque raison que ce soit ..."
InformationsquelleAutor Charles Brunet | 2011-06-15
  1. 34

    SciPy ne plus:

    En outre, SciPy exportations de certaines des fonctions de NumPy par le biais de sa propre interface, par exemple, si vous exécutez scipy.fftpack.helper.fftfreq et numpy.fft.helper.fftfreq vous êtes fait exécuter le même code.

    Cependant, SciPy a ses propres implémentations de beaucoup de fonctionnalités. La source a des tests de performances que de comparer l'original NumPy et de nouvelles SciPy versions. Mon archaïque ordinateur portable montre quelque chose comme ceci:

                     Fast Fourier Transform
=================================================
      |    real input     |   complex input    
-------------------------------------------------
 size |  scipy  |  numpy  |  scipy  |  numpy 
-------------------------------------------------
  100 |    0.07 |    0.06 |    0.06 |    0.07  (secs for 7000 calls)
 1000 |    0.06 |    0.09 |    0.09 |    0.09  (secs for 2000 calls)
  256 |    0.11 |    0.11 |    0.12 |    0.11  (secs for 10000 calls)
  512 |    0.16 |    0.21 |    0.20 |    0.21  (secs for 10000 calls)
 1024 |    0.03 |    0.04 |    0.04 |    0.04  (secs for 1000 calls)
 2048 |    0.05 |    0.09 |    0.08 |    0.08  (secs for 1000 calls)
 4096 |    0.05 |    0.08 |    0.07 |    0.09  (secs for 500 calls)
 8192 |    0.10 |    0.20 |    0.19 |    0.21  (secs for 500 calls)

    Il semble que SciPy est significativement plus rapide que la matrice augmente en taille, mais ce sont juste des exemples inventées et il serait intéressant d'expérimenter avec les deux pour votre projet particulier.

    Il vaut la peine de regarder le code source http://www.scipy.org/Download#head-312ad78cdf85a9ca6fa17a266752069d23f785d1 . Oui, ces .f fichiers sont vraiment Fortran! 😀

    • Aucune idée de pourquoi ils ont choisi de maintenir deux implémentations différentes?
    • scipy la fft vérifie si le type de données est réel, et utilise deux fois efficace rfft si. numpy la fft n'a pas.
    • scipy renvoie les données dans un vraiment inutile format - alternance de parties réelles et imaginaires après le premier élément. Une fois que vous avez split en dehors de cela, plâtre pour complexes, faites votre calcul, puis jeté tous de retour, vous perdez beaucoup (mais pas tous) de la vitesse. En gros, c'est pas une comparaison équitable - numpy est temps d'inclure la sortie est utilisable, non seulement fait la fft.
    • Aussi, découvrez hgomersall.github.io/pyFFTW/pyfftw/interfaces/interfaces.html C'est une belle enveloppe pour fftw qui fonctionne comme une baisse-dans le remplacement pour numpy.fft ou scipy.fftpack.
    • Vous pouvez utiliser dtype astuces pour view la "alternance" tableau en tableau de nombres complexes (sauf pour le premier élément, je crois) @Corone
    • pouvez-vous développer ce que?

    InformationsquelleAutor jond3k
  2. 16

    J'ai trouvé que numpy la fft 2D a été nettement plus rapide que scipy, mais FFTW a été plus rapide que les deux (à l'aide de la PyFFTW liaisons). Les tests de performances sont ici:
    code.google.com/p/agpy/source/browse/trunk/tests/test_ffts.py

    Et les résultats (pour n x n tableaux):

               n                sp               np             fftw
           8:         0.010189         0.005077         0.028378
          16:         0.010795         0.008069         0.028716
          32:         0.014351         0.008566         0.031076
          64:         0.028796         0.019308         0.036931
         128:         0.093085         0.074986         0.088365
         256:         0.459137         0.317680         0.170934
         512:         2.652487         1.811646         0.571402
        1024:        10.722885         7.796856         3.509452
    • Au passage, je pense que la vitesse dépend fortement de ce soutien paquets que vous avez compilé pour numpy/scipy, par exemple, si vous avez compilé BLAS/LAPACK et avec le compilateur et les options du compilateur. Mais je ne sais pas qui compilateurs/flags sont plus rapides =(
    InformationsquelleAutor keflavich
  3. 3

    Regardant le repository github pour chaque, scipy n'est pas seulement l'importation de numpy de la version et de le renommer (bien qu'il ne emprunter certaines fonctionnalités). Vous aurez à creuser dans le code si vous voulez discerner la différence dans les implémentations car la documentation n'est pas une comparaison directe.

    https://github.com/numpy/numpy/tree/master/numpy/fft

    https://github.com/scipy/scipy/tree/master/scipy/fftpack

    • Numpy C du portage de la FFTPACK Fortran programmes, tandis que Scipy utilise l'original Fortran version.
    InformationsquelleAutor JoshAdel