Xarray de bibliothèque d'analyse de données multidimensionnelle

Xarray de bibliothèque d'analyse de données multidimensionnelle

Cet article présente xarray, une bibliothèque Python qui prend en charge l'analyse de données multidimensionnelle. Pour plus d'informations, veuillez consulter Information du chef de famille.

Caractéristiques de xarray

Contexte

Les données de mesure scientifiques sont souvent multidimensionnelles. Par exemple, lors de la mesure de données de séries chronologiques avec des capteurs installés à plusieurs positions, Les données de mesure sont des données bidimensionnelles dans la direction spatiale du canal x la direction temporelle. En outre, lors de l'application d'une transformée de Fourier de courte durée à ces données, elles deviennent des données tridimensionnelles dans la direction du canal spatial x la direction du temps x la direction de la fréquence.

En général, lorsque vous traitez de telles données, je pense que vous utilisez souvent np.ndarray de numpy. Cependant, puisque np.ndarray est une simple matrice (ou tenseur), d'autres informations doivent être mises de côté. Dans l'exemple ci-dessus,

Etc. correspondent à «autres informations» ici.

Par conséquent, par exemple, si vous souhaitez découper une partie d'une certaine plage horaire des données qu'elle contient et l'utiliser. En plus des données découpées, il est nécessaire de découper les données de l'axe des temps en même temps.

Bien sûr, vous pouvez le faire exactement avec un simple np.ndarray, mais Dans un programme compliqué, ces opérations compliquées peuvent être source d'erreurs.

xarray est une bibliothèque qui simplifie ces opérations. (À propos, puisque np.ndarray est utilisé en interne, les performances de calcul haute vitesse de np.ndarray sont à peine sacrifiées.) Il existe des pandas en tant que bibliothèque qui gère des données unidimensionnelles. les pandas ne peuvent pas (facilement) gérer les données multidimensionnelles. xarray est une bibliothèque qui l'interpole.

En plus de ce qui précède,

Etc.

Au fait,

import numpy as np
import xarray as xr
xr.__version__
'0.9.1'

Il semble qu'il soit courant de l'abréger en «xr».

Type de données

Il prend principalement en charge deux types de données, xr.DataArray et xr.Dataset.

xr.DataArray xr.DataArray est les données multidimensionnelles mentionnées ci-dessus. À l'intérieur, il a un type de dictionnaire ordonné coords, qui est une paire de valeurs d'axe et d'étiquettes, et un type de dictionnaire ordonné appelé ʻattrs`, qui stocke d'autres informations.

Puisque nous surchargons la méthode __get_item__, nous pouvons y accéder comme da [i, j] de la même manière que np.ndarray. Cependant, puisque la valeur de retour est également un objet xr.DataArray, elle hérite des informations d'axe et ainsi de suite.

xr.Dataset Un objet qui contient plusieurs xr.DataArrays. Vous pouvez avoir plusieurs axes et il contiendra des informations sur l'axe auquel chaque donnée correspond.

Il est accessible comme un objet dictionnaire. Par exemple, dans xr.Dataset, qui contient des informations sur la température T et la densité N à l'intérieur. data ['T'] renverra la température T sous la forme xr.DataArray.

Comment utiliser xr.DataArray

C'est un rôle similaire à «DataSeries» dans «pandas». Il a la valeur de données elle-même et les données de l'axe.

Instanciation

data = xr.DataArray(np.random.randn(2, 3))

Ensuite, vous pouvez créer un objet 2x3 xr.DataArray sans informations d'axe.

Vous pouvez afficher le résumé de l'objet créé par la méthode print.

print(data)
<xarray.DataArray (dim_0: 2, dim_1: 3)>
array([[ 0.32853 , -1.010702,  1.220686],
       [ 0.877681,  1.180265, -0.963936]])
Dimensions without coordinates: dim_0, dim_1

Si vous ne spécifiez pas explicitement l'axe comme cette fois, dim_0 et dim_1 seront attribués automatiquement.

Par exemple, considérons le cas où la première dimension d'une certaine donnée «data_np» correspond à la position spatiale x et la seconde dimension correspond au temps t.

