ADF检验
 
在使用很多时间序列模型的时候，如 ARMA、ARIMA，都会要求时间序列是平稳的，所以一般在研究一段时间序列的时候，第一步都需要进行平稳性检验，除了用肉眼检测的方法，另外比较常用的严格的统计检验方法就是ADF检验，也叫做单位根检验。
 
ADF检验全称是 Augmented Dickey-Fuller test，顾名思义，ADF是 Dickey-Fuller检验的增广形式。DF检验只能应用于一阶情况，当序列存在高阶的滞后相关时，可以使用ADF检验，所以说ADF是对DF检验的扩展。
 
单位根（unit root）
 
在做ADF检验，也就是单位根检验时，需要先明白一个概念，也就是要检验的对象——单位根。
 
当一个自回归过程中： ，如果滞后项系数b为1，就称为单位根。当单位根存在时，自变量和因变量之间的关系具有欺骗性，因为残差序列的任何误差都不会随着样本量（即时期数）增大而衰减，也就是说模型中的残差的影响是永久的。这种回归又称作伪回归。如果单位根存在，这个过程就是一个随机漫步（random walk）。
 
ADF检验的原理
 
ADF检验就是判断序列是否存在单位根：如果序列平稳，就不存在单位根；否则，就会存在单位根。
 
所以，ADF检验的 H0 假设就是存在单位根，如果得到的显著性检验统计量小于三个置信度（10%，5%，1%），则对应有（90%，95，99%）的把握来拒绝原假设。
 
ADF检验的python实现
 
ADF检验可以通过python中的 statsmodels 模块，这个模块提供了很多统计模型。
 
使用方法如下：
 
导入adfuller函数
 
from statsmodels.tsa.stattools import adfuller
 
adfuller函数的参数意义分别是：
 
x：一维的数据序列。
maxlag：最大滞后数目。
regression：回归中的包含项（c：只有常数项，默认；ct：常数项和趋势项；ctt：常数项，线性二次项；nc：没有常数项和趋势项）
autolag：自动选择滞后数目（AIC：赤池信息准则，默认；BIC：贝叶斯信息准则；t-stat：基于maxlag，从maxlag开始并删除一个滞后直到最后一个滞后长度基于 t-statistic 显著性小于5%为止；None：使用maxlag指定的滞后）
store：True  False，默认。
regresults：True 完整的回归结果将返回。False，默认。
返回值意义为：
 
adf：Test statistic，T检验，假设检验值。
pvalue：假设检验结果。
usedlag：使用的滞后阶数。
nobs：用于ADF回归和计算临界值用到的观测值数目。
icbest：如果autolag不是None的话，返回最大的信息准则值。
resstore：将结果合并为一个dummy。
def adfuller(x, maxlag=None, regression="c", autolag='AIC',
             store=False, regresults=False):
    """
    Augmented Dickey-Fuller unit root test

    The Augmented Dickey-Fuller test can be used to test for a unit root in a
    univariate process in the presence of serial correlation.

    Parameters
    ----------
    x : array_like, 1d
        data series
    maxlag : int
        Maximum lag which is included in test, default 12*(nobs/100)^{1/4}
    regression : {'c','ct','ctt','nc'}
        Constant and trend order to include in regression

        * 'c' : constant only (default)
        * 'ct' : constant and trend
        * 'ctt' : constant, and linear and quadratic trend
        * 'nc' : no constant, no trend
    autolag : {'AIC', 'BIC', 't-stat', None}
        * if None, then maxlag lags are used
        * if 'AIC' (default) or 'BIC', then the number of lags is chosen
          to minimize the corresponding information criterion
        * 't-stat' based choice of maxlag.  Starts with maxlag and drops a
          lag until the t-statistic on the last lag length is significant
          using a 5%-sized test
    store : bool
        If True, then a result instance is returned additionally to
        the adf statistic. Default is False
    regresults : bool, optional
        If True, the full regression results are returned. Default is False

    Returns
    -------
    adf : float
        Test statistic
    pvalue : float
        MacKinnon's approximate p-value based on MacKinnon (1994, 2010)
    usedlag : int
        Number of lags used
    nobs : int
        Number of observations used for the ADF regression and calculation of
        the critical values
    critical values : dict
        Critical values for the test statistic at the 1 %, 5 %, and 10 %
        levels. Based on MacKinnon (2010)
    icbest : float
        The maximized information criterion if autolag is not None.
    resstore : ResultStore, optional
        A dummy class with results attached as attributes
    """
 
 现在我们用一个RB1309的收盘数据来进行ADF检验，看一下结果：
 
 
