In diesem Artikel wird xarray vorgestellt, eine Python-Bibliothek, die die mehrdimensionale Datenanalyse unterstützt. Weitere Informationen finden Sie unter Informationen der Hauptfamilie.
Wissenschaftliche Messdaten sind häufig mehrdimensional. Wenn Sie beispielsweise Zeitreihendaten mit Sensoren messen, die an mehreren Positionen installiert sind, Die Messdaten sind zweidimensionale Daten in der räumlichen Kanalrichtung x Zeitrichtung. Wenn eine Kurzzeit-Fourier-Transformation auf diese Daten angewendet wird, werden sie außerdem zu dreidimensionalen Daten in der räumlichen Kanalrichtung x Zeitrichtung x Frequenzrichtung.
Im Allgemeinen denke ich, dass Sie beim Umgang mit solchen Daten häufig np.ndarray von numpy verwenden. Da np.ndarray jedoch eine einfache Matrix (oder ein Tensor) ist, müssen andere Informationen beiseite gelegt werden. Im obigen Beispiel ist
Usw. entsprechen "anderen Informationen" hier.
Daher beispielsweise, wenn Sie einen Teil eines bestimmten Zeitbereichs aus den darin enthaltenen Daten ausschneiden und verwenden möchten. Zusätzlich zu den Ausschnittdaten müssen gleichzeitig die Zeitachsendaten ausgeschnitten werden.
Natürlich können Sie es genau mit einem einfachen np.ndarray tun, aber In einem komplizierten Programm können solche komplizierten Operationen eine Fehlerquelle sein.
xarray ist eine Bibliothek, die solche Operationen vereinfacht. (Da np.ndarray intern verwendet wird, wird die Hochgeschwindigkeits-Rechenleistung von np.ndarray übrigens kaum beeinträchtigt.) Es gibt Pandas als Bibliothek, die eindimensionale Daten verarbeitet. Pandas können (leicht) nicht mit mehrdimensionalen Daten umgehen. xarray ist eine Bibliothek, die es interpoliert.
Zusätzlich zum oben genannten,
__str__ ist überladen und gibt Ihnen beim Drucken einen Überblick.Und so weiter.
Apropos,
import numpy as np
import xarray as xr
xr.__version__
'0.9.1'
Es scheint, dass es üblich ist, es als "xr" abzukürzen.
Es werden hauptsächlich zwei Datentypen unterstützt, xr.DataArray und xr.Dataset.
xr.DataArray xr.DataArray sind die oben genannten mehrdimensionalen Daten. Im Inneren befindet sich ein geordneter Wörterbuchtyp "Koordinaten", bei dem es sich um ein Paar von Achsenwerten und Beschriftungen handelt, und ein geordneter Wörterbuchtyp "Attribute", der andere Informationen speichert.
Da wir die Methode get_item überladen, können wir wie da [i, j] auf dieselbe Weise wie np.ndarray darauf zugreifen. Da der Rückgabewert jedoch auch ein xr.DataArray-Objekt ist, erbt er Achseninformationen usw.
xr.Dataset Ein Objekt, das mehrere xr.DataArrays enthält. Sie können mehrere Achsen haben und es werden Informationen darüber gespeichert, welcher Achse die einzelnen Daten entsprechen.
Es kann wie ein Wörterbuchobjekt aufgerufen werden. Zum Beispiel in xr.Dataset, das Informationen zu Temperatur T und Dichte N enthält. data ['T'] gibt die Temperatur T als xr.DataArray zurück.
Dies ist eine ähnliche Rolle wie "DataSeries" in "Pandas". Es hat den Datenwert selbst und die Achsdaten.
data = xr.DataArray(np.random.randn(2, 3))
Anschließend können Sie ein 2x3 xr.DataArray-Objekt ohne Achseninformationen erstellen.
Sie können die Zusammenfassung des Objekts anzeigen, das mit der Methode "print" erstellt wurde.
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
Wenn Sie die Achse nicht explizit wie diese Zeit angeben, werden dim_0 und dim_1 automatisch zugewiesen.
Betrachten Sie zum Beispiel den Fall, in dem die erste Dimension eines bestimmten Daten "data_np" der räumlichen Position x und die zweite Dimension der Zeit t entspricht.
#Beispieldaten
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')
Und so weiter
dims die Beschriftungen auf (oder tippen Sie sie auf), die jeder Dimension von data_np entsprechen.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
Von der angezeigten Zusammenfassung
<xarray.DataArray 'some_measurement' (x: 5, t: 4)>
Gibt an, dass es sich bei diesem DataArray um eine 5x4-Matrix mit dem Namen "some_measurement" handelt, wobei die Beschriftung der Achse der 1. Dimension "x" und die Beschriftung der Achse der 2. Dimension "t" entspricht.
Ebenfalls,
Coordinates:
Das Folgende ist eine Liste von Achsdaten.
Auf die Achsenliste kann über "dims" zugegriffen werden. Darüber hinaus gibt die hier angezeigte Reihenfolge an, welcher Zeitraumachse der Originaldaten entspricht.
data.dims
('x', 't')
Um auf den Wert der Achse zuzugreifen, nehmen Sie den Beschriftungsnamen als 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
xarray unterstützt mehrere Arten der Indizierung. Da es den Mechanismus von Pandas nutzt, ist es so schnell wie Pandas.
data[0,1]
<xarray.DataArray 'some_measurement' ()>
array(0.3430393695918721)
Coordinates:
t float64 0.6667
x float64 0.0
Da es Array-ähnlich ist, kann wie eine normale Matrix darauf zugegriffen werden. Die Achseninformationen zu diesem Zeitpunkt werden vererbt.
Sie können darauf zugreifen, indem Sie die Position entlang der Achsdaten mit der Methode ".loc" angeben.
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]
Ist eine Operation zum Ausschneiden von Daten im Bereich von 0 <x <0,5 entlang der Achse der ersten Dimension und im Bereich von t <1,0 entlang der Achse der zweiten Dimension.
Verwenden Sie die Methoden .isel und .sel für den Zugriff mit einem Achsenbeschriftungsnamen.
.isel gibt die Achsenbeschriftung und ihren Index als Ganzzahl an.
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 gibt die Achsenbeschriftung und ihren Achsenwert an.
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
Unterstützt viele np.ndarray-ähnliche Operationen.
Unterstützt grundlegende Operationen einschließlich Broadcast.
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
Element-für-Element-Berechnungen können diese Informationen erben.
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
xr.Dataset ist ein Objekt, das eine Sammlung mehrerer xr.DataArrays ist.
Insbesondere können Sie "xr.DataArray" indizieren und in Scheiben schneiden, die eine Achse gleichzeitig gemeinsam nutzen. Ich denke, dass ein Messgerät mehrere Arten von Signalen ausgeben kann. Es ist für den Umgang mit solchen mehrdimensionalen Informationen geeignet.
Dies ist eine ähnliche Rolle wie "DataFrame" in "Pandas".
Das erste Argument ist, dass "data_vars" "dikt" ist. Übergeben Sie den Namen der Daten, die im Schlüssel gespeichert werden sollen, und den Taple mit zwei Elementen im Element. Das erste Element des Taples übergibt die diesen Daten entsprechende Achsenbeschriftung, und das zweite Element übergibt die Daten ("Array" -artig).
Übergeben Sie "dict" -ähnlich an "coords", um die Achsdaten zu speichern. Übergeben Sie die Achsenbeschriftung für den Schlüssel und den Achsenwert für das Element.
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 ...
Um auf den Inhalt zuzugreifen, übergeben Sie den Labelnamen in [].
In diesem Fall lautet der Rückgabewert "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
Sie können auf die Achsen auch über die Beschriftung zugreifen.
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
Verwenden Sie "isel" für den Indexzugriff. Um auf das erste Element entlang der x-Achse zuzugreifen, geben Sie den Namen der Achsenbezeichnung und den entsprechenden Index wie folgt an:
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
Natürlich können Sie auch mehrere Achsen angeben
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
Es unterstützt auch das Schneiden.
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
Verwenden Sie die .sel -Methode für die Positionsindizierung.
Geben Sie wie bei ".isel" den Namen der Achsenbezeichnung und diesmal den Achsenwert an.
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
Standardmäßig wird genau derselbe Wert zurückgegeben, Sie können ihn jedoch mit der Option method angeben.
Wenn Sie den nächstgelegenen Wert wünschen, setzen Sie method = 'next'.
# x = 0.Gibt den Wert zurück, wobei x 4 am nächsten kommt.
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
Sie können auch ein Slice-Objekt übergeben.
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