#Exemple de données
data_np = np.random.randn(5,4)
x_axis = np.linspace(0.0, 1.0, 5)
t_axis = np.linspace(0.0, 2.0, 4)
data = xr.DataArray(data_np, dims=['x','t'], 
                    coords={'x':x_axis, 't':t_axis}, 
                    name='some_measurement')

Etc

print(data)
<xarray.DataArray 'some_measurement' (x: 5, t: 4)>
array([[ 1.089975,  0.343039, -0.521509,  0.02816 ],
       [ 1.117389,  0.589563, -1.030908, -0.023295],
       [ 0.403413, -0.157136, -0.175684, -0.743779],
       [ 0.814334,  0.164875, -0.489531, -0.335251],
       [ 0.009115,  0.294526,  0.693384, -1.046416]])
Coordinates:
  * t        (t) float64 0.0 0.6667 1.333 2.0
  * x        (x) float64 0.0 0.25 0.5 0.75 1.0

Du résumé affiché

<xarray.DataArray 'some_measurement' (x: 5, t: 4)>

Indique que ce DataArray est une matrice 5x4 nommée some_measurement, avec le premier libellé d'axe de dimension correspondant à" x "et le deuxième libellé d'axe de dimension correspondant à" ".

Aussi,

Coordinates:

Voici une liste de données d'axe.

Informations sur l'axe

La liste des axes est accessible par dims. De plus, l'ordre affiché ici indique à quel axe de période des données d'origine correspond.

data.dims
('x', 't')

Pour accéder à la valeur de l'axe, prenez le nom de l'étiquette comme argument.

data['x']
<xarray.DataArray 'x' (x: 5)>
array([ 0.  ,  0.25,  0.5 ,  0.75,  1.  ])
Coordinates:
  * x        (x) float64 0.0 0.25 0.5 0.75 1.0

Indexage

xarray prend en charge plusieurs types d'indexation. Puisqu'il utilise le mécanisme des pandas, il est aussi rapide que les pandas.

accès de type numpy

data[0,1]
<xarray.DataArray 'some_measurement' ()>
array(0.3430393695918721)
Coordinates:
    t        float64 0.6667
    x        float64 0.0

Puisqu'il est de type tableau, il est accessible comme une matrice normale. Les informations d'axe à ce moment-là sont héritées.

indexation positionnelle

Vous pouvez y accéder en spécifiant la position le long des données de l'axe en utilisant la méthode .loc.

data.loc[0:0.5, :1.0]
<xarray.DataArray 'some_measurement' (x: 3, t: 2)>
array([[ 1.089975,  0.343039],
       [ 1.117389,  0.589563],
       [ 0.403413, -0.157136]])
Coordinates:
  * t        (t) float64 0.0 0.6667
  * x        (x) float64 0.0 0.25 0.5

.loc[0:0.5, :1.0] Est une opération pour découper des données dans la plage de 0 <x <0,5 le long de l'axe de la première dimension et dans la plage de t <1,0 le long de l'axe de la deuxième dimension.

Accès avec le nom de l'étiquette de l'axe

Utilisez les méthodes .isel et .sel pour accéder avec un nom d'étiquette d'axe.

.isel spécifie l'étiquette de l'axe et son index sous forme d'entier.

data.isel(t=1)
<xarray.DataArray 'some_measurement' (x: 5)>
array([ 0.343039,  0.589563, -0.157136,  0.164875,  0.294526])
Coordinates:
    t        float64 0.6667
  * x        (x) float64 0.0 0.25 0.5 0.75 1.0

.sel spécifie l'étiquette de l'axe et sa valeur d'axe.

data.sel(t=slice(0.5,2.0))
<xarray.DataArray 'some_measurement' (x: 5, t: 3)>
array([[ 0.343039, -0.521509,  0.02816 ],
       [ 0.589563, -1.030908, -0.023295],
       [-0.157136, -0.175684, -0.743779],
       [ 0.164875, -0.489531, -0.335251],
       [ 0.294526,  0.693384, -1.046416]])
Coordinates:
  * t        (t) float64 0.6667 1.333 2.0
  * x        (x) float64 0.0 0.25 0.5 0.75 1.0

Calcul

Prend en charge de nombreuses opérations de type np.ndarray.

Prend en charge les opérations de base, y compris la diffusion.

