数据挖掘比赛常用数据处理函数

文章目录

写在前面
1.pandas apply applymap map 的使用
2. csr csc 稀疏矩阵
3. pandas 表连接并显示连接后的NaN值
输出数组中出现次数最多的元素
value_counts对Series值进行统计并排序
get_dummies() 和 factorize（）
drop_dumplicates()

写在前面

该篇博客用来记录数据挖掘比赛中常用的pandas 处理技巧实时更新

1.pandas apply applymap map 的使用

apply表示沿着dataFrame某一个轴执行函数默认axies=0 即对每一列的所有行进行某一运算
如果axies=1 则对每一行的所有列进行某一运算
例：

In [116]: frame = DataFrame(np.random.randn(4, 3), columns=list('bde'), index=['Utah', 'Ohio', 'Texas', 'Oregon'])In [117]: frame
Out[117]: b         d         e
Utah   -0.029638  1.081563  1.280300
Ohio    0.647747  0.831136 -1.549481
Texas   0.513416 -0.884417  0.195343
Oregon -0.485454 -0.477388 -0.309548In [118]: f = lambda x: x.max() - x.min()In [119]: frame.apply(f)
Out[119]:
b    1.133201
d    1.965980
e    2.829781
dtype: float64

def change(x):if x.find('iphone')==0:x='apple'return x
traindata['make']=traindata['make'].apply(lambda x: change(x))

applymap是对dataFrame中每一个元素都进行该操作
map是对Series中的每一个元素都进行该操作

2. csr csc 稀疏矩阵

在进行feature engineing 之后会产生很多feature位置为0的数据，这时候使用稠密矩阵存储会浪费很多空间所以可以转化为稀疏矩阵这里主要使用csr和csc这两种稀疏矩阵

csr稀疏矩阵：存储3行数据第一行数据是row的偏移量即每一行和其前面所有行非零特征的总和（总共有行数加1个元素从第0行开始计算）
第二行数据为每一个非零数据的列的index
第三行数据为每一个非零数据的数据值

    indptr = np.array([0, 2, 3, 6])#最后一个元素是总共有多少个数据，这里为6，因为data的数据为1到6，6个数字#前三个元素，分别为每一行第一个有数据的元素在data数据中的索引，比如3，指的是第3行的第一个数字在data中的index为3，值为4indices = np.array([0, 2, 2, 0, 1, 2])#元素意义： 每个数在最终生成的数组数据中，位于每一行中的索引值data = np.array([1, 2, 3, 4, 5, 6])#在矩阵中的所有元素data_array = csr_matrix((data, indices, indptr), shape=(3, 3)).toarray()print('data_array=', data_array)  # [[1 0 2] [0 0 3] [4 5 6]]return

在使用csr 或者csc等压缩格式数据进行处理的时候可以想象成使用的依旧是这些格式对应的稠密矩阵这些稀疏矩阵运算对用用户而言是透明的
例如：

cv = CountVectorizer()
cv .fit(data['user_tags'])
train_a = cv .transform(train['user_tags'])
test_a = cv .transform(test['user_tags'])

利用CountVectorizer（）进行分词并统计出现频数
返回的数据即为CSR存储的数据
如果对这一类的数据进行像稠密数据一样的concat等操作的时候可以使用

sparse.hstack 相当于稠密矩阵中的pd.concat(axis=1)
sparse.vstack 相当于稠密矩阵中的pd.concat(axis=0)
例如：

>>> from scipy.sparse import coo_matrix, hstack
>>> A = coo_matrix([[1, 2], [3, 4]])
>>> B = coo_matrix([[5], [6]])
>>> hstack([A,B]).toarray()
array([[1, 2, 5],[3, 4, 6]])

hstack可以传入三个参数
1 blocks 即为进行拼接的稀疏矩阵
2 format 返回的稀疏矩阵的类型可以设置为’csr’
3 dtype 返回数据的数据类型
在这里有一个小trick 在使用CountVectorizer（）进行分词并统计数量之后如果将数据类型由int64转化为bool可以将每个特征出现的次数转化为是否出现了该特征
同时如果能够确定每一行每一个特征只会出现一次，那么转化之后可以大大降低该特征的存储空间

