Vitesse de lecture Python netCDF4 et imbrication d'instructions for

Si vous essayez de tracer des données météorologiques sur différents plans de pression sur une longue période, l'imbrication par les déclarations for et la lecture des fichiers netCDF augmenteront naturellement.

Par conséquent, j'ai étudié comment le temps nécessaire pour obtenir un tableau de données change en modifiant la structure d'imbrication de l'instruction for.

Code de vérification 1

Pour le code de vérification, je me suis référé à ici. Les données ont été obtenues auprès du NCAR's RDA. Les données sont un géopotentiel, un tableau à quatre dimensions de [temps, plan de pression, latitude, longitude]. Le temps est de 24 heures de 0 à 23 et le niveau de pression est de 37.

func_1 lit les données une fois et stocke le tableau tridimensionnel dans un fichier. Après cela, le géopotentiel à chaque plan de pression est remplacé par b. func_2 lit les données pour chaque plan de pression et obtient à chaque fois un tableau bidimensionnel.

check1.py

import timeit
from netCDF4 import Dataset

def func_1():
    nc = Dataset('../data/era5/Z_2020070100_2020070123.nc', 'r')
    a = nc.variables['Z'][0, :]
    for i in range(len(a)):
        b = a[i, :]
    return 0

def func_2():
    nc = Dataset('../data/era5/Z_2020070100_2020070123.nc', 'r')
    lev = nc.variables['level'][:]
    for i in range(len(lev)):
        b = nc.variables['Z'][0, i, :]
    return 0

loop = 20

result_1 = timeit.timeit(lambda: func_1(), number=loop)
result_2 = timeit.timeit(lambda: func_2(), number=loop)

print('1: ', result_1 / loop)
print('2: ', result_2 / loop)

Le résultat est

1:  0.009774951753206551
2:  0.018051519710570573

C'est devenu comme. Il y a une double différence de vitesse. À partir de là, il a été constaté que la vitesse de lecture du tableau tridimensionnel est supérieure à la vitesse de lecture du tableau tridimensionnel à un instant et à la vitesse de lecture du tableau bidimensionnel à chaque fois.

Code de vérification 2

Étant donné que les données que vous souhaitez gérer sont un tableau à 4 dimensions, vérifiez également le cas d'un tableau à 4 dimensions. Comme pour le code de vérification 1, func_1 et func_2 sont lus une fois par func_1 et lus par func_2 à chaque fois.

check1.py

import timeit
from netCDF4 import Dataset

def func_1():
    nc = Dataset('../data/era5/Z_2020070100_2020070123.nc', 'r')
    a = nc.variables['Z'][0, :]
    for i in range(len(a)):
        b = a[i, :]
    return 0

def func_2():
    nc = Dataset('../data/era5/Z_2020070100_2020070123.nc', 'r')
    lev = nc.variables['level'][:]
    for i in range(len(lev)):
        b = nc.variables['Z'][0, i, :]
    return 0

loop = 10

result_1 = timeit.timeit(lambda: func_1(), number=loop)
result_2 = timeit.timeit(lambda: func_2(), number=loop)

print('1: ', result_1 / loop)
print('2: ', result_2 / loop)

Ensuite, le résultat était le suivant.

1:  1.4546271565370261
2:  1.3412013622000813

Il s'est avéré que la méthode de lecture d'un tableau à la fois, qui était rapide en 3D, est plus lente que la méthode de lecture à chaque fois dans 4D. Cela signifie-t-il que si le tableau devient multidimensionnel, la vitesse de traitement sera plus lente que l'instruction for? C'est un résultat intéressant. Aussi, à partir de maintenant, je pensais que si je prenais le meilleur des deux mondes, ce serait un programme qui pourrait lire les données le plus rapidement, j'ai donc comparé la vitesse du code suivant.

Code de vérification 3

J'ai créé un nouveau func_3 et comparé la vitesse. func_3 est une fonction qui transforme le temps avec une instruction for et lit un tableau tridimensionnel [plan de pression, latitude, longitude] pour chaque fois.

check3.py

from netCDF4 import Dataset
import timeit

def func_1():
    nc = Dataset('../data/era5/Z_2020070100_2020070123.nc', 'r')
    a = nc.variables['Z'][:]
    for i in range(len(a)):
        b = a[i, :]
        for j in range(len(b)):
            c = b[j, :]
    return 0

def func_2():
    nc = Dataset('../data/era5/Z_2020070100_2020070123.nc', 'r')
    time = nc.variables['time'][:]
    lev = nc.variables['level'][:]
    for j in range(len(time)):
        for i in range(len(lev)):
            b = nc.variables['Z'][j, i, :]
    return 0

def func_3():
    nc = Dataset('../data/era5/Z_2020070100_2020070123.nc', 'r')
    time = nc.variables['time'][:]
    for j in range(len(time)):
        a = nc.variables['Z'][j, :]
        for i in range(len(a)):
            b = a[i, :]
    return 0


loop = 10

result_1 = timeit.timeit(lambda: func_1(), number=loop)
result_2 = timeit.timeit(lambda: func_2(), number=loop)
result_3 = timeit.timeit(lambda: func_3(), number=loop)

print('1: ', result_1 / loop)
print('2: ', result_2 / loop)
print('3: ', result_3 / loop)

Le résultat est le suivant.

1:  1.4101094176992774
2:  1.344068780587986
3:  1.0753227178938687

Comme vous vous en doutez, func_3 était le plus rapide.

Conclusion

Ce que nous avons appris des trois vérifications

• Il est plus rapide de lire jusqu'à la matrice 3D [plan de pression, latitude, longitude] en même temps.
• Il est plus rapide de traiter un tableau à 4 dimensions [temps, plan de pression, latitude, longitude] comme un tableau à 3 dimensions en le tournant avec une instruction for.

C'est ce que cela signifie. La visualisation des données météorologiques est une tâche qui prend du temps. Nous espérons que cette vérification vous fera gagner du temps.