result = adfuller(rb_price)
print(result)


(-0.45153867687808574, 0.9011315454402649, 1, 198, {'5%': -2.876250632135043, '1%': -3.4638151713286316, '10%': -2.574611347821651}, 1172.4579344852016)
 
看到 t-statistic 的值 -0.451 要大于10%，所以无法拒绝原假设，另外，p-value的值也很大。
 
将数据进行一阶差分滞后，看一下结果如何：
 
 
rb_price = np.diff(rb_price)
result = adfuller(rb_price)
print(result)

(-15.436034211511204, 2.90628134201655e-28, 0, 198, {'5%': -2.876250632135043, '1%': -3.4638151713286316, '10%': -2.574611347821651}, 1165.1556545612445)
 
 看到 t-statistic 的值 -15 要小于5%，所以拒绝原假设，另外，p-value的值也很小。
 
 

 
 
什么是std::optional？
 
 
C++17中新引入了std::optional<T>。类模板std::optional管理一个可选的容纳值。简单说来，std::optional就是一个和类型，常见的用处就是作为函数返回值来处理一个可能失败的函数。
 
 
如何处理无参返回？
 
 
此前处理无参返回的函数一般有两种方式。
 
 
第一种：
 
 
bool foo(int param1, int*param2);
 
 
返回参数作为引用/指针型输入参数而存在，传入地址，在执行完毕后访问指定地址得到返回值，而使用真正的返回值来作为函数是否成功的返回。
 这种方式可以实现需求。
 缺点是：
 
 
浪费存储空间——无论是否返回值，都需要做好有值的准备，param2的空间需要事先分配
可读性/可用性差——同为参数，有的是输入参，有的是输出参，即使以名字取分，使用的时候也比较困难。
 
第二种：
 
 
std::pair<T,bool>foo(int param1);
 
 
这是比较常用的方式，解决了问题2——每次使用都知道返回值是pair的第一个值，第二个值专门用于成功与否的判断。
 不过std::optional继续优化了处理方式。
 
 
正如前述，std::optional管理的是可选的容纳值。如果函数成功执行，则实例含值，如果执行失败，实例不含值。
 
 
如何处理多参返回？
 
 
这都不是个问题，class，struct，哪个都比直接放在一个tuple里面或者更过分的直接列在函数参数里面好。
 
 
使用std::optional
 
 
定义位置：<optional>
T：一个满足可析构的类型
初始化： 
   
使用=用另一个T类型含值std::optional初始化
使用构造函数初始化：以nullopt_t类型值或是T类型值
默认构造函数
是否含值： 
   
使用bool hasValue=temp.has_value()检查是否含值
取值： 
   
使用（*temp）取T，即默认为T的指针
使用temp.value()获取T值
使用temp.value_or()获取值（存在值）或者其他（不存在值）
返回： 
   
一个T对象（非指针）
nullopt
{}
...
 
一个实例：
 
 
//一个可析构类型
class Test{
    int num1;
    int num2;
    Test(int n1,int n2){
        num1=n1;
        num2=n2;
    }
    bool isOK(){
        return num1+num2>=0?true:false;
    }
}

//一个可能执行失败的函数【有点草率，看看语法就好
std::optional<Test>foo(int num){
    Test t(num,num);
    if(t.isOK()){
        //返回正常对象
        return t;
    }
    //返回空值
    return nullopt;
}

int main(){
    int myAge=20;
    //一种赋值方式
    std::optional<Test>opt=foo(myAge);
    //一种判断是否含值的方式
    if(opt.has_value()){
        //foo函数成功执行
        //一种取值方式
        cout<<(opt.value()).num1<<endl;
    }
}
 
 
Reference
 
 
cppreference-std::optional 更多特性/支持的操作请访问
C++17 新特性之 std::optional（上）更好地理解为何使用std::optional请访问
 
 
转载于:https://www.cnblogs.com/riko707/p/11440664.html

