Tipps und Tricks zum Anzeigen von Numpy-Versionen

numpy ist eine sehr häufig verwendete Mathematikbibliothek in Python. Sie wird häufig im Bereich des wissenschaftlichen Rechnens verwendet und unterstützt eine große Anzahl numerischer Berechnungen, lineare Algebra, Zufallszahlengenerierung, Fourier-Transformation und andere Funktionen. Bei der Verwendung von Numpy für mathematische Berechnungen ist es häufig erforderlich, die Numpy-Version und ihre Eigenschaften zu bestimmen und unterschiedliche Optimierungs- und Algorithmusauswahlen für verschiedene Versionen von Numpy zu treffen. In diesem Artikel werden Tipps und Tricks zum Überprüfen der Numpy-Version vorgestellt und erläutert, wie Sie Numpy durch Erkennen von Numpy-Versionsinformationen besser nutzen können.

1. So überprüfen Sie die Numpy-Version

In Numpy sind viele Funktionen und Attribute integriert, mit denen Sie Informationen zur Numpy-Version erhalten können. Im Folgenden werden einige häufig verwendete Methoden zum Überprüfen der Numpy-Version vorgestellt.

1. Verwenden Sie das numpy.version-Attribut

Es gibt ein Versionsattribut in numpy, mit dem detaillierte Informationen zur aktuellen numpy-Version abgerufen werden können, einschließlich Versionsnummer, Git-Commit-Hashwert, Compilerinformationen usw. Das Codebeispiel lautet wie folgt:

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

Das Ausgabeergebnis lautet wie folgt:

1.20.1

2. Verwenden Sie das Attribut numpy.__version__

Zusätzlich zum Versionsattribut stellt numpy auch ein Attribut __version__ bereit, dessen Standardwert der aktuelle Wert ist Numpy-Version String-Darstellung. Dieses Attribut ist auch eine der häufigsten Methoden zum Ermitteln von Versionsinformationen in Numpy. Das Codebeispiel lautet wie folgt:

import numpy as np
print(np.__version__)

Das Ausgabeergebnis ist das gleiche wie im vorherigen Beispiel:

1.20.1

3. Verwenden Sie die Funktion numpy.show_config

Wenn Sie detailliertere numpy-Informationen zur Kompilierung und Erstellung benötigen, können Sie die Funktion numpy.show_config verwenden. Diese Funktion zeigt die verschiedenen Compiler, Linker und Bibliotheken an, die Numpy beim Erstellen verwendet, einschließlich des C++-Compilers, der CBLAS-Bibliothek, der LAPACK-Bibliothek usw. Das Codebeispiel lautet wie folgt:

import numpy as np
np.show_config()

Das Ausgabeergebnis lautet wie folgt:

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']
...（输出结果省略）

Mit den oben genannten drei Methoden können Sie die spezifische Version und die Kompilierungsinformationen von Numpy überprüfen, die Numpy-Version ermitteln, die verschiedenen Projekten entspricht, und auswählen Geeignete Numpy-Algorithmen und -Methoden sind von großer Bedeutung.

2. Anwendung von Numpy-Versionsinformationen

Nachdem Sie die Numpy-Versionsinformationen geklärt haben, können Sie bei der Verwendung von Numpy geeignete Algorithmen und Methoden für verschiedene Versionen auswählen, um den besten Optimierungseffekt und die beste Leistungsverbesserung zu erzielen. Beispielsweise können in Numpy-Versionen 1.20 und höher Funktionen auf höherer Ebene verwendet werden, um NaN-Werte automatisch zu verarbeiten und Ausnahmen zu vermeiden, wenn das Programm ausgeführt wird. Gleichzeitig werden einige effiziente Optimierungsalgorithmen verwendet, und die Leistung hat sich ebenfalls verbessert stark verbessert worden. In niedrigeren Versionen von Numpy müssen Sie möglicherweise NaN-Werte und Ausnahmen manuell verarbeiten und einige einfache Algorithmen verwenden, um die Stabilität und Leistung des Programms zu verbessern.

Das Folgende ist ein einfaches Beispiel, das zeigt, wie Numpy-Versionsinformationen verwendet werden, um den optimalen Algorithmus auszuwählen.

Angenommen, wir müssen das Produkt einer 10000×10000-Matrix berechnen. Wir können diese Aufgabe auf zwei Arten berechnen. Eine Methode besteht darin, die Funktion numpy.dot() zu verwenden, die das Skalarprodukt zweier Matrizen durch Aufrufen der Unterroutine dgemm in der BLAS-Bibliothek berechnet. Sie unterstützt auch Multithreading- und Vektorisierungsberechnungen und die Berechnungsgeschwindigkeit ist sehr hoch. Eine andere Methode besteht darin, die Funktion numpy.multiply() zu verwenden, um die beiden Matrizen Element für Element zu multiplizieren und dann die Ergebnisse zu summieren, um das Skalarprodukt zu erhalten. Die Implementierung dieser Methode ist relativ einfach, aber die Leistung ist schlecht.

Der folgende Code vergleicht die Berechnungszeit der beiden Algorithmen:

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)

Die Ausgabeergebnisse lauten wie folgt:

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

Wie Sie sehen können, ist die Berechnungsgeschwindigkeit mit numpy.dot() fast 2,5-mal so hoch wie die mit numpy. multiply(). Daraus kann geschlossen werden, dass bei Kompatibilität der Numpy-Version der Algorithmus Numpy.dot() bevorzugt werden sollte, um eine bessere Leistung und eine kürzere Berechnungszeit zu erzielen.

Fazit

In diesem Artikel werden verschiedene Methoden zum Anzeigen von Numpy-Versionen sowie die Anwendung verschiedener Algorithmen und Methoden für verschiedene Numpy-Versionen vorgestellt. Bei der eigentlichen Numpy-Entwicklung ist es sehr wichtig, die Eigenschaften und die Leistung der Numpy-Version zu verstehen und die Fähigkeiten zum Anzeigen der Numpy-Version zu beherrschen, was eine solide Grundlage für eine bessere Numpy-Anwendung und -Entwicklung legen kann.

Das obige ist der detaillierte Inhalt vonTipps und Tricks zum Anzeigen von Numpy-Versionen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!