Trucs et astuces pour afficher les versions numpy

numpy est une bibliothèque mathématique très couramment utilisée en Python. Elle est largement utilisée dans le domaine du calcul scientifique et prend en charge un grand nombre de calculs numériques, d'algèbre linéaire, de génération de nombres aléatoires, de transformée de Fourier et d'autres fonctions. Lors de l'utilisation de numpy pour des calculs mathématiques, il est souvent nécessaire de déterminer la version de numpy et ses caractéristiques, et d'effectuer différentes sélections d'optimisation et d'algorithme pour différentes versions de numpy. Cet article présentera des trucs et astuces pour vérifier la version de numpy et comment mieux utiliser numpy en détectant les informations de version de numpy.

1. Comment vérifier la version de numpy

Il existe de nombreuses fonctions et attributs intégrés dans numpy, qui peuvent être utilisés pour obtenir des informations sur la version de numpy. Ce qui suit présentera plusieurs méthodes couramment utilisées pour vérifier la version numpy.

1. Utilisez l'attribut numpy.version

Il existe un attribut de version dans numpy, qui peut être utilisé pour obtenir des informations détaillées sur la version actuelle de numpy, y compris le numéro de version, la valeur de hachage de validation Git, les informations sur le compilateur, etc. L'exemple de code est le suivant :

import numpy as np
print(np.version.version)

Le résultat de sortie est le suivant :

1.20.1

2. Utilisez l'attribut numpy.__version__

En plus de l'attribut version, numpy fournit également un attribut __version__, dont la valeur par défaut est la valeur actuelle. version numpy Représentation sous forme de chaîne. Cet attribut est également l'un des moyens courants de déterminer les informations de version dans numpy. L'exemple de code est le suivant :

import numpy as np
print(np.__version__)

Le résultat de sortie est le même que l'exemple précédent :

1.20.1

3. Utilisez la fonction numpy.show_config

Si vous avez besoin d'afficher des informations plus détaillées sur numpy Pour la compilation et la construction, vous pouvez utiliser la fonction numpy.show_config. Cette fonction affichera les différents compilateurs, éditeurs de liens et bibliothèques utilisés par numpy lors de la construction, y compris le compilateur C++, la bibliothèque CBLAS, la bibliothèque LAPACK, etc. Son exemple de code est le suivant :

import numpy as np
np.show_config()

Le résultat de sortie est le suivant :

blas_mkl_info:
    libraries = ['mkl_rt']
    library_dirs = ['C:/Program Files (x86)/Intel/oneAPI/mkl/2021.1.1/lib/intel64']
    define_macros = [('SCIPY_MKL_H', None), ('HAVE_CBLAS', None)]
    include_dirs = ['C:/Program Files (x86)/Intel/oneAPI/mkl/2021.1.1/include']

blis_info:
    NOT AVAILABLE

openblas_info:
    NOT AVAILABLE

lapack_mkl_info:
    libraries = ['mkl_rt']
    library_dirs = ['C:/Program Files (x86)/Intel/oneAPI/mkl/2021.1.1/lib/intel64']
    define_macros = [('SCIPY_MKL_H', None), ('HAVE_CBLAS', None)]
    include_dirs = ['C:/Program Files (x86)/Intel/oneAPI/mkl/2021.1.1/include']

lapack_opt_info:
    libraries = ['mkl_rt']
    library_dirs = ['C:/Program Files (x86)/Intel/oneAPI/mkl/2021.1.1/lib/intel64']
    define_macros = [('SCIPY_MKL_H', None), ('HAVE_CBLAS', None)]
    include_dirs = ['C:/Program Files (x86)/Intel/oneAPI/mkl/2021.1.1/include']

lapack_info:
    libraries = ['mkl_rt']
    library_dirs = ['C:/Program Files (x86)/Intel/oneAPI/mkl/2021.1.1/lib/intel64']
    define_macros = [('SCIPY_MKL_H', None), ('HAVE_CBLAS', None)]
    include_dirs = ['C:/Program Files (x86)/Intel/oneAPI/mkl/2021.1.1/include']