DL之LSTM：tf.contrib.rnn.BasicLSTMCell(rnn_unit)函数的解读
 
 
 
 
 
目录
 
tf.contrib.rnn.BasicLSTMCell(rnn_unit)函数的解读
 
函数功能解读
 
函数代码实现
 

 
 
 
 
tf.contrib.rnn.BasicLSTMCell(rnn_unit)函数的解读
 
函数功能解读
 
 
  """Basic LSTM recurrent network cell.
 
  The implementation is based on: http://arxiv.org/abs/1409.2329.
 
  We add forget_bias (default: 1) to the biases of the forget gate in order to reduce the scale of forgetting in the beginning of the training.
 
  It does not allow cell clipping, a projection layer, and does not use peep-hole connections: it is the basic baseline.  For advanced models, please use the full @{tf.nn.rnn_cell.LSTMCell}
   that follows.
 
  """
 
  def __init__(self,
                num_units,
                forget_bias=1.0,
                state_is_tuple=True,
                activation=None,
                reuse=None,
                name=None,
                dtype=None):
     """Initialize the basic LSTM cell.
 
 
基本LSTM递归网络单元。
 
实现基于:http://arxiv.org/abs/1409.2329。
 
我们在遗忘门的偏见中加入了遗忘偏见(默认值:1)，以减少训练开始时的遗忘程度。
 
它不允许细胞剪切(一个投影层)，也不使用窥孔连接:它是基本的基线。对于高级模型，请使用完整的@{tf.n .rnn_cell. lstmcell}遵循。
 
 
 
 
    Args:
       num_units: int, The number of units in the LSTM cell.
       forget_bias: float, The bias added to forget gates (see above).
         Must set to `0.0` manually when restoring from CudnnLSTM-trained checkpoints.
       state_is_tuple: If True, accepted and returned states are 2-tuples of the `c_state` and `m_state`.  If False, they are concatenated along the column axis.  The latter behavior will soon be deprecated.
       activation: Activation function of the inner states.  Default: `tanh`.
       reuse: (optional) Python boolean describing whether to reuse variables in an existing scope.  If not `True`, and the existing scope already has the given variables, an error is raised.
       name: String, the name of the layer. Layers with the same name will share weights, but to avoid mistakes we require reuse=True in such cases.
       dtype: Default dtype of the layer (default of `None` means use the type of the first input). Required when `build` is called before `call`.
 
      When restoring from CudnnLSTM-trained checkpoints, must use `CudnnCompatibleLSTMCell` instead.
     """
 
 
参数:
num_units: int类型, LSTM单元中的单元数。
 forget_bias: float类型，偏见添加到忘记门(见上面)。
 从cudnnlstm训练的检查点恢复时，必须手动设置为“0.0”。
 state_is_tuple: 如果为真，则接受状态和返回状态是' c_state '和' m_state '的二元组。如果为假，则沿着列轴连接它们。后一种行为很快就会被摒弃。
activation: 内部状态的激活功能。默认值tanh激活函数。
reuse: (可选)Python布尔值，描述是否在现有范围内重用变量。如果不是“True”，并且现有范围已经有给定的变量，则会引发错误。
name:字符串，层的名称。具有相同名称的层将共享权重，但是为了避免错误，我们需要在这种情况下重用=True。
dtype:该层的默认dtype(默认为‘None’意味着使用第一个输入的类型)。当' build '在' call '之前被调用时是必需的。
 
从经过cudnnlstm训练的检查点恢复时，必须使用“CudnnCompatibleLSTMCell”。
 ”“”
 
 
 
函数代码实现
 

