标签: python-xarray

当使用xarray open_dataset或open_mfdataset加载NARR netcdf数据集（例如ftp://ftp.cdc.noaa.gov/Datasets/NARR/monolevel/air.2m.2010.nc）时，xarray返回有关“与_FillValue和missing_values”。

输入：

ds = xarray.open_dataset('air.2m.2010.nc')

产生此错误：

ValueError: ('Discovered conflicting _FillValue and missing_value. Considering opening the offending dataset using decode_cf=False, corrected the attributes', 'and decoding explicitly using xray.conventions.decode_cf(ds)')

使用建议打开时：

ds = xarray.open_dataset('air.2m.2010.nc',decode_cf=False)，

数据集已打开，但变量，时间，坐标等未解码（显然）。xarray.decode_cf(ds)显式使用似乎无法成功解码数据集，因为会遇到相同的错误。

我相信会出现此错误，因为NARR数据集是Lambert Conformal，因此由于xarray打开网格时的网格形状而导致一些缺失值，并且由于某些原因，这与填充值冲突。

在xarray中打开和解码此文件的最佳方法是什么？

注意：我已经能够使用netcdf4-python打开和解码，但是我希望能够在xarray中执行此操作，以利用dask提供的核心计算功能。

Xarray 是否支持 numpy 计算函数，例如 polyfit？或者是否有一种有效的方法可以将此类函数应用于数据集？

示例：我想计算拟合到两个变量（温度和高度）的直线的斜率，以计算失效率。我有一个数据集（如下），其中包含这两个维度为（垂直、时间、xgrid_0、ygrid_0）的变量。

<xarray.Dataset>
Dimensions:    (PressLev: 7, time: 48, xgrid_0: 685, ygrid_0: 485)
Coordinates:
    gridlat_0  (ygrid_0, xgrid_0) float32 44.6896 44.6956 44.7015 44.7075 ...
    gridlon_0  (ygrid_0, xgrid_0) float32 -129.906 -129.879 -129.851 ...
  * ygrid_0    (ygrid_0) int64 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 ...
  * xgrid_0    (xgrid_0) int64 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 ... …

我正在尝试设置一个性能测试来重复读取具有不同分块配置的 netcdf 文件，以最终确定特定用例的最佳块大小。我遇到的一个问题是，当使用xarray.open_dataset()读取文件时，即使缓存设置为 False，它仍然以某种方式将缓存存储在内存中。我知道这是基于两个指标的情况：

• 第一次运行时读取总是很慢。
• 使用RamMap应用程序，我看到即使关闭数据集，打开的文件仍在内存中。

这是我运行的代码：

ds = xr.open_dataset("path/to/netcdf/file", engine='h5netcdf', cache=False)

lat_dim = 2160
lon_dim = 4320
time_dim = 46
read_chunk_size = 2160

data = np.empty((time_dim, lat_dim, lon_dim))
data[0:time_dim, 0:read_chunk_size, 0:read_chunk_size] = \
ds['value'][0:time_dim, 0:read_chunk_size, 0:read_chunk_size]

ds.close()

很明显，我对 xarray 中缓存的理解非常少。因此，如果有人能向我解释它的实际工作原理，以及如何在多运行性能测试中利用它，我将不胜感激。

我正在尝试创建一个兼容cf的netcdf文件.我可以得到大约98%cf与xarray兼容但是我遇到了一个问题.当我在我正在创建的文件上执行ncdump时,我看到以下内容:

float lon(lon) ;
    lon:_FillValue = NaNf ;
    lon:long_name = "Longitude" ;
    lon:standard_name = "longitude" ;
    lon:short_name = "lon" ;
    lon:units = "degrees_east" ;
    lon:axis = "X" ;
    lon:valid_min = -180.f ;
    lon:valid_max = 180.f ;
float lat(lat) ;
    lat:_FillValue = NaNf ;
    lat:long_name = "Latitude" ;
    lat:standard_name = "latitude" ;
    lat:short_name = "lat" ;
    lat:units = "degrees_north" ;
    lat:axis = "Y" ;
    lat:valid_min = -90.f ;
    lat:valid_max = 90.f ;
double time(time) ;
    time:_FillValue = NaN ;
    time:standard_name = …

是否也可以创建一个核外 DataArray，并使用 xarray 将其逐块写入 NetCDF4 文件？

例如，当维度更大时，我希望能够以核外方式执行此操作，因此我无法将整个数组存储在内存中：

num_steps = 20
num_times = 100
#Create DataArray
d = xr.DataArray(np.zeros([num_steps, num_times], np.float32),
                 {'Step': np.arange(num_steps),
                  'Time': np.arange(num_times)},
                 ('Step', 'Time'))
#Computatation
for i in range(num_steps):
    d[i, :] = i
#Write to file
d.to_netcdf('test.nc')

所以我不想在内存中创建整个 NumPy 数组，我希望计算和写入文件阶段一次完成一个块（在本例中在 Step 维度上分块）。