mkl_info:
    libraries = ['mkl_rt']
    library_dirs = ['C:/Program Files (x86)/Intel/oneAPI/mkl/2021.1.1/lib/intel64']
    define_macros = [('SCIPY_MKL_H', None), ('HAVE_CBLAS', None)]
    include_dirs = ['C:/Program Files (x86)/Intel/oneAPI/mkl/2021.1.1/include']

blas_opt_info:
    libraries = ['mkl_rt']
    library_dirs = ['C:/Program Files (x86)/Intel/oneAPI/mkl/2021.1.1/lib/intel64']
    define_macros = [('SCIPY_MKL_H', None), ('HAVE_CBLAS', None)]
    include_dirs = ['C:/Program Files (x86)/Intel/oneAPI/mkl/2021.1.1/include']
...（输出结果省略）

Grâce aux trois méthodes ci-dessus, vous pouvez vérifier la version spécifique et les informations de compilation de numpy, déterminer la version de numpy correspondant aux différents projets et sélectionner Les algorithmes et méthodes numpy appropriés sont d'une grande importance.

2. Application des informations sur la version numpy

Après avoir clarifié les informations sur la version numpy, lorsque vous utilisez numpy, vous pouvez sélectionner les algorithmes et les méthodes appropriés pour différentes versions afin d'obtenir le meilleur effet d'optimisation et d'amélioration des performances. Par exemple, dans les versions numpy 1.20 et supérieures, des fonctions de niveau supérieur peuvent être utilisées pour gérer automatiquement les valeurs NaN afin d'éviter les exceptions lorsque le programme est en cours d'exécution. En même temps, certains algorithmes d'optimisation efficaces sont utilisés et les performances sont également améliorées. été grandement améliorée. Dans les versions inférieures de numpy, vous devrez peut-être gérer manuellement les valeurs NaN et les exceptions, et utiliser des algorithmes simples pour améliorer la stabilité et les performances du programme.

Ce qui suit est un exemple simple montrant comment utiliser les informations de version numpy pour sélectionner l'algorithme optimal.

Supposons que nous devions calculer le produit d'une matrice 10 000 × 10 000. Nous pouvons calculer cette tâche de deux manières. Une méthode consiste à utiliser la fonction numpy.dot(), qui calcule le produit scalaire de deux matrices en appelant le sous-programme dgemm dans la bibliothèque BLAS. Elle prend également en charge les calculs multithread et de vectorisation, et la vitesse de calcul est très rapide. Une autre méthode consiste à utiliser la fonction numpy.multiply() pour multiplier les deux matrices élément par élément, puis additionner les résultats pour obtenir le produit scalaire. La mise en œuvre de cette méthode est relativement simple, mais les performances sont médiocres.

Le code suivant compare le temps de calcul des deux algorithmes :

import numpy as np
import time

A = np.random.rand(10000, 10000)
B = np.random.rand(10000, 10000)

# 方法1：使用numpy.dot函数
start_time = time.time()
C = np.dot(A, B)
end_time = time.time()
print("方法1计算时间：", end_time - start_time)

# 方法2：使用numpy.multiply函数
start_time = time.time()
C = np.multiply(A, B).sum()
end_time = time.time()
print("方法2计算时间：", end_time - start_time)

Les résultats de sortie sont les suivants :

方法1计算时间： 3.94059681892395
方法2计算时间： 9.166156768798828

Comme vous pouvez le voir, la vitesse de calcul avec numpy.dot() est presque 2,5 fois supérieure à celle de numpy. multiplier(), on peut conclure que lorsque la version numpy est compatible, l'algorithme numpy.dot() doit être préféré pour obtenir de meilleures performances et un temps de calcul plus court.

Conclusion

Cet article présente plusieurs méthodes pour afficher les versions de numpy, et présente également l'application de différents algorithmes et méthodes pour différentes versions de numpy. Dans le développement réel de numpy, il est très nécessaire de comprendre les caractéristiques et les performances de la version numpy et de maîtriser les compétences de visualisation de la version numpy, ce qui peut jeter une base solide pour une meilleure application et un meilleur développement de numpy.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!