Python 在tensorflow概率sts中设置批次

使用

tfp.sts

设置拟合和预测时遇到一些问题。我试图使模型适合于24个观测时间步序列，并预测以下24个步骤。为此，我将365*24个值的大序列分为48个步长的批次（因此观察到的数据矩阵具有shape

（364,48）

）。我还有另一个变量，我正试图使用

tfp.sts.LinearRegression

，找到线性相关性，当转换为与观察数据等效的批次时，该变量的设计矩阵具有形状

（365,24）

，或

（364,48,1）

我使用变分推理来获取参数样本，这就是我遇到的问题——样本具有形状

（n_samples，364）

。然后，我尝试使用这些样本执行预测。有了这些，观测数据和预测的设计矩阵分别具有形状

（24，）

和

（48，1）

（好像它们是训练时的批次之一），我得到了一个内存分配错误，因为预测函数无法为具有形状

[n_样本，364,24,24]

的张量分配空间。这让我觉得我在批处理设置中犯了一个错误，但我看不出在哪里。我试图创建一个代理后验分布来传递

batch_size

参数，该参数等于

（364，）

，但由于内存分配错误，它也崩溃了，它试图分配一个非常大的矩阵

这里有一些相关的代码

模型函数：

def构建模型（观察到的时间序列、功能和设计）：
一天中的小时效应=季节性(
季节数=24，
观测的时间序列=观测的时间序列，
name='hour\u of \u day\u effect'）
特征效应=标准线性回归(
设计矩阵=特征设计，
name=‘温度效应’）
自回归=标准自回归(
订单=1，
观测的时间序列=观测的时间序列，
name='autoregressive'）
模型=标准总和（[每天的小时数]，
#周中的日效应，
#年月效应，
特点"u效应",，
自回归，
#趋势
],
观察到的时间序列=观察到的时间序列）
回归模型

培训职能：

def第vi列（模型、观察到的、，
步骤数=200，
optimizer=tf.optimizers.Adam（学习率=0.1），
nsamples=50）：
变分后验率=tfp.sts.build系数替代后验率(
模型=模型）
@函数（实验编译=True）
def序列（）：
返回tfp.vi.fit_代理_后(
target\u log\u prob\u fn=model.joint\u log\u prob(
观察到的时间系列=观察到的），
替代后验概率=变分后验概率，
优化器=优化器，
num_步数=num_步数）
整体损失曲线
损耗曲线=列车（）
返回后验样本（nsamples）

预测功能：

def预测（模型，q_样本，观察，步骤=24）：
预测区=tfp.sts.forecast(
模型=模型，
观察到的时间系列=观察到的，
参数_samples=q_samples，
num_steps_forecast=步骤）
返回值（预测区平均值（）.numpy（）[…，0]，
forecast_dist.stddev（）.numpy（）[…，0]）

数据设置

train_lim='2014-01-01'
df\u列=df[：列\u列]
df_测试=df[列车长度：]
索引_start=0
设计列车=[]
观察到的列车=[]
对于范围内的索引端（48，len（df\U列），24）：
df_批次=df_序列[索引开始：索引结束]
设计序列追加（df批次空气温度值整形（-1,1））
观察到的序列追加（df\U批次[目标]）
索引_start+=24
设计列车=tf.stack（设计列车）
观测列=np.阵列（观测列）
列车外形设计

配件：

model=构建模型（观察列车、设计列车）
样本=第六列（模型、观察到的第六列）

预测：

day=15
步骤=24
索引结束=第24天
索引开始=索引结束-24
设计=df测试。空气温度[索引开始：索引结束+步数]。值。重塑（-1，1）
观察到的=df_测试[目标][索引开始：索引结束].值
模型=构建模型（观察、设计）
平均值，std=预测（模型、样本、观察到的、步骤=步骤）#此操作失败

这是我得到的堆栈跟踪：

---------------------------------------------------------------------------
ResourceExhaustedError                    Traceback (most recent call last)
<ipython-input-18-cddd6738ba4d> in <module>
     11 
     12 model = build_model(observed, design)
---> 13 means, std = forecast(model, samples, observed, steps=steps)
     14 
     15 plt.plot(range(index_start, index_end + steps), df_test[goal][index_start:index_end + steps], label='actual')

<ipython-input-11-4a8440dedb9e> in forecast(model, q_samples, observed, steps)
      1 def forecast(model, q_samples, observed, steps=24):
----> 2     forecast_dist = tfp.sts.forecast(
      3         model=model,
      4         observed_time_series=observed,
      5         parameter_samples=q_samples,

~/venv/mmes/lib/python3.8/site-packages/tensorflow_probability/python/sts/forecast.py in forecast(model, observed_time_series, parameter_samples, num_steps_forecast, include_observation_noise)
    313         num_timesteps=num_observed_steps, param_vals=parameter_samples)
    314     (_, _, _, predictive_means, predictive_covs, _, _
--> 315     ) = observed_data_ssm.forward_filter(observed_time_series, mask=mask)
    316 
    317     # Build a batch of state-space models over the forecast period. Because

~/venv/mmes/lib/python3.8/site-packages/tensorflow_probability/python/distributions/linear_gaussian_ssm.py in forward_filter(self, x, mask)
    839 
    840     with self._name_and_control_scope('forward_filter', x, {'mask': mask}):
--> 841       return self._forward_filter(x, mask=mask)
    842 
    843   def _forward_filter(self, x, mask=None):

~/venv/mmes/lib/python3.8/site-packages/tensorflow_probability/python/distributions/linear_gaussian_ssm.py in _forward_filter(self, x, mask)
    923         self.get_observation_noise_for_timestep)
    924 
--> 925     filter_states = tf.scan(update_step_fn,
    926                             elems=x if mask is None else (x, mask),
    927                             initializer=initial_state)

~/venv/mmes/lib/python3.8/site-packages/tensorflow/python/util/dispatch.py in wrapper(*args, **kwargs)
    199     """Call target, and fall back on dispatchers if there is a TypeError."""
    200     try:
--> 201       return target(*args, **kwargs)
    202     except (TypeError, ValueError):
    203       # Note: convert_to_eager_tensor currently raises a ValueError, not a

~/venv/mmes/lib/python3.8/site-packages/tensorflow/python/util/deprecation.py in new_func(*args, **kwargs)
    572                   func.__module__, arg_name, arg_value, 'in a future version'
    573                   if date is None else ('after %s' % date), instructions)
--> 574       return func(*args, **kwargs)
    575 
    576     doc = _add_deprecated_arg_value_notice_to_docstring(

~/venv/mmes/lib/python3.8/site-packages/tensorflow/python/ops/functional_ops.py in scan_v2(fn, elems, initializer, parallel_iterations, back_prop, swap_memory, infer_shape, reverse, name)
    804     ```
    805   """
--> 806   return scan(
    807       fn=fn,
    808       elems=elems,

~/venv/mmes/lib/python3.8/site-packages/tensorflow/python/util/dispatch.py in wrapper(*args, **kwargs)
    199     """Call target, and fall back on dispatchers if there is a TypeError."""
    200     try:
--> 201       return target(*args, **kwargs)
    202     except (TypeError, ValueError):
    203       # Note: convert_to_eager_tensor currently raises a ValueError, not a

~/venv/mmes/lib/python3.8/site-packages/tensorflow/python/ops/functional_ops.py in scan(fn, elems, initializer, parallel_iterations, back_prop, swap_memory, infer_shape, reverse, name)
    662       initial_i = i
    663       condition = lambda i, _1, _2: i < n
--> 664     _, _, r_a = control_flow_ops.while_loop(
    665         condition,
    666         compute, (initial_i, a_flat, accs_ta),

~/venv/mmes/lib/python3.8/site-packages/tensorflow/python/ops/control_flow_ops.py in while_loop(cond, body, loop_vars, shape_invariants, parallel_iterations, back_prop, swap_memory, name, maximum_iterations, return_same_structure)
   2733                                               list(loop_vars))
   2734       while cond(*loop_vars):
-> 2735         loop_vars = body(*loop_vars)
   2736         if try_to_pack and not isinstance(loop_vars, (list, _basetuple)):
   2737           packed = True

~/venv/mmes/lib/python3.8/site-packages/tensorflow/python/ops/control_flow_ops.py in <lambda>(i, lv)
   2724         cond = lambda i, lv: (  # pylint: disable=g-long-lambda
   2725             math_ops.logical_and(i < maximum_iterations, orig_cond(*lv)))
-> 2726         body = lambda i, lv: (i + 1, orig_body(*lv))
   2727       try_to_pack = False
   2728 

~/venv/mmes/lib/python3.8/site-packages/tensorflow/python/ops/functional_ops.py in compute(i, a_flat, tas)
    645       packed_elems = input_pack([elem_ta.read(i) for elem_ta in elems_ta])
    646       packed_a = output_pack(a_flat)
--> 647       a_out = fn(packed_a, packed_elems)
    648       nest.assert_same_structure(elems if initializer is None else initializer,
    649                                  a_out)

~/venv/mmes/lib/python3.8/site-packages/tensorflow_probability/python/distributions/linear_gaussian_ssm.py in kalman_filter_step(state, elems_t)
   1596     #  u_{t|t-1} = F_t u_{t-1} + b_t
   1597     #  P_{t|t-1} = F_t P_{t-1} F_t' + Q_t
-> 1598     predicted_mean, predicted_cov = kalman_transition(
   1599         filtered_mean,
   1600         filtered_cov,

~/venv/mmes/lib/python3.8/site-packages/tensorflow_probability/python/distributions/linear_gaussian_ssm.py in kalman_transition(filtered_mean, filtered_cov, transition_matrix, transition_noise)
   1744                                    transition_matrix,
   1745                                    transition_noise)
-> 1746   predicted_cov = _propagate_cov(filtered_cov,
   1747                                  transition_matrix,
   1748                                  transition_noise)

~/venv/mmes/lib/python3.8/site-packages/tensorflow_probability/python/distributions/linear_gaussian_ssm.py in _propagate_cov(cov, linop, dist)
   1945   """Propagate covariance through linear Gaussian transformation."""
   1946   # For linop A and input cov P, returns `A P A' + dist.cov()`
-> 1947   return linop.matmul(linop.matmul(cov), adjoint_arg=True) + dist.covariance()

~/venv/mmes/lib/python3.8/site-packages/tensorflow/python/ops/linalg/linear_operator_block_diag.py in matmul(self, x, adjoint, adjoint_arg, name)
    341                         else self.domain_dimension)
    342         op_dimension.assert_is_compatible_with(x.shape[arg_dim])
--> 343       return self._matmul(x, adjoint=adjoint, adjoint_arg=adjoint_arg)
    344 
    345   def _matmul(self, x, adjoint=False, adjoint_arg=False):

~/venv/mmes/lib/python3.8/site-packages/tensorflow/python/ops/linalg/linear_operator_block_diag.py in _matmul(self, x, adjoint, adjoint_arg)
    369     result_list = linear_operator_util.broadcast_matrix_batch_dims(
    370         result_list)
--> 371     return array_ops.concat(result_list, axis=-2)
    372 
    373   def matvec(self, x, adjoint=False, name="matvec"):

~/venv/mmes/lib/python3.8/site-packages/tensorflow/python/util/dispatch.py in wrapper(*args, **kwargs)
    199     """Call target, and fall back on dispatchers if there is a TypeError."""
    200     try:
--> 201       return target(*args, **kwargs)
    202     except (TypeError, ValueError):
    203       # Note: convert_to_eager_tensor currently raises a ValueError, not a

~/venv/mmes/lib/python3.8/site-packages/tensorflow/python/ops/array_ops.py in concat(values, axis, name)
   1652           dtype=dtypes.int32).get_shape().assert_has_rank(0)
   1653       return identity(values[0], name=name)
-> 1654   return gen_array_ops.concat_v2(values=values, axis=axis, name=name)
   1655 
   1656 

~/venv/mmes/lib/python3.8/site-packages/tensorflow/python/ops/gen_array_ops.py in concat_v2(values, axis, name)
   1205       return _result
   1206     except _core._NotOkStatusException as e:
-> 1207       _ops.raise_from_not_ok_status(e, name)
   1208     except _core._FallbackException:
   1209       pass

~/venv/mmes/lib/python3.8/site-packages/tensorflow/python/framework/ops.py in raise_from_not_ok_status(e, name)
   6841   message = e.message + (" name: " + name if name is not None else "")
   6842   # pylint: disable=protected-access
-> 6843   six.raise_from(core._status_to_exception(e.code, message), None)
   6844   # pylint: enable=protected-access
   6845 

~/venv/mmes/lib/python3.8/site-packages/six.py in raise_from(value, from_value)

ResourceExhaustedError: OOM when allocating tensor with shape[50,364,24,24] and type double on /job:localhost/replica:0/task:0/device:GPU:0 by allocator GPU_0_bfc [Op:ConcatV2] name: concat

---------------------------------------------------------------------------
ResourceExhaustedError回溯（最近一次调用上次）
在里面
11
12模型=建造模型（观察、设计）
--->13平均值，标准=预测（模型、样本、观察到的步骤=步骤）
14
15 plt.绘图（范围（索引开始，索引结束+步骤），测向测试[目标][索引开始：索引结束+步骤]，标签='实际'）
预测中（模型、q_样本、观测值、步骤）
1 def预测（模型、q_样本、观察到的步骤=24）：
---->2预测区=tfp.sts.forecast(
3模型=模型，
4观察到的时间序列=观察到的，
5参数_样本=q_样本，
预测中的~/venv/mmes/lib/python3.8/site-packages/tensorflow\u probability/python/sts/forecast.py（模型、观测时间序列、参数样本、数量步数预测，包括观测噪声）
313 num_timesteps=num_observed_steps，param_vals=parameter_samples）
314（u，u，u，预测性_u表示，预测性_uCOV，u_
-->315）=观测数据前向滤波器（观测时间序列，掩码=掩码）
316
317#在预测期内建立一批状态空间模型。因为
~/venv/mmes/lib/python3.8/site-packages/tensorflow\u probability/python/distributions/linear\u gaussian\u ssm.py in forward\u filter（self，x，mask）
839
840，带有self.\u name\u和\u control\u作用域（'forward\u filter'，x，{'ma'