小编Aka*_*all的帖子

我试图statsmodels在Python中运行Augmented Dickey-Fuller测试,但我似乎错过了一些东西.

这是我正在尝试的代码:

import numpy as np
import statsmodels.tsa.stattools as ts

x = np.array([1,2,3,4,3,4,2,3])
result = ts.adfuller(x)

我收到以下错误:

Traceback (most recent call last):
  File "C:\Users\Akavall\Desktop\Python\Stats_models\stats_models_test.py", line 12, in <module>
    result = ts.adfuller(x)
  File "C:\Python27\lib\site-packages\statsmodels-0.4.1-py2.7-win32.egg\statsmodels\tsa\stattools.py", line 201, in adfuller
    xdall = lagmat(xdiff[:,None], maxlag, trim='both', original='in')
  File "C:\Python27\lib\site-packages\statsmodels-0.4.1-py2.7-win32.egg\statsmodels\tsa\tsatools.py", line 305, in lagmat
    raise ValueError("maxlag should be < nobs")
ValueError: maxlag should be < nobs

我的Numpy版本:1.6.1我的statsmodels版本:0.4.1我正在使用Windows.

我在这里查看文档,但无法弄清楚我做错了什么.我错过了什么？

提前致谢.

我想保留满足两个或多个条件的数组的值，例如：

a = np.array([1,3,5,6,4,6,7,8,9])

我只想保留大于 3 且小于 7 的值，我想要的输出是：

array([5, 6, 4, 6])

我看到一种方法：

a = a[(a > 3) * (a < 7)]  

但是这种乘法感觉有些多余，而且我认为我缺少一个内置的方法来处理这样的事情。

我想知道用稀疏矩阵替换不满足某个条件的行的最佳方法是什么.例如(我使用普通数组进行说明):

我想用一行零替换总和大于10的每一行

a = np.array([[0,0,0,1,1],
              [1,2,0,0,0],
              [6,7,4,1,0],  # sum > 10
              [0,1,1,0,1],
              [7,3,2,2,8],  # sum > 10 
              [0,1,0,1,2]])

我想用零替换[2]和[4],所以我的输出应该如下所示:

array([[0, 0, 0, 1, 1],
       [1, 2, 0, 0, 0],
       [0, 0, 0, 0, 0],
       [0, 1, 1, 0, 1],
       [0, 0, 0, 0, 0],
       [0, 1, 0, 1, 2]])

这对于密集矩阵来说非常简单:

row_sum = a.sum(axis=1)
to_keep = row_sum >= 10   
a[to_keep] = np.zeros(a.shape[1]) 

但是,当我尝试:

s = sparse.csr_matrix(a) 
s[to_keep, :] = np.zeros(a.shape[1])

我收到此错误:

    raise NotImplementedError("Fancy indexing in assignment not "
NotImplementedError: Fancy indexing …

我想要一个与之相关的系数和Newey-West标准误.

我正在寻找Python库(理想情况下,但任何工作解决方案都很好)可以做以下R代码正在做的事情:

library(sandwich)
library(lmtest)

a <- matrix(c(1,3,5,7,4,5,6,4,7,8,9))
b <- matrix(c(3,5,6,2,4,6,7,8,7,8,9))

temp.lm = lm(a ~ b)

temp.summ <- summary(temp.lm)
temp.summ$coefficients <- unclass(coeftest(temp.lm, vcov. = NeweyWest))

print (temp.summ$coefficients)

结果:

             Estimate Std. Error   t value  Pr(>|t|)
(Intercept) 2.0576208  2.5230532 0.8155281 0.4358205
b           0.5594796  0.4071834 1.3740235 0.2026817

我得到系数并与它们相关的标准误差.

我看到statsmodels.stats.sandwich_covariance.cov_hac模块,但我不知道如何使它与OLS一起工作.

编辑:性能的巨大差异是由于测试中的错误,正确设置时Eigen速度提高了2到3倍.

我注意到使用C++ Eigen库的稀疏矩阵乘法 比使用Python scipy.sparse库慢得多.我scipy.sparse在~0.03几秒钟内完成了我Eigen在~25几秒钟内取得的成就.也许我在Eigen做错了什么？

这里Python代码:

from scipy import sparse
from time import time
import random as rn

N_VALUES = 200000
N_ROWS = 400000
N_COLS = 400000

rows_a = rn.sample(range(N_COLS), N_VALUES)
cols_a = rn.sample(range(N_ROWS), N_VALUES)
values_a = [rn.uniform(0,1) for _ in xrange(N_VALUES)]

rows_b = rn.sample(range(N_COLS), N_VALUES)
cols_b = rn.sample(range(N_ROWS), N_VALUES)
values_b = [rn.uniform(0,1) for _ in xrange(N_VALUES)]

big_a = sparse.coo_matrix((values_a, (cols_a, rows_a)), shape=(N_ROWS, N_COLS))
big_b …

以下是我要看的内容:

In [1]: import sys

In [2]: sys.getsizeof(45)
Out[2]: 24

In [3]: sys.getsizeof([])
Out[3]: 72

In [4]: sys.getsizeof(range(1000))
Out[4]: 8072

我知道int在Python中可以增长(可以变大24个字节)对象,它们存在于堆上,我知道为什么该对象可能非常大,但不仅仅是这些对象的集合列表？显然它不是,这里发生了什么？

例如,如果我有一个列表List(1,2,1,3,2),我想只删除一个1,所以我得到了List(2,1,3,2).如果另一个1被删除它会没事的.

我的解决方案是:

scala> val myList = List(1,2,1,3,2)
myList: List[Int] = List(1, 2, 1, 3, 2)

scala> myList.patch(myList.indexOf(1), List(), 1)
res7: List[Int] = List(2, 1, 3, 2)

但我觉得我错过了一个更简单的解决方案,如果是这样,我错过了什么？

这就是我想要做的:

x <- c(1,2,3,3,2,3,4,5,6)

my_acf = acf(x,plot=F)


> my_acf

Autocorrelations of series ‘x’, by lag

     0      1      2      3      4      5      6      7      8 
 1.000  0.497  0.097 -0.047 -0.050 -0.075 -0.231 -0.376 -0.316 

我想只提取0.497,第一个滞后的相关系数,我想把它作为数值.我怎样才能做到这一点？

谢谢

假设我使用numpy数组(例如numpy.ndarray)存储大的稀疏矩阵(即,大多数条目为0):零条目实际占用内存吗？numpy是否支持稀疏数组,如果是,则使用哪种存储格式？

让我们说我有矢量,我想要保持偶数元素.我需要用cloned()和filter().例如:

fn main() {
    let my_vec: Vec<i32> = vec![1,2,3,4];

    let my_vec_1: Vec<i32> = my_vec.iter().cloned().filter(|&x| x % 2 == 0).collect();
    println!("{:?}", my_vec_1);

    let my_vec_2: Vec<i32> = my_vec.iter().filter(|&x| x % 2 == 0).cloned().collect();
    println!("{:?}", my_vec_2);

}

两种方法都有效.使用cloned()after filter()看起来效率更高一些.因为那时我不必将迭代器的所有元素转换&T为T,而只转换已经过滤的元素.在我的例子中,这是元素的一半.

但是,我似乎看到cloned()之前申请过filter().这是一个例子:method.inspect

我认为可能.cloned()必须在之前使用没有实现Copy特征的类型,但似乎并非如此:嵌套的vec示例.此外,因为过滤器使用FnMut(&Self::Item),我认为这应该是一个问题.

cloned()以前使用有优势filter()吗？这更像是一个风格问题吗？如果是这样,是否有首选风格？