Fastet方式洗牌一個數據幀，以計算在大熊貓P值爲

Question

我有以下的數據幀（數據幀的實際長度要大的多）：

spend_df: 

var spend 
1  120 
2  200 
1  111 
1  143 
1  230 
2  180 
2  190 
2  94 
2  100 
1  278 

這裏'var'柱告訴哪個組測試行的屬於我，我需要隨機播放1000次df，隨機地將每行分配到測試的不同側，然後group by'var'並計算每次迭代的差異。在結束計算組和之間的差多少時間較大，實際的差別：

我採取如下方法：

def simulate(df): 
    simul_df = df.copy() 

    shuffled_var = simul_df.sample(frac=1) 
    shuffled_var.index = simul_df.index # replace shuffled series' index with the real one 

    simul_df['var'] = shuffled_var 
    simul_grouped = simul_df.groupby('var').sum()['spend'] 
    simul_difference = simul_grouped.iloc[1] - simul_grouped.iloc[0] 
    return simul_difference 


simulate(spend_df) 

，這是我如何計算有多少次模擬不同的是，實際的大區別：

simulations = np.array([simulate(spend_df) for i in range(1000)]) 
(simulations > real_difference).mean() 

這裏real_difference是兩組之和之間的差額花（組由 '變種'）：

grouped=df.groupby('var').sum().reset_index() 
real_diff=grouped.iloc[1] - grouped.iloc[0] 

在這種情況下，它是：882-764 = 118

每當我洗牌數據幀我需要計算我需要找出有多少次這樣的模擬差異有超過像上述那麼新組的區別real_diff

這個解決方案對我來說似乎有點冒失，有沒有更快或更有組織的方式來計算P值的這個模擬任務？沒有深入統計方法。

Answer 1

嘗試1

def gdif(df): 
    v, s = df.values.T 
    return np.diff(df.groupby('var').spend.sum().values)[0] 

def shuf(df): 
    np.random.shuffle(df['var'].values) 
    return df 

def sim1(df): 
    sdf = df.copy() 

    real_diff = gdif(sdf) 

    return (np.array([gdif(shuf(sdf)) for _ in range(1000)]) > real_diff).mean() 

sim1(spend_df) 

0.52900000000000003 

嘗試2
更numpy

def gdif2(values): 
    v, s = values.T 
    r = np.arange(v.size) 

    a = v.argsort() 
    c = s[a].cumsum() 
    d0 = c[np.flatnonzero(np.diff(v[a]))[0]] 
    return c[-1] - 2 * d0 

def shuf2(v): 
    np.random.shuffle(v[:, 0]) 
    return v 

def sim2(df): 
    values = df.values 

    real_diff = gdif2(values) 

    return (np.array([gdif2(shuf2(values)) for _ in range(1000)]) > real_diff).mean() 

sim2(spend_df) 

0.52700000000000002 

---

天真時間tetsting