data+10
<xarray.DataArray 'some_measurement' (x: 5, t: 4)>
array([[ 11.089975,  10.343039,   9.478491,  10.02816 ],
       [ 11.117389,  10.589563,   8.969092,   9.976705],
       [ 10.403413,   9.842864,   9.824316,   9.256221],
       [ 10.814334,  10.164875,   9.510469,   9.664749],
       [ 10.009115,  10.294526,  10.693384,   8.953584]])
Coordinates:
  * t        (t) float64 0.0 0.6667 1.333 2.0
  * x        (x) float64 0.0 0.25 0.5 0.75 1.0

Les calculs élément par élément peuvent hériter de ces informations.

np.sin(data)
<xarray.DataArray 'some_measurement' (x: 5, t: 4)>
array([[ 0.886616,  0.336351, -0.498189,  0.028156],
       [ 0.89896 ,  0.555998, -0.857766, -0.023293],
       [ 0.39256 , -0.15649 , -0.174781, -0.677074],
       [ 0.727269,  0.164129, -0.470212, -0.329006],
       [ 0.009114,  0.290286,  0.639144, -0.865635]])
Coordinates:
  * t        (t) float64 0.0 0.6667 1.333 2.0
  * x        (x) float64 0.0 0.25 0.5 0.75 1.0

Comment utiliser xr.Dataset

xr.Dataset est un objet qui est une collection de plusieurs xr.DataArrays.

En particulier, vous pouvez indexer et découper xr.DataArray qui partagent un axe à la fois. Je pense qu'un instrument de mesure peut produire plusieurs types de signaux, Il convient au traitement de telles informations ** multidimensionnelles **.

C'est un rôle similaire à «DataFrame» dans «pandas».

Instanciation

Le premier argument est que «data_vars» est semblable à «dict». Passez le nom des données à stocker dans la clé et le taple à deux éléments dans l'élément. Le premier élément du taple passe l'étiquette d'axe correspondant à ces données, et le deuxième élément transmet les données (de type «tableau»).

Passez dict-like à coords pour stocker les données d'axe. Passez l'étiquette d'axe pour la clé et la valeur d'axe pour l'élément.

ds = xr.Dataset({'data1': (['x','t'], np.random.randn(5,4)), 'data2': (['x','t'], np.random.randn(5,4))}, 
                coords={'x': x_axis, 't': t_axis})
ds
<xarray.Dataset>
Dimensions:  (t: 4, x: 5)
Coordinates:
  * t        (t) float64 0.0 0.6667 1.333 2.0
  * x        (x) float64 0.0 0.25 0.5 0.75 1.0
Data variables:
    data1    (x, t) float64 -1.091 -1.851 0.343 2.077 1.477 0.0009389 1.358 ...
    data2    (x, t) float64 0.4852 -0.5463 -0.22 -1.357 -1.416 -0.4929 ...

Pour accéder au contenu, passez le nom de l'étiquette à l'intérieur de []. Dans ce cas, la valeur de retour sera «xr.DataArray».

ds['data1']
<xarray.DataArray 'data1' (x: 5, t: 4)>
array([[ -1.091230e+00,  -1.851416e+00,   3.429677e-01,   2.077113e+00],
       [  1.476765e+00,   9.389425e-04,   1.358136e+00,  -1.627471e+00],
       [ -2.007550e-01,   1.008126e-01,   7.177067e-01,   8.893402e-01],
       [ -1.813395e-01,  -3.407015e-01,  -9.673550e-01,   1.135727e+00],
       [  2.423873e-01,  -1.198268e+00,   1.650465e+00,  -1.923102e-01]])
Coordinates:
  * t        (t) float64 0.0 0.6667 1.333 2.0
  * x        (x) float64 0.0 0.25 0.5 0.75 1.0

Vous pouvez également accéder aux axes par étiquette.

ds['x']
<xarray.DataArray 'x' (x: 5)>
array([ 0.  ,  0.25,  0.5 ,  0.75,  1.  ])
Coordinates:
  * x        (x) float64 0.0 0.25 0.5 0.75 1.0

Indexation de l'ensemble de données xr.

