熊猫-计算所有列的 z 分数

我有一个包含一列 ID 的数据框架，所有其他列都是我想要计算 z 分数的数值。下面是其中的一部分:

ID      Age    BMI    Risk Factor
PT 6    48     19.3    4
PT 8    43     20.9    NaN
PT 2    39     18.1    3
PT 9    41     19.5    NaN

我的一些列包含 NaN 值，我不想把它们包含到 z 分数计算中，所以我打算使用一个提供给这个问题的解决方案: 如何得分正常化熊猫栏与奶奶？

df['zscore'] = (df.a - df.a.mean())/df.a.std(ddof=0)

我有兴趣将此解决方案应用于除 ID 列之外的所有列，以生成一个新的数据框架，我可以使用该数据框架将其保存为 Excel 文件

df2.to_excel("Z-Scores.xlsx")

因此，基本上，我如何计算每个列的 z 分数(忽略 NaN 值)并将所有内容推入一个新的数据框架？

旁白: 在熊猫中有一个概念叫做“索引”，这让我感到害怕，因为我不太理解它。如果索引是解决这个问题的关键部分，请简化你对索引的解释。

199021 次浏览
小开
最佳答案

从列中构建一个列表，并删除不希望计算 Z 值的列:

In [66]:
cols = list(df.columns)
cols.remove('ID')
df[cols]


Out[66]:
Age  BMI  Risk  Factor
0    6   48  19.3       4
1    8   43  20.9     NaN
2    2   39  18.1       3
3    9   41  19.5     NaN
In [68]:
# now iterate over the remaining columns and create a new zscore column
for col in cols:
col_zscore = col + '_zscore'
df[col_zscore] = (df[col] - df[col].mean())/df[col].std(ddof=0)
df
Out[68]:
ID  Age  BMI  Risk  Factor  Age_zscore  BMI_zscore  Risk_zscore  \
0  PT    6   48  19.3       4   -0.093250    1.569614    -0.150946
1  PT    8   43  20.9     NaN    0.652753    0.074744     1.459148
2  PT    2   39  18.1       3   -1.585258   -1.121153    -1.358517
3  PT    9   41  19.5     NaN    1.025755   -0.523205     0.050315


Factor_zscore
0              1
1            NaN
2             -1
3            NaN
小开

几乎是一句话的解决方案:

df2 = (df.ix[:,1:] - df.ix[:,1:].mean()) / df.ix[:,1:].std()
df2['ID'] = df['ID']
小开

使用 Scipy 的 zscore函数:

df = pd.DataFrame(np.random.randint(100, 200, size=(5, 3)), columns=['A', 'B', 'C'])
df


|    |   A |   B |   C |
|---:|----:|----:|----:|
|  0 | 163 | 163 | 159 |
|  1 | 120 | 153 | 181 |
|  2 | 130 | 199 | 108 |
|  3 | 108 | 188 | 157 |
|  4 | 109 | 171 | 119 |


from scipy.stats import zscore
df.apply(zscore)


|    |         A |         B |         C |
|---:|----------:|----------:|----------:|
|  0 |  1.83447  | -0.708023 |  0.523362 |
|  1 | -0.297482 | -1.30804  |  1.3342   |
|  2 |  0.198321 |  1.45205  | -1.35632  |
|  3 | -0.892446 |  0.792025 |  0.449649 |
|  4 | -0.842866 | -0.228007 | -0.950897 |

如果数据框架中的所有列都不是数值型的，那么可以使用 select_dtypes函数将 Z-score 函数仅应用于数值型的列:

# Note that `select_dtypes` returns a data frame. We are selecting only the columns
numeric_cols = df.select_dtypes(include=[np.number]).columns
df[numeric_cols].apply(zscore)


|    |         A |         B |         C |
|---:|----------:|----------:|----------:|
|  0 |  1.83447  | -0.708023 |  0.523362 |
|  1 | -0.297482 | -1.30804  |  1.3342   |
|  2 |  0.198321 |  1.45205  | -1.35632  |
|  3 | -0.892446 |  0.792025 |  0.449649 |
|  4 | -0.842866 | -0.228007 | -0.950897 |
小开

如果要计算所有列的 zscore，只需使用以下命令:

df_zscore = (df - df.mean())/df.std()
小开