@tf_export("nn.rnn_cell.BasicLSTMCell")
class BasicLSTMCell(LayerRNNCell):
  """Basic LSTM recurrent network cell.

  The implementation is based on: http://arxiv.org/abs/1409.2329.

  We add forget_bias (default: 1) to the biases of the forget gate in order to
  reduce the scale of forgetting in the beginning of the training.

  It does not allow cell clipping, a projection layer, and does not
  use peep-hole connections: it is the basic baseline.

  For advanced models, please use the full @{tf.nn.rnn_cell.LSTMCell}
  that follows.
  """

  def __init__(self,
               num_units,
               forget_bias=1.0,
               state_is_tuple=True,
               activation=None,
               reuse=None,
               name=None,
               dtype=None):
    """Initialize the basic LSTM cell.

    Args:
      num_units: int, The number of units in the LSTM cell.
      forget_bias: float, The bias added to forget gates (see above).
        Must set to `0.0` manually when restoring from CudnnLSTM-trained
        checkpoints.
      state_is_tuple: If True, accepted and returned states are 2-tuples of
        the `c_state` and `m_state`.  If False, they are concatenated
        along the column axis.  The latter behavior will soon be deprecated.
      activation: Activation function of the inner states.  Default: `tanh`.
      reuse: (optional) Python boolean describing whether to reuse variables
        in an existing scope.  If not `True`, and the existing scope already has
        the given variables, an error is raised.
      name: String, the name of the layer. Layers with the same name will
        share weights, but to avoid mistakes we require reuse=True in such
        cases.
      dtype: Default dtype of the layer (default of `None` means use the type
        of the first input). Required when `build` is called before `call`.

      When restoring from CudnnLSTM-trained checkpoints, must use
      `CudnnCompatibleLSTMCell` instead.
    """
    super(BasicLSTMCell, self).__init__(_reuse=reuse, name=name, dtype=dtype)
    if not state_is_tuple:
      logging.warn("%s: Using a concatenated state is slower and will soon be "
                   "deprecated.  Use state_is_tuple=True.", self)

    # Inputs must be 2-dimensional.
    self.input_spec = base_layer.InputSpec(ndim=2)

    self._num_units = num_units
    self._forget_bias = forget_bias
    self._state_is_tuple = state_is_tuple
    self._activation = activation or math_ops.tanh

  @property
  def state_size(self):
    return (LSTMStateTuple(self._num_units, self._num_units)
            if self._state_is_tuple else 2 * self._num_units)

  @property
  def output_size(self):
    return self._num_units

  def build(self, inputs_shape):
    if inputs_shape[1].value is None:
      raise ValueError("Expected inputs.shape[-1] to be known, saw shape: %s"
                       % inputs_shape)

    input_depth = inputs_shape[1].value
    h_depth = self._num_units
    self._kernel = self.add_variable(
        _WEIGHTS_VARIABLE_NAME,
        shape=[input_depth + h_depth, 4 * self._num_units])
    self._bias = self.add_variable(
        _BIAS_VARIABLE_NAME,
        shape=[4 * self._num_units],
        initializer=init_ops.zeros_initializer(dtype=self.dtype))

    self.built = True

  def call(self, inputs, state):
    """Long short-term memory cell (LSTM).

    Args:
      inputs: `2-D` tensor with shape `[batch_size, input_size]`.
      state: An `LSTMStateTuple` of state tensors, each shaped
        `[batch_size, num_units]`, if `state_is_tuple` has been set to
        `True`.  Otherwise, a `Tensor` shaped
        `[batch_size, 2 * num_units]`.

    Returns:
      A pair containing the new hidden state, and the new state (either a
        `LSTMStateTuple` or a concatenated state, depending on
        `state_is_tuple`).
    """
    sigmoid = math_ops.sigmoid
    one = constant_op.constant(1, dtype=dtypes.int32)
    # Parameters of gates are concatenated into one multiply for efficiency.
    if self._state_is_tuple:
      c, h = state
    else:
      c, h = array_ops.split(value=state, num_or_size_splits=2, axis=one)

    gate_inputs = math_ops.matmul(
        array_ops.concat([inputs, h], 1), self._kernel)
    gate_inputs = nn_ops.bias_add(gate_inputs, self._bias)

    # i = input_gate, j = new_input, f = forget_gate, o = output_gate
    i, j, f, o = array_ops.split(
        value=gate_inputs, num_or_size_splits=4, axis=one)

    forget_bias_tensor = constant_op.constant(self._forget_bias, dtype=f.dtype)
    # Note that using `add` and `multiply` instead of `+` and `*` gives a
    # performance improvement. So using those at the cost of readability.
    add = math_ops.add
    multiply = math_ops.multiply
    new_c = add(multiply(c, sigmoid(add(f, forget_bias_tensor))),
                multiply(sigmoid(i), self._activation(j)))
    new_h = multiply(self._activation(new_c), sigmoid(o))

    if self._state_is_tuple:
      new_state = LSTMStateTuple(new_c, new_h)
    else:
      new_state = array_ops.concat([new_c, new_h], 1)
    return new_h, new_state
 
 