更新：似乎（来自@jhamman 的回答）可能无法使用 xarray 实现我上面的示例。我的主要兴趣是加深对 xarray 的核外计算的理解，所以我没有要问的特定计算，但是，由于有人要求我提供一个更复杂的示例，因此我有一个潜在的应用程序有是：

for i in range(num_steps):
    u[:] = f(u)
    s[:] = g(s)
    d[i, :] = u[:] * s[:]

其中u和s是维时间xr.DataArrays，和f和g是PDE求解器仅依赖来自前面步骤的输入阵列上。假设有 1000 步，但 Time 维度太大，我只能在内存中存储一​​两个，因此d …

我使用xarray作为分析流体湍流数据的工作流程的基础,但我无法正确利用dask来限制笔记本电脑上的内存使用量.

我有一个n带维度的数据阵列('t', 'x', 'z'),我在z维度上将其拆分为5个块:

<xarray.DataArray 'n' (t: 801, x: 960, z: 512)>
dask.array<shape=(801, 960, 512), dtype=float32, chunksize=(801, 960, 5)>
Coordinates:
* t              (t) int64 200 201 202 203 204 205 206 207 208 209 210 211 ...
* x              (x) int64 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 ...
* z              (z) int64 0 1 2 3 4 5 6 7 8 9 10 11 …

我有一个 4D xarray 数据集。我想在特定维度（这里是时间）上的两个变量之间进行线性回归，并将回归参数保留在 3D 数组中（其余维度）。我设法通过使用此串行代码获得了我想要的结果，但速度相当慢：

# add empty arrays to store results of the regression
res_shape = tuple(v for k,v in ds[x].sizes.items() if k != 'year')
res_dims = tuple(k for k,v in ds[x].sizes.items() if k != 'year')
ds[sl] = (res_dims, np.empty(res_shape, dtype='float32'))
ds[inter] = (res_dims, np.empty(res_shape, dtype='float32'))
# Iterate in kept dimensions
for lat in ds.coords['latitude']:
    for lon in ds.coords['longitude']:
        for duration in ds.coords['duration']:
            locator = {'longitude':lon, 'latitude':lat, 'duration':duration}
            sel = ds.loc[locator]
            res = scipy.stats.linregress(sel[x], sel[y])
            ds[sl].loc[locator] = res.slope …

按单个维度分组对于 xarray DataArrays 工作正常：

d = xr.DataArray([1, 2, 3], coords={'a': ['x', 'x', 'y']}, dims=['a'])
d.groupby('a').mean())  # -> DataArray (a: 2) array([1.5, 3. ])`

但是，这仅支持单个维度，因此按多个维度分组不起作用：

d = DataAssembly([[1, 2, 3], [4, 5, 6]],
                 coords={'a': ('multi_dim', ['a', 'b']), 'c': ('multi_dim', ['c', 'c']), 'b': ['x', 'y', 'z']},
                 dims=['multi_dim', 'b'])
d.groupby(['a', 'b'])  # TypeError: `group` must be an xarray.DataArray or the name of an xarray variable or dimension

我只有一个低效的解决方案，它手动执行 for 循环：

a, b = np.unique(d['a'].values), np.unique(d['b'].values)
result = xr.DataArray(np.zeros([len(a), len(b)]), coords={'a': a, 'b': b}, …

对于多维滚动窗口使用 xarray 滚动构造的最佳方法是什么？这是一个 numpy 示例：

import numpy as np
from numpy.lib.stride_tricks import as_strided

data = np.array(np.arange(6).reshape(2, 3),dtype="float64")


win_size = (
    3  # Size of the window (e.g. 3*3)
)
win_size_half = int(np.floor(win_size / 2))

# pad with nan to get correct window for the edges
data = np.pad(
    data,
    (win_size_half, win_size_half),
    "constant",
    constant_values=(np.nan),
)

sub_shape = (win_size, win_size)
view_shape = tuple(np.subtract(data.shape, sub_shape) + 1) + sub_shape
data_view = as_strided(
    data, view_shape, data.strides * 2
)
data_view = data_view.reshape((-1,) + sub_shape) …

我是 xarray 和机器学习方面的新手。

所以我的 xarray 数据集如下：

<xarray.Dataset>
Dimensions:    (latitude: 721, longitude: 1440, time: 72)
Coordinates:
  * time       (time) datetime64[ns] 1950-01-01 1951-01-01 ... 2021-01-01
  * longitude  (longitude) float32 0.0 0.25 0.5 0.75 ... 359.25 359.5 359.75
  * latitude   (latitude) float32 90.0 89.75 89.5 89.25 ... -89.5 -89.75 -90.0
Data variables:
    z          (time, latitude, longitude) float32 49654.793 49654.793 ... 49654.793

现在我想在跨时间维度的每个网格上应用线性回归，然后我想从原始值中删除回归值以删除趋势。下面是一个示例网格的示例。

y = np.array(jan.z[:, 700, 700]) #single grid with all time
x = (np.arange(1950, len(y)+1949)).reshape(-1, 1) #72 time for x axis which …