3. pandas 表连接并显示连接后的NaN值

pandas表连接可以使用 join 以及merge
对于连接之后可能会由于操作不慎出现部分元素为NaN的情况这时我们需要找出这些情况
df.isnull().any() 会显示各列是否存在为NaN的元素
df.isnull() 输出该DataFrame 只是每个位置上都是true或者false

此时如果想要得到是True的坐标可使用 df.isnull().values 将其转化为array数组
使用 df[df.isnull().values==True] 获取原始dataFrame中为null的元素
如果想要查看究竟是什么原因导致了连接出现NaN可以搭配unique

df[df.isnull().values==True] [’ label’ ].unique()

输出数组中出现次数最多的元素

可以使用np.bincount() 以及 np.argmax() 组合
对于 np.bincount() 输出的数组比x的最大值大1 输出数组每个位置的输出值代表该位置的值在原始数组中出现的次数

# 我们可以看到x中最大的数为7，因此bin的数量为8，那么它的索引值为0->7
x = np.array([0, 1, 1, 3, 2, 1, 7])
# 索引0出现了1次，索引1出现了3次......索引5出现了0次......
np.bincount(x)
#因此，输出结果为：array([1, 3, 1, 1, 0, 0, 0, 1])

np.argmax
返回最大值的索引

value_counts对Series值进行统计并排序

使用value_counts 输出Series 对应的出现次数返回的是一个Series数组，如果想要得到各个值在所有值中所占的比重可以加上 normalize=True 输出的则是一个Series，index是属性名 valus是对应属性值所占的比重

get_dummies() 和 factorize（）

get_dummies ：
aim: 得到category类型特征的one-hot 编码
arguments:Series or dataFrame
pd.get_dummies(pd.Series(list(“abcaa”)))

>>> pd.get_dummies(pd.Series(list('abcaa')))a  b  c
0  1  0  0
1  0  1  0
2  0  0  1
3  1  0  0
4  1  0  0

>>> df = pd.DataFrame({'A': ['a', 'b', 'a'], 'B': ['b', 'a', 'c'],
...                    'C': [1, 2, 3]})
>>> pd.get_dummies(df, prefix=['col1', 'col2'])C  col1_a  col1_b  col2_a  col2_b  col2_c
0  1       1       0       0       1       0
1  2       0       1       1       0       0
2  3       1       0       0       0       1

pd.factorize()
相当于label encoding

>>> pd.factorize(pd.Series(list('abcaadedffg')))
(array([0, 1, 2, 0, 0, 3, 4, 3, 5, 5, 6]), Index(['a', 'b', 'c', 'd', 'e', 'f', 'g'], dtype='object'))

对于category特征
for i in trainData.columns[trainData.dtype==‘object’]:
trainData[i]=trainData[i].factorize()[0]
可以简单对trainData进行label encoding

drop_dumplicates()

一般而言我们通常使用drop_dumplicates() 来删除数据中完全重复的数据
但是让我们换一个思路如果对trainData实施转置操作即 trainData.T 然后再进行 drop_dumplicates() 操作
相当于把两列取值完全一一对应的特征删除掉一维
在我们删除完全相关的特征的时候一般使用相关系数但是相关系数对于category类型的数据无法实施
如果使用trainData.T drop_dumplicates 可以解决这个问题

即上述的f2和f3可以通过trainData.T.drop_dumplicates() 删除
但是对于f4和f5 同样的其实两列也是完全重复的因为对于不同的category 取值只是一个代指如果我们重新编码自上到下
f4 : A—>0 B—>1 C---->2 即 0 1 0 2
f5 C---->0 A---->1 B-----2 即 0 1 0 2
所以对于这样的数据也可以
traincopy=trainData
for i in category_columns:
traincopy[i]=traincopy[i].factorize[0]
traincopy.T.drop_dumplicates()

当然上述适用于feature较少的数据如果feature很多则需使用
dup_cols = {}

for i, c1 in enumerate(tqdm_notebook(train_enc.columns)):
for c2 in train_enc.columns[i + 1:]:
if c2 not in dup_cols and np.all(train_enc[c1] == train_enc[c2]):
dup_cols[c2] = c1