日常开发中最常见的异常大概就是NullPointerException，因为我们写业务代码的时候经常不会去考虑这个对象为空，这个属性为空的情况。当测试告诉我们程序报错了，我们一看日志报错信息为空指针异常，然后就会恍然大悟，哦这里忘记加空值判断了，于是就会写if (face!=null)这样的代码去规避这样的问题。但是当出现对象包含对象的情况，这样的if判断会变得很冗余而且可维护性也差。Optional类就是为了解决这一系列问题的。
 
Optional常用的一些方法
 
 
 
 
// 返回一个Optionl包装的一个空实例 static <T> Optional<T> empty()
 
 
// 根据特定条件返回一个 Optional实例 Optional<T> filter(Predicate<? super T> predicate)
 
 
// 返回Optional实际表示的对象 T get()
 
 
// 获取Optional保存的对象的各个属性值 <U> Optional<U> map(Function<? super T,? extends U> mapper)
 
 
// 返回一个不为null的Optional对象 static <T> Optional<T> ofNullable(T value)
 
 
// 配合5使用当获取到的实例是null时返回默认对象 T orElse(T other)
 
 
// 配合5使用如果获取的是null时,获取一个特定对象 T orElseGet(Supplier<? extends T> other)
 
 
// 配合5 使用如果为null时，抛出指定异常 <X extends Throwable> orElseThrow(Supplier<? extends X> exceptionSupplier)
 
 
 
实战
 
业务场景1
 
一个小区中有很多楼栋，楼栋下面有很多的单元，单元下面有很多的楼层，楼层下面有很多的房间，而日常生活中我们在设计表格的时候，小区楼栋单元楼层房间都是维护在不同表格里面的，但是实际业务需求是为了准确知道某个房间的具体位置，一般定义房间名称时会是以xxxx小区-xx栋-xx单元-xx楼-xx号房间,这就需要去小区实体取小区名字，楼栋实体取楼栋名字等系列操作，完成以上需求有两张方案如下
 
 
传统方案
 
  
 
   
// 小区名字
String communityName 
if(community !=null){
    communityName=community.getCommunityName();
}
// 楼栋名字
String buildName 
if(build !=null){
    buildName=build.getBulidName();
}
..... 最后拼接字符串返回
 
  
 
 
Java 8 方案
 
  
 
   
// 小区名字
String communityName =Optional.ofNullable(community).map(community -> community.getCommunityName()).orElse("*");
// 楼栋名字
String bName=Optional.ofNullable(build).map(build>build.getBuildingName()).orElse("*");
// 单元名字
String unitName = Optional.ofNullable(unit).map(unit -> unit.getUnitName()).orElse("*");
// 楼层名字
String floorName = Optional.ofNullable(basicBuildingUnitFloorByFloorId).map(floor -> floor.getFloorName()).orElse("*");
// 房间名字
String roomName = Optional.ofNullable(basicRoomByRoomId).map(room -> room.getRoomName()).orElse("*");
// 返回拼接后的名字
return sb.append(communityName).append("-").append(buildName).append("-").append(unitName).append("-").append(floorName).append("-").append(roomName).toString();
   }                         
 
  
 
 
业务场景2
 
常常会先获取到某个对象，然后获取这个对象的某个属性的值，map()可以很方便的完成这一需求而且十分优雅。
 
 
  
 
   
// 获取组织结构对象
EstateOrganization or =iEstateOrganiz.findOrganizationByName(e.getOrgId());
// 将组织结构的Id值 赋予给用户
user.setOrgId(Optional.ofNullable(or).map(organ->organ.getOrgId()).orElse("未知组织机构"));
 
  
 
 
总结
 
传统方案代码冗余且不易维护。
Java 8 优化后代码简洁明了，而且看起来十分的清爽优雅。