当我们处理时间序列时，计算 z 分数(或异常值——不是同一件事，但是您可以很容易地调整这段代码)有点复杂。例如，您有每周测量的10年温度数据。要计算整个时间序列的 z 分数，你必须知道一年中每一天的平均值和标准差。那么，让我们开始吧:

假设您有一个熊猫数据框架。首先，您需要一个 DateTime 索引。如果您还没有，但幸运的是您有一个带有日期的列，只需将其作为索引。熊猫会试图猜测日期的格式。这里的目标是拥有 DateTimeIndex。你可以试试看:

type(df.index)

如果你没有，那就做吧。

df.index = pd.DatetimeIndex(df[datecolumn])
df = df.drop(datecolumn,axis=1)

下一步是计算每组天数的平均值和标准差。为此，我们使用 groupby 方法。

mean = pd.groupby(df,by=[df.index.dayofyear]).aggregate(np.nanmean)
std = pd.groupby(df,by=[df.index.dayofyear]).aggregate(np.nanstd)

最后，我们循环遍历所有日期，执行计算(value-mean)/stddev; 然而，正如前面提到的，对于时间序列，这并不那么简单。

df2 = df.copy() #keep a copy for future comparisons
for y in np.unique(df.index.year):
for d in np.unique(df.index.dayofyear):
df2[(df.index.year==y) & (df.index.dayofyear==d)] = (df[(df.index.year==y) & (df.index.dayofyear==d)]- mean.ix[d])/std.ix[d]
df2.index.name = 'date' #this is just to look nicer


df2 #this is your z-score dataset.

For 循环中的逻辑是: 对于给定的年份，我们必须将每年的每一天与其平均值和 stdev 相匹配。我们在你的时间序列里，运行了这么多年。

小开

下面是使用自定义函数获取 Zscore 的另一种方法:

In [6]: import pandas as pd; import numpy as np


In [7]: np.random.seed(0) # Fixes the random seed


In [8]: df = pd.DataFrame(np.random.randn(5,3), columns=["randomA", "randomB","randomC"])


In [9]: df # watch output of dataframe
Out[9]:
randomA   randomB   randomC
0  1.764052  0.400157  0.978738
1  2.240893  1.867558 -0.977278
2  0.950088 -0.151357 -0.103219
3  0.410599  0.144044  1.454274
4  0.761038  0.121675  0.443863


## Create custom function to compute Zscore
In [10]: def z_score(df):
....:         df.columns = [x + "_zscore" for x in df.columns.tolist()]
....:         return ((df - df.mean())/df.std(ddof=0))
....:


## make sure you filter or select columns of interest before passing dataframe to function
In [11]: z_score(df) # compute Zscore
Out[11]:
randomA_zscore  randomB_zscore  randomC_zscore
0        0.798350       -0.106335        0.731041
1        1.505002        1.939828       -1.577295
2       -0.407899       -0.875374       -0.545799
3       -1.207392       -0.463464        1.292230
4       -0.688061       -0.494655        0.099824

使用 scypy.stats zscore 复制结果

In [12]: from scipy.stats import zscore


In [13]: df.apply(zscore) # (Credit: Manuel)
Out[13]:
randomA   randomB   randomC
0  0.798350 -0.106335  0.731041
1  1.505002  1.939828 -1.577295
2 -0.407899 -0.875374 -0.545799
3 -1.207392 -0.463464  1.292230
4 -0.688061 -0.494655  0.099824
小开

对于 Z 分数，我们可以坚持使用文档，而不是使用“应用”函数

from scipy.stats import zscore
df_zscore = zscore(cols as array, axis=1)
小开

要快速计算整个列的 z 值，请执行以下操作:

from scipy.stats import zscore
import pandas as pd


df = pd.DataFrame({'num_1': [1,2,3,4,5,6,7,8,9,3,4,6,5,7,3,2,9]})
df['num_1_zscore'] = zscore(df['num_1'])


display(df)
小开

另一种方法是从 scikit-learn 调用 StandardScaler()。只需实例化 StandardScaler并使用相关列作为输入调用 fit_transform。结果是一个数字数组，您可以将其作为新列分配回数据框架(或者处理数组本身等)。

from sklearn.preprocessing import StandardScaler


cols = ['col1', 'col2']
new_cols = [f"{c}_zscore" for c in cols]


sc = StandardScaler()
df[new_cols] = sc.fit_transform(df[cols])

提交答案