Utilisez ʻisel` pour l'accès à l'index. Pour accéder au premier élément le long de l'axe des x, spécifiez le nom de l'étiquette de l'axe et son index correspondant, comme suit:

ds.isel(x=1)
<xarray.Dataset>
Dimensions:  (t: 4)
Coordinates:
  * t        (t) float64 0.0 0.6667 1.333 2.0
    x        float64 0.25
Data variables:
    data1    (t) float64 1.477 0.0009389 1.358 -1.627
    data2    (t) float64 -1.416 -0.4929 0.4926 -0.7186

Bien sûr, vous pouvez également spécifier plusieurs axes

ds.isel(x=1, t=2)
<xarray.Dataset>
Dimensions:  ()
Coordinates:
    t        float64 1.333
    x        float64 0.25
Data variables:
    data1    float64 1.358
    data2    float64 0.4926

Il prend également en charge le tranchage.

ds.isel(x=slice(0,2,1), t=2)
<xarray.Dataset>
Dimensions:  (x: 2)
Coordinates:
    t        float64 1.333
  * x        (x) float64 0.0 0.25
Data variables:
    data1    (x) float64 0.343 1.358
    data2    (x) float64 -0.22 0.4926

Indexation de position

Utilisez la méthode .sel pour l'indexation de position. Comme pour .isel, spécifiez le nom de l'étiquette de l'axe et cette fois la valeur de l'axe.

ds.sel(x=0.0)
<xarray.Dataset>
Dimensions:  (t: 4)
Coordinates:
  * t        (t) float64 0.0 0.6667 1.333 2.0
    x        float64 0.0
Data variables:
    data1    (t) float64 -1.091 -1.851 0.343 2.077
    data2    (t) float64 0.4852 -0.5463 -0.22 -1.357

Par défaut, exactement la même valeur est renvoyée, mais vous pouvez la spécifier avec l'option method. Si vous voulez la valeur la plus proche, définissez `méthode = 'plus proche'

# x = 0.Renvoie la valeur avec x la plus proche de 4.
ds.sel(x=0.4, method='nearest')
<xarray.Dataset>
Dimensions:  (t: 4)
Coordinates:
  * t        (t) float64 0.0 0.6667 1.333 2.0
    x        float64 0.5
Data variables:
    data1    (t) float64 -0.2008 0.1008 0.7177 0.8893
    data2    (t) float64 -0.03163 0.6942 0.8194 -2.93

Vous pouvez également passer un objet slice.

ds.sel(x=slice(0,0.5))
<xarray.Dataset>
Dimensions:  (t: 4, x: 3)
Coordinates:
  * t        (t) float64 0.0 0.6667 1.333 2.0
  * x        (x) float64 0.0 0.25 0.5
Data variables:
    data1    (x, t) float64 -1.091 -1.851 0.343 2.077 1.477 0.0009389 1.358 ...
    data2    (x, t) float64 0.4852 -0.5463 -0.22 -1.357 -1.416 -0.4929 ...

Recommended Posts

Xarray de bibliothèque d'analyse de données multidimensionnelle
Bibliothèque d'analyse de données multidimensionnelle xarray Partie 2
Analyse des données à l'aide de xarray
Analyse des données Titanic 2
Analyse de données python
Analyse des données Titanic 1
Analyse des données Titanic 3
Analyse de données avec python 2
Présentation de l'analyse de données python
Modèle d'analyse de données Python
Analyse de données avec Python
Python pour l'analyse des données Chapitre 4
[Python] Notes sur l'analyse des données
Notes d'apprentissage sur l'analyse des données Python
Python pour l'analyse des données Chapitre 2
Wrap Analysis part1 (préparation des données)
Analyse de données à l'aide de pandas python
Conseils et précautions lors de l'analyse des données
Python pour l'analyse des données Chapitre 3
Analyse des données Twitter | Analyse des tendances
Première analyse de données satellitaires par Tellus
Python: analyse des séries chronologiques: prétraitement des données des séries chronologiques
Modèle de prétraitement pour l'analyse des données (Python)
Expérience de réussite du test d'analyse des données de la version de novembre 2020
Analyse de données pour améliorer POG 3 ~ Analyse de régression ~
Recommandation d'analyse des données à l'aide de MessagePack
Analyse des séries chronologiques 3 Prétraitement des données des séries chronologiques
Analyse de données à partir de python (visualisation de données 1)
Analyse de données à partir de python (visualisation de données 2)
Traitement des données 2 Analyse de divers formats de données