데이터 분석을 하다 보면 변수들 간의 척도 (scale) 가 서로 다른 경우 직접적으로 상호 비교를 할 수가 없습니다.  모델링에서는 척도(scale)가 다름으로 인해서 모수의 왜곡이 생길 수도 있습니다.

 

따라서 모델링 작업에 들어가기 전에 변수들 간의 척도가 다른 경우에는 보통 표준화(scale standization)를 진행합니다.

 

표준화 중에서도 모집단이 '정규분포 (normal distribution, Gaussian distribution)을 따르는 경우 평균이 0, 표준편차는 1 인 표준정규분포(standard normal distribution)로 표준화 하는 방법을 많이 사용합니다. 

 

이번 포스팅에서는

 

 - Numpy : z = (x - mean())/std()

 - scipy.stats : zscore()

 - sklearn.preprocessing : StandardScaler().fit_transform()

 

의 모듈, method를 이용한 표준정규분포 표준화 (mean removal and variance scaling, mean = 0, std = 1)에 대해서 소개하겠습니다.

 

 

 

 

실습에 필요한 모듈을 importing하고 예제 Dataset을 만들어보겠습니다.

 

 

In [1]: import numpy as np


In [2]: data = np.random.randint(30, size=(6, 5))


In [3]: data

Out[3]:

array([[ 3,  5, 14, 24, 24],
       [ 3,  9,  1, 20,  3],
       [10,  5, 11, 17, 28],
       [26,  9, 20, 10,  8],
       [15,  7,  1, 24,  2],
       [15, 19, 10, 13,  2]])

 

 

 

표준정규분포로 표준화하는 3가지 방법을 차례대로 소개하겠습니다.

 

 

  (1) Numpy 를 이용한 표준화 : z = (x - mean())/std()

 

칼럼마다 각각의 평균, 표준편차를 적용해서 표준화를 하려면 mean(data, axis=0), std(data, axis=0) 처럼 'axis=0' 을 설정해주면 됩니다.

 

 

# (1) Using numpy, z = (x-mean)/std

In [4]: from numpy import *


In [5]: data_standadized_np = (data - mean(data, axis=0)) / std(data, axis=0)


In [6]: data_standadized_np

Out[6]:

array([[-1.13090555, -0.84016805,  0.66169316,  1.14070365,  1.19426502],
       [-1.13090555,  0.        , -1.24986486,  0.38023455, -0.75998683],
       [-0.25131234, -0.84016805,  0.22056439, -0.19011728,  1.56650347],
       [ 1.75918641,  0.        ,  1.54395071, -1.5209382 , -0.29468877],
       [ 0.37696852, -0.42008403, -1.24986486,  1.14070365, -0.85304644],
       [ 0.37696852,  2.10042013,  0.07352146, -0.95058638, -0.85304644]])

 

# check of 'mean=0', 'standard deviation=1'

In [7]: mean(data_standadized_np, axis=0)

Out[7]:

array([ -5.55111512e-17,   0.00000000e+00,   9.25185854e-18,
         0.00000000e+00,   3.70074342e-17])


In [8]: std(data_standadized_np, axis=0)

Out[8]: array([ 1.,  1.,  1.,  1.,  1.])

 

 

 

 

  (2) scipy.stats 을 이용한 표준화 : ss.zscore()

 

 

# (2) Standardization using zscore() of scipy.stats

In [9]: import scipy.stats as ss


In [10]: data_standadized_ss = ss.zscore(data)


In [11]: data_standadized_ss

Out[11]:

array([[-1.13090555, -0.84016805,  0.66169316,  1.14070365,  1.19426502],
       [-1.13090555,  0.        , -1.24986486,  0.38023455, -0.75998683],
       [-0.25131234, -0.84016805,  0.22056439, -0.19011728,  1.56650347],
       [ 1.75918641,  0.        ,  1.54395071, -1.5209382 , -0.29468877],
       [ 0.37696852, -0.42008403, -1.24986486,  1.14070365, -0.85304644],
       [ 0.37696852,  2.10042013,  0.07352146, -0.95058638, -0.85304644]])

 

 

 

 

  (3) sklearn.preprocessing 을 이용한 표준화 : StandardScaler().fit_transform()

 

 

In [12]: from sklearn.preprocessing import StandardScaler


In [13]: data_standadized_skl = StandardScaler().fit_transform(data)

 

In [14]: data_standadized_skl

Out[14]:

array([[-1.13090555, -0.84016805,  0.66169316,  1.14070365,  1.19426502],
       [-1.13090555,  0.        , -1.24986486,  0.38023455, -0.75998683],
       [-0.25131234, -0.84016805,  0.22056439, -0.19011728,  1.56650347],
       [ 1.75918641,  0.        ,  1.54395071, -1.5209382 , -0.29468877],
       [ 0.37696852, -0.42008403, -1.24986486,  1.14070365, -0.85304644],
       [ 0.37696852,  2.10042013,  0.07352146, -0.95058638, -0.85304644]])

 

 

 

다음번 포스팅에서는 데이터셋에 Outlier 가 들어있을 때 Robust하게 표준화할 수 있는 방법으로서 sklearn.preprocessing.robust_scale, sklearn.preprocessing.RobustScaler 을 소개하겠습니다.

 

많은 도움이 되었기를 바랍니다.

 

 

 

Posted by R Friend R_Friend

지난번 포스팅에서는 중복값 확인, 중복값 처리에 대해서 알아보았습니다.

 

이번 포스팅에서는 유일한 값(unique value)을 찾고 개수도 세어보기 위해서 Python pandas의

 

 - pd.Series.unique() 를 이용한 유일한 값 찾기

   (Return np.ndarray of unique values in the object)

 

 - pd.Series.value_counts() 를 이용한 유일한 값별 개수 세기

   (Returns object containing counts of unique values)

 

를 소개하겠습니다. 

 

 

 

데이터 전처리 및 탐색적 데이터 분석 단계에서 종종 사용하니 알아두면 좋겠습니다.

 

 

먼저, 필요한 모듈 불러오고, 예제 DataFrame을 만들어보겠습니다.

 

 

In [1]: import pandas as pd


In [2]: import numpy as np


In [3]: df = pd.DataFrame({'A': ['A1', 'A1', 'A2', 'A2', 'A3', 'A3'],

   ...: 'B': ['B1', 'B1', 'B1', 'B1', 'B2', np.nan],

   ...: 'C': [1, 1, 3, 4, 4, 4]})


In [4]: df

Out[4]:

    A    B  C
0  A1   B1  1
1  A1   B1  1
2  A2   B1  3
3  A2   B1  4
4  A3   B2  4
5  A3  NaN  4

 

 

 

 

  (1) 유일한 값 찾기 : pd.Series.unique()

 

pd.Series.unique()는 np.ndarray를 반환합니다. DataFrame의 각 칼럼별로 indexing해서 unique()를 적용한 결과는 아래와 같습니다.

 

'B' 칼럼에 'NaN'도 unique()에 포함되었습니다.

 

 

In [5]: df['A'].unique()

Out[5]: array(['A1', 'A2', 'A3'], dtype=object)


In [6]: df['B'].unique()

Out[6]: array(['B1', 'B2', nan], dtype=object)


In [7]: df['C'].unique()

Out[7]: array([1, 3, 4], dtype=int64)

 

 

 

 

  (2) 유일한 값별로 개수 세기 : pd.Series.value_counts()

 

 

# eturns object containing counts of unique values

pd.Series.value_counts(normalize=False, # False면 개수, True면 상대 비율 구함

                              sort=True, # True면 개수 기준 정렬, False면 유일한 값 기준 정렬

                              ascending=False, # False면 내림차순 정렬, True면 오름차순 정렬

                          bins=None, # None이면 유일값 기준 개수, None아니면 Bins Group별 개수

                              dropna=True # True면 NaN 무시, False면 유일값에 NaN 포함)

 

 

 

 

In [4]: df

Out[4]:

    A    B  C
0  A1   B1  1
1  A1   B1  1
2  A2   B1  3
3  A2   B1  4
4  A3   B2  4
5  A3  NaN  4

 

# returns of pd.Series.value_counts() by default setting

In [8]: df['A'].value_counts()

Out[8]:

A3    2
A2    2
A1    2

Name: A, dtype: int64


In [9]: df['B'].value_counts()

Out[9]:

B1    4
B2    1

Name: B, dtype: int64


In [10]: df['C'].value_counts()

Out[10]:

4    3
1    2
3    1

Name: C, dtype: int64

 

 

 

 

  (2-1) 유일 값 별 상대적 비율 : pd.Series.value_counts(normalize=True)

 

 

In [4]: df

Out[4]:

    A    B   C
0  A1   B1  1
1  A1   B1  1
2  A2   B1  3
3  A2   B1  4
4  A3   B2  4
5  A3  NaN  4

 

In [11]: df['C'].value_counts(normalize=True)

Out[11]:

4    0.500000
1    0.333333
3    0.166667

Name: C, dtype: float64

 

 

 

 

  (2-2) 유일한 값 기준 정렬 : pd.Series.value_counts(sort=True, ascending=True)

 

sort=True, False 와 ascending=True, False 의 조합은 아래 예시의 3가지 경우의 수가 있습니다. 

 

[12] : 유일한 값의 개수 기준 내림차순 정렬 예시 (sort descending order by value_counts)

[13] : 유일한 값의 개수 기준 오름차순 정렬 예시 (sort ascending order by value_counts)

[14] : 유일한 값 기준 오름차순 정렬 예시 (유일한 값의 개수 기준 정렬은 없음)

 

 

In [4]: df

Out[4]:

    A    B   C
0  A1   B1  1
1  A1   B1  1
2  A2   B1  3
3  A2   B1  4
4  A3   B2  4
5  A3  NaN  4

 

# sort descending order by value_counts

In [12]: df['C'].value_counts(sort=True, ascending=False) # by default

Out[12]:

4    3
1    2
3    1

Name: C, dtype: int64

 

# sort ascending order by value_counts

In [13]: df['C'].value_counts(sort=True, ascending=True)

Out[13]:

3    1
1    2
4    3

Name: C, dtype: int64

 

# Don't sort by value_counts, but sort by unique value

In [14]: df['C'].value_counts(sort=False)

Out[14]:

1    2
3    1
4    3

Name: C, dtype: int64

 

 

 

 

  (2-3) 결측값을 유일한 값에 포함할지 여부 : pd.Series.value_counts(dropna=True)

 

 

In [4]: df

Out[4]:

    A    B   C
0  A1   B1  1
1  A1   B1  1
2  A2   B1  3
3  A2   B1  4
4  A3   B2  4
5  A3  NaN  4

 

# dropna=True : Don’t include counts of NaN

In [15]: df['B'].value_counts(dropna=True) # by default

Out[15]:

B1    4
B2    1

Name: B, dtype: int64

 

# dropna=False : Include counts of NaN

In [16]: df['B'].value_counts(dropna=False)

Out[16]:

B1     4
B2     1
NaN    1

Name: B, dtype: int64

 

 

 

 

  (2-4) Bins Group별 값 개수 세기 : pd.Series.value_counts(bins=[ , , ,])

 

 

In [4]: df

Out[4]:

    A    B   C
0  A1   B1  1
1  A1   B1  1
2  A2   B1  3
3  A2   B1  4
4  A3   B2  4
5  A3  NaN  4

 

In [17]: df['C'].value_counts(bins=[0, 1, 2, 3, 4, 5], sort=False)

Out[17]:

0 2

1 0

2 1

3 3

4 0

Name: C, dtype: int64

 

 

 

아래의 pd.cut(Series, bins=[ , , , ]) 와 위의 결과가 동일하며, 위의 Series.value_counts(bins=[ , , , ])가 조금 더 사용하기 편리합니다.

 

 

In [18]: out = pd.cut(df['C'], bins=[0, 1, 2, 3, 4, 5])


In [19]: pd.value_counts(out)

Out[19]:

(3, 4] 3

(0, 1] 2

(2, 3] 1

(4, 5] 0

(1, 2] 0

Name: C, dtype: int64

 

 

 

많은 도움 되었기를 바랍니다.

 

 

Posted by R Friend R_Friend

데이터를 수집하는 과정 중의 오류, 데이터를 병합하는 과정에서의 오류 등으로 인해서 중복되지 않아야 할 데이터가 중복이 되는 경우가 생길 수 있습니다.

 

특히, unique 한 'key' 값을 관리해야 하는 경우 중복(duplicates)이 발생하면 분석에 심각한 영향을 끼칠 수도 있습니다.  (관계형 DB라면 아례 데이터가 들어가지도 않겠지요...)

 

따라서 본격적인 데이터 분석에 들어가기 전에 반드시, 꼭, 예외없이, 무조건, Seriously 중복 데이터를 확인하고 처리하는 전처리 작업이 필요합니다.  (가령, 두 개의 DataFrame을 Left Join 으로 Merge했더니 row의 개수가 늘어났다 하면 그건 병합하는 DataFrame의 'key' 값에 중복이 있다는 얘기거든요.)

 

데이터 개수가 몇 개 안되면 눈으로 확인하고 중복 데이터 위치 indexing 해서 처리하면 되는데요, 데이터 개수가 많으면 육안으로 일일이 확인한다는게 사실상 불가능해집니다.

 

이때 중복이 존재하는지 확인할 때 사용할 수 있는 것이 Python pandas의 duplicated() method 입니다.  그리고 중복값을 처리하는 것이 drop_duplicates() method 이구요.

 

 - 중복 여부 확인 : DataFrame.duplicated()

 - 중복이 있으면 처음과 마지막 값 중 무엇을 남길 것인가? : keep = 'first', 'last', False

 - 중복값 처리(unique한 1개의 key만 남기고 나머지 중복은 제거) : DataFrame.drop_duplicates()

 

 

 

 

먼저 pandas 모듈을 불러오고, 예제로 사용할 '중복(duplicate entries)'이 있는 DataFrame을 만들어보겠습니다.

 

 

In [1]: import pandas as pd


In [2]: data = {'key1':['a', 'b', 'b', 'c', 'c'],

   ...: 'key2':['v', 'w', 'w', 'x', 'y'],

   ...: 'col':[1, 2, 3, 4, 5]}


In [3]: df = pd.DataFrame(data, columns=['key1','key2','col'])


In [4]: df

Out[4]:

  key1 key2  col
0    a    v    1
1    b    w    2
2    b    w    3
3    c    x    4
4    c    y    5

 

 

 

 

  (1) 중복 데이터가 있는지 확인하기 : DataFrame.duplicated()

 

'key1'을 기준으로 하면 index 1, 2 ('b')가 중복, index 3, 4 ('c')가 서로 중복입니다.

'key1'과 'key2'를 동시에 기준으로 하면 index 1, 2 ('b', 'w') 가 서로 중복입니다.

 

DataFrame.duplicated() method는 True, False 의 boolean 형태의 Series를 반환합니다.

 

 

In [5]: df.duplicated(['key1'])

Out[5]:

0    False
1    False
2     True
3    False
4     True
dtype: bool


In [6]: df.duplicated(['key1', 'key2'])

Out[6]:

0    False
1    False
2     True
3    False
4    False
dtype: bool

 

 

 

 

  (2) 중복이 있으면 처음과 끝 중 무슨 값을 남길 것인가? : keep = 'first', 'last', False

 

keep='first'가 default 이며, 중복값이 있으면 첫번째 값을 duplicated 여부를 False로 반환하고, 나머지 중복값에 대해서는 True를 반환하게 됩니다. keep='last'는 그 반대이겠지요.

 

keep=False는 처음이나 끝값인지 여부는 고려를 안하고 중복이면 무조건 True를 반환합니다 (=> 나중에 drop_duplicates() 에서 keep 할 생각이 없다는 뜻입니다).

 

 

In [7]: df.duplicated(['key1'], keep='first') # by default

Out[7]:

0    False
1    False
2     True
3    False
4     True
dtype: bool


 

In [8]: df.duplicated(['key1'], keep='last')

Out[8]:

0    False
1     True
2    False

3     True
4    False
dtype: bool

 

 

In [9]: df.duplicated(['key1'], keep=False)

Out[9]:

0    False
1     True
2     True
3     True
4     True

dtype: bool

 

 

 

 

  (3) 중복값 처리(unique한 1개의 key만 남기고 나머지 중복은 제거) 

       : DataFrame.drop_duplicates()

 

drop_duplicates() method는 중복값을 keep='first', 'last', False argument에 따라서 unique한 1개의 key값만 남기고 나머지 중복은 제거를 한 후의 DataFrame을 반환합니다.

 

 

# drop duplic

In [10]: df.drop_duplicates(['key1'], keep='first')

Out[10]:

  key1 key2  col
0    a    v    1
1    b    w    2
3    c    x    4


In [11]: df.drop_duplicates(['key1'], keep='last')

Out[11]:

  key1 key2  col
0    a    v    1
2    b    w    3
4    c    y    5


In [12]: df.drop_duplicates(['key1'], keep=False)

Out[12]:

  key1 key2  col
0    a    v    1

 

 

 

이상으로 중복 여부 확인, 중복값 처리를 위한 Python pandas의 DataFrame.duplicated(), DataFrame.drop_duplicates() method에 대한 소개를 마치겠습니다.

 


많은 도움 되었기를 바랍니다.

 

 

 

Posted by R Friend R_Friend

지난번 포스팅에서는 Python pandas의

 

 - fillna() method를 사용한 결측값 대체

 - dropna() method를 사용한 결측값 있는 행, 열 제거

 - interpolate() method를 사용한 결측값 보간

 

하는 방법을 알아보았습니다.

 

이번 포스팅에서는 Python pandas의 replace() method를 사용해서

 

 - 결측값 혹은 원래의 값을 다른 값으로 교체(replacing generic values)

 - List 를 다른 List로 교체

 - mapping dict 로 교체

 - DataFrame의 특정 칼럼 값 교체

 

하는 방법을 소개하겠습니다.

 

fillna() 를 사용한 결측값 대체와 replace()를 사용한 결측값 교체가 유사한면이 있구요, 다만 replace() 는 결측값 말고도 모든 값을 대상으로 할 수 있고, list, mapping dict 등으로 좀더 유연하고 포괄적으로 사용할 수 있는 장점이 있습니다.

 

 

 

 

replace() method를 가지고 결측값, 실측값 모두를 대상으로 교체(replacement)하는 예를 들어보겠습니다.  필요한 모듈을 importing하고, 결측값을 포함한 간단한 Series 먼저 시작하겠습니다.

 

 

In [1]: import pandas as pd


In [2]: import numpy as np


In [3]: from pandas import DataFrame, Series

 

In [4]: ser = Series([1, 2, 3, 4, np.nan])

 

In [5]: ser

Out[5]:

0    1.0
1    2.0
2    3.0
3    4.0
4    NaN
dtype: float64

 

 

 

 

  (1) 결측값, 실측값을 다른 값으로 교체하기 : replace(old_val, new_val)

 

 

# replacing a value with other value

In [6]: ser.replace(2, 20)

Out[6]:

0     1.0
1    20.0
2     3.0
3     4.0
4     NaN
dtype: float64

 

# replacing missing value(NaN) with other value

In [7]: ser.replace(np.nan, 5)

Out[7]:

0    1.0
1    2.0
2    3.0
3    4.0
4    5.0
dtype: float64

 

 

 

 

 

  (2) list 를 다른 list 값으로 교체하기 : replace([old1, old2, ...], [new1, new2, ...])

 

 

In [8]: ser

Out[8]:

0    1.0
1    2.0
2    3.0
3    4.0
4    NaN
dtype: float64

 

In [9]: ser.replace([1, 2, 3, 4, np.nan], [6, 7, 8, 9, 10])

Out[9]:

0     6.0
1     7.0
2     8.0
3     9.0
4    10.0
dtype: float64

 

 

 

 

  (3) mapping dict 로 원래 값, 교체할 값 매핑 : replace({old1 : new1, old2: new2})

 

 

In [10]: ser

Out[10]:

0    1.0
1    2.0
2    3.0
3    4.0
4    NaN
dtype: float64

 

In [11]: ser.replace({1: 6,

    ...: 2: 7,

    ...: 3: 8,

    ...: 4: 9,

    ...: np.nan: 10})

Out[11]:

0     6.0
1     7.0
2     8.0
3     9.0
4    10.0
dtype: float64

 

 

 

 

  (4) DataFrame의 특정 칼럼 값 교체하기 : df.replace({'col1': old_val}, {'col1': new_val})

 

DataFrame 의 값을 교체하려면 dict { } 안에 원래와 교체할 'column name'과 'value' 를 짝을 이루어서 매핑해주면 됩니다.

 

 

In [13]: df = DataFrame({'C1': ['a_old', 'b', 'c', 'd', 'e'],

    ...: 'C2': [1, 2, 3, 4, 5],

    ...: 'C3': [6, 7, 8, 9, np.nan]})


In [14]: df

Out[14]:

      C1  C2   C3
a_old   1  6.0
1      b   2  7.0
2      c   3  8.0
3      d   4  9.0
4      e   5  NaN

 

In [15]: df.replace({'C1': 'a_old'}, {'C1': 'a_new'})

Out[15]:

      C1  C2   C3
a_new   1  6.0
1      b   2  7.0
2      c   3  8.0
3      d   4  9.0
4      e   5  NaN


In [16]: df.replace({'C3': np.nan}, {'C3': 10})

Out[16]:

      C1  C2    C3
0  a_old   1   6.0
1      b   2   7.0
2      c   3   8.0
3      d   4   9.0
4      e   5  10.0

 

 

 

이상으로 Python pandas의 replace() method를 사용해서 결측값, 원래 값을 다른 값으로 교체하기 소개를 마치겠습니다.

 

결측값을 그룹별로 그룹별 평균으로 대체하기는 http://rfriend.tistory.com/402 를 참고하세요. 


많은 도움이 되었기를 바랍니다.

 

 

 

Posted by R Friend R_Friend

지난번 포스팅에서는 Python pandas 의 dropna() method를 사용해서

 

 - 결측값이 들어있는 행 전체 제거하기

 - 결측값이 들어있는 열 전체 제거하기

 

방법을 알아보았습니다.

 

 

이번 포스팅에서는 Python pondas의 interpolate() method를 사용해서 결측값을 보간하는 방법(interpolation of missing values)에 대해서 소개하겠습니다.

 

 - (1) 시계열데이터의 값에 선형으로 비례하는 방식으로 결측값 보간

       (interpolate TimeSeries missing values linearly)

 - (2) 시계열 날짜 index를 기준으로 결측값 보간

       (interploate TimeSeries missing values along with Time-index)

 - (3) DataFrame 값에 선형으로 비례하는 방식으로 결측값 보간

       (interpolate DataFrame missing values linearly)

 - (4) 결측값 보간 개수 제한하기

       (limit the number of consecutive interpolation)

 

시계열 데이터 분석이라든지 이미지 분석 등에서 사용하면 매우 유용하고 편리한 method 입니다.

 

이전 포스팅의 결측값 대체는 '특정의 동일 값'으로 채우는 방식(filling, imputation)이었던 반면에, 이번 포스팅의 결측값 보간(interploation)은 실측값과 실측값 사이의 결측값을 마치 '그라데이션(gradation)' 기법으로 색깔을 조금씩 변화시켜가면서 부드럽게 채워나가는 방법이라고 이해하시면 되겠습니다.

 

 

 

자, 그럼 필요한 모듈을 import 하고, 결측값이 들어있는 TimeSeries 데이터를 만든 후에, 결측값을 보간해보겠습니다.

 

  (1) 시계열데이터의 값에 선형으로 비례하는 방식으로 결측값 보간

       (interpolate TimeSeries missing values linearly) : ts.interpolate()

 

 

# importing modules 

In [1]: import pandas as pd


In [2]: import numpy as np


In [3]: from pandas import DataFrame, Series


In [4]: from datetime import datetime

 

# making TimeSeries with missing values

In [5]: datestrs = ['12/1/2016', '12/03/2016', '12/04/2016', '12/10/2016']


In [6]: dates = pd.to_datetime(datestrs)


In [7]: dates

Out[7]: DatetimeIndex(['2016-12-01', '2016-12-03', '2016-12-04', '2016-12-10'], dtype='datetime64[ns]', freq=None)


In [8]: ts = Series([1, np.nan, np.nan, 10], index=dates)

 

In [9]: ts

Out[9]:

2016-12-01     1.0
2016-12-03     NaN
2016-12-04     NaN

2016-12-10    10.0
dtype: float64

 

 

 

ts.interpolote() 는 default 가 interpolate(method='values')로서 선형으로 비례하여 결측값을 보간해줍니다.

 

 

# interpolate missing values linearly 

In [10]: ts_intp_linear = ts.interpolate()

 

In [11]: ts_intp_linear

Out[11]:

2016-12-01     1.0
2016-12-03     4.0
2016-12-04     7.0
2016-12-10    10.0

 

 

 

 

  (2) 시계열 날짜 index를 기준으로 결측값 보간

       (interploate TimeSeries missing values along with Time-index)

       : ts.interploate(method='time')

 

위의 ts.interpolate() 결과와 아래의 ts.interpolate(method='time') 보간 결과를 유심히 비교해보시기 바랍니다.

 

 

In [12]: ts

Out[12]:

2016-12-01     1.0
2016-12-03     NaN
2016-12-04     NaN
2016-12-10    10.0

dtype: float64

 

In [13]: ts_intp_time = ts.interpolate(method='time')

 

In [14]: ts_intp_time

Out[14]:

2016-12-01     1.0
2016-12-03     3.0
2016-12-04     4.0
2016-12-10    10.0
dtype: float64

 

 

 

 

  (3) DataFrame 값에 선형으로 비례하는 방식으로 결측값 보간

      (interpolate DataFrame missing values linearly)

 

 

In [15]: df = DataFrame({'C1': [1, 2, np.nan, np.nan, 5],

    ...: 'C2': [6, 8, 10, np.nan, 20]})

    ...:

 

In [16]: df

Out[16]:

    C1    C2
0  1.0   6.0
1  2.0   8.0
NaN  10.0
NaN   NaN
4  5.0  20.0

 

In [17]: df_intp_values = df.interpolate(method='values')

 

In [18]: df_intp_values

Out[18]:

    C1    C2
0  1.0   6.0
1  2.0   8.0
3.0  10.0
4.0  15.0
4  5.0  20.0

 

# the same with : df.interpolate(method='values') = df.interpolate()

In [19]: df.interpolate() # by default : method='values'

Out[19]:

    C1    C2
0  1.0   6.0
1  2.0   8.0
3.0  10.0
4.0  15.0
4  5.0  20.0

 

 

 

 

 (4) 결측값 보간 개수 제한하기 (limit the number of consecutive interpolation) : limit

 

연속적으로 결측값을 보간하는 개수를 'limit=1'을 사용해서 제한해보겠습니다.  아래 예시처럼 df.ix[3, 'C1']의 NaN이 보간되지 않고 NaN 그대로 남아있습니다.

 

 

In [20]: df.interpolate(method='values', limit=1)

Out[20]:

    C1    C2
0  1.0   6.0
1  2.0   8.0
3.0  10.0
NaN  15.0
4  5.0  20.0

 

 

 

 

limit_direction='backward' 로 설정해주면 보간해주는 방향이 밑에서 위로 올라가면서 해주게 됩니다.

(아무런 설정을 안해주면 default 로 limit_direction='forward' 설정됨.  limit_direction='both' 도 있음)

 

 

In [29]: df.interpolate(method='values', limit=1, limit_direction='backward')

Out[29]:

    C1    C2
0  1.0   6.0
1  2.0   8.0
NaN  10.0
4.0  15.0
4  5.0  20.0

 

 

 

이상으로 Python pandas 의 interpolate() method를 활용한 결측값 보간법을 마치도록 하겠습니다.

 

많은 도움 되었기를 바랍니다.

 

Posted by R Friend R_Friend

지난번 포스팅에서는 Python pandas의 fillna() method를 사용한

 

 - 결측값 여부 확인하기

 - 결측값 채우기, 결측값 대체하기

 

에 대해서 알아보았습니다.

 

이번 포스팅에서는 Python pandas의 dropna() method를 사용해서

 

 - 결측값이 들어있는 행 전체 제거

   (delete row with missing values)

 - 결측값이 들어있는 열 전체를 제거

   (delete column with missing values)

 - 특정 행 또는 열 만을 대상으로 결측값이 들어있으면 제거

   (delete specific row or column with missing values)

 

하는 방법을 소개하겠습니다.

 

관측값이 아주 많고 결측값이 별로 없는 경우에는 결측값이 들어있는 행 전체를 삭제하고 분석을 진행해도 무리가 없고 편리할 수 있습니다.

 

혹은 특정 변수의 결측값 비율이 매우 높고, 결측값을 채워넣을 만한 마땅한 방법이 없는 경우에는 분석의 신뢰성 확보를 위해서 그 변수(행, 칼럼)을 삭제하고 분석을 진행할 필요도 있습니다.

 

이때 dropna() method 를 사용하면 됩니다.

 

 

 

 

먼저, 필요한 모듈을 불러오고, 결측값(None 또는 np.nan)이 들어있는 DataFrame을 만들어보겠습니다.

 

 

# importing modules

In [1]: import pandas as pd


In [2]: import numpy as np


In [3]: from pandas import DataFrame

 

# making DataFrame

In [4]: df = DataFrame(np.random.randn(5, 4),

   ...: columns=['C1', 'C2', 'C3', 'C4'])


In [5]: df

Out[5]:

         C1        C2        C3        C4
0 -0.336659 -0.738247  0.598380  0.727832
1 -0.900631  0.073079  1.182290 -0.138224
2 -1.521049 -1.422940  0.330948 -0.275343
3  0.554677 -0.530208 -0.397182  0.990026
4 -0.332384 -1.979684  0.560655  0.833487

 

# inserting missing values

In [6]: df.ix[[0,1], 'C1'] = None


In [7]: df.ix[2, 'C2'] = np.nan


In [8]: df

Out[8]:

         C1        C2        C3        C4
0       NaN -0.738247  0.598380  0.727832
1       NaN  0.073079  1.182290 -0.138224
2 -1.521049       NaN  0.330948 -0.275343
3  0.554677 -0.530208 -0.397182  0.990026
4 -0.332384 -1.979684  0.560655  0.833487

 

 

 

 

 

이제 dropna() method를 사용해서 결측값이 들어있는 행 전체(axis = 0) 삭제, 혹은 결측값이 들어있는 열 전체(axis=1) 삭제해 보겠습니다.

 

 

  (1) 결측값이 들어있는 행 전체 삭제하기(delete row with NaN) : df.dropna(axis=0)

 

 

# delete row with missing values

In [9]: df_dr

df_dop_row = df.dropna(axis=0)


In [10]: df_drop_row

Out[10]:

C1 C2 C3 C4

         C1        C2        C3        C4
3  0.554677 -0.530208 -0.397182  0.990026
4 -0.332384 -1.979684  0.560655  0.833487

 

 

 

 

  (2) 결측값이 들어있는 열 전체 삭제하기 (delete column with NaN) : df.dropna(axis=1)

 

 

In [8]: df

Out[8]:

         C1        C2        C3        C4
0       NaN -0.738247  0.598380  0.727832
1       NaN  0.073079  1.182290 -0.138224
2 -1.521049       NaN  0.330948 -0.275343
3  0.554677 -0.530208 -0.397182  0.990026
4 -0.332384 -1.979684  0.560655  0.833487

 

# delete column with missing values

In [11]: df_drop_column = df.dropna(axis=1)


In [12]: df_drop_column

Out[12]:

         C3        C4
0  0.598380  0.727832
1  1.182290 -0.138224
2  0.330948 -0.275343
3 -0.397182  0.990026
4  0.560655  0.833487

 

 

 

 

  (3) 특정 행 또는 열을 대상으로 결측값이 들어있으면 제거

       (delete specific row or column with missing values) : df[ ].dropna()

 

DataFrame의 행 또는 열을 indexing 한 후에 dropna() method를 적용하면 됩니다.  dropna() 와 dropna(axis=0)은 동일합니다 (즉, axis=0 은 생략 가능).

 

아래에 4가지의 예를 들어보았습니다.  원래의 df DataFrame을 어떻게 indexing 하느냐에 따라 결측값이 들어있는 행과 열이 제거되는지 유심히 살펴보시면 금방 이해가 될거예요.

 

 

In [8]: df

Out[8]:

         C1        C2        C3        C4
0       NaN -0.738247  0.598380  0.727832
1       NaN  0.073079  1.182290 -0.138224
2 -1.521049       NaN  0.330948 -0.275343
3  0.554677 -0.530208 -0.397182  0.990026
4 -0.332384 -1.979684  0.560655  0.833487

 

# delete specific column with missing values

In [13]: df['C1'].dropna()

Out[13]:

2   -1.521049
3    0.554677
4   -0.332384
Name: C1, dtype: float64


In [14]: df[['C1', 'C2', 'C3']].dropna() # the same with dropna(axis=0)

Out[14]:

         C1        C2        C3
3  0.554677 -0.530208 -0.397182
4 -0.332384 -1.979684  0.560655


In [15]: df[['C1', 'C2', 'C3']].dropna(axis=0) # by default, the same with dropna()

Out[15]:

         C1        C2        C3
3  0.554677 -0.530208 -0.397182
4 -0.332384 -1.979684  0.560655


In [16]: df[['C1', 'C2', 'C3']].dropna(axis=1)

Out[16]:

         C3
0  0.598380
1  1.182290
2  0.330948
3 -0.397182
4  0.560655

 

 

In [17]: df.ix[[2, 4], ['C1', 'C2', 'C3']].dropna(axis=0)

Out[17]:

         C1        C2        C3
4 -0.332384 -1.979684  0.560655

 

 

 

마지막으로 첨언하자면, 결측값이 들어있는 행 전체, 혹은 열 전체를 삭제하는 것은 데이터 소실, 혹은 데이터 모집단 왜곡의 위험도 있는 만큼 분석에 영향도를 한번 생각해보고 나서 결정하시면 좋겠습니다.

 

그리고 만약을 대비해서 원본 데이터 (source data)는 그대로 남겨 놓은 상태에서 행 삭제 혹은 열 삭제 후의 DataFrame은 다른 이름으로 copy 해서 사용하실 것을 권합니다. 

 

다음번 포스팅에서는 결측값 보간(interpolation)에 대해서 알아보겠습니다.

 

많은 도움 되었기를 바랍니다.

 

 

 

Posted by R Friend R_Friend

지난번 포스팅에서는 결측값 여부 확인, 결측값 개수 세기 등을 해보았습니다.

 

이번 포스팅에서는 결측값을 채우고 대체하는 다양한 방법들로서,

 

 - 결측값을 특정 값으로 채우기

   (replace missing valeus with scalar value)

 

 - 결측값을 앞 방향 혹은 뒷 방향으로 채우기

   (fill gaps forward or backward)

 

 - 결측값 채우는 회수를 제한하기

   (limit the amount of filling)

 

 - 결측값을 변수별 평균으로 대체하기

   (filling missing values with mean value per columns)

 

 - 결측값을 다른 변수의 값으로 대체하기

   (filling missing values with another columns' values)

 

등에 대해서 알아보도록 하겠습니다.  모델링에 들어가기 전에 결측값을 확인하고 결측값을 처리하는 절차가 반드시 필요하고 매우 중요한 부분입니다. 

 

 

 

 

 

먼저 필요한 pandas, numpy 모듈을 불러오고, 결측값(missing values)을 포함하고 있는 DataFrame을 만들어보겠습니다.  결측값은 df.ix[x, y] 에 None 또는 np.nan 을 할당해주면 됩니다.

 

 

#%% missing value imputation, filling missing value

## importing modules

 

In [1]: import pandas as pd


In [2]: import numpy as np

 

## making DataFrame

In [3]: df = pd.DataFrame(np.random.randn(5, 3),

   ...: columns=['C1', 'C2', 'C3'])

   ...:


In [4]: df

Out[4]:

         C1        C2        C3
0 -0.905421 -0.228791 -0.850988
1  0.558819  0.564767  0.232641
2 -0.834515 -0.204626 -0.566917
3  0.242694 -0.317098 -0.673298
4 -0.497041 -0.301435 -1.265128


In [5]: df.ix[0, 0] = None


In [6]: df.ix[1, ['C1', 'C3']] = np.nan


In [7]: df.ix[2, 'C2'] = np.nan


In [8]: df.ix[3, 'C2'] = np.nan


In [9]: df.ix[4, 'C3'] = np.nan


In [10]: df

Out[10]:

         C1        C2        C3
0       NaN -0.228791 -0.850988
1       NaN  0.564767       NaN
2 -0.834515       NaN -0.566917
3  0.242694       NaN -0.673298
4 -0.497041 -0.301435       NaN

 

 

 

 

  (1) 결측값을 특정 값으로 채우기 (replace missing values with scalar value) : df.fillna(0)

 

결측값을 '0' 으로 대체해보겠습니다.

 

 

In [11]: df_0 = df.fillna(0)


In [12]: df_0

Out[12]:

         C1        C2        C3
0.000000 -0.228791 -0.850988
0.000000  0.564767  0.000000
2 -0.834515  0.000000 -0.566917
3  0.242694  0.000000 -0.673298
4 -0.497041 -0.301435  0.000000

 

 

 

 

이번에는 결측값을 'missing' 이라는 string 값으로 채워보겠습니다.

 

 

In [13]: df_missing = df.fillna('missing')


In [14]: df_missing

Out[14]:

C1 C2 C3

         C1        C2        C3
0   missing -0.228791 -0.850988
1   missing  0.564767   missing
2 -0.834515   missing -0.566917
3  0.242694   missing -0.673298
4 -0.497041 -0.301435   missing

 

 

 

 

  (2) 결측값을 앞 방향 혹은 뒷 방향으로 채우기 (fill gaps forward or backward)

      : fillna(method='ffill' or 'pad'), fillna(method='bfill' or 'backfill')

 

(2-) 결측값을 앞 방향으로 채워나가려면(fill gaps forward) fillna(method='ffill') 혹은 fillna(method='pad') 를 사용하면 됩니다.

 

 

In [10]: df

Out[10]:

          C1        C2        C3
0       NaN -0.228791 -0.850988
1       NaN  0.564767       NaN
2 -0.834515       NaN -0.566917
3  0.242694       NaN -0.673298
4 -0.497041 -0.301435       NaN

 

In [15]: df.fillna(method='ffill') # Fill values forward

Out[15]:

         C1        C2        C3
0       NaN -0.228791 -0.850988
1       NaN  0.564767 -0.850988
2 -0.834515  0.564767 -0.566917
3  0.242694  0.564767 -0.673298
4 -0.497041 -0.301435 -0.673298


In [16]: df.fillna(method='pad') # Fill values forward

Out[16]:

         C1        C2        C3
0       NaN -0.228791 -0.850988
1       NaN  0.564767 -0.850988
2 -0.834515  0.564767 -0.566917
3  0.242694  0.564767 -0.673298
4 -0.497041 -0.301435 -0.673298

 

 

 

 

다음은 (2-2) 결측값을 뒷 방향으로 채워나가기 위해 fillna(method='bfill') 혹은 fillna(method='backfill')을 사용한 예시의 결과입니다.

 

 

In [10]: df

Out[10]:

         C1        C2        C3
0       NaN -0.228791 -0.850988
1       NaN  0.564767       NaN
2 -0.834515       NaN -0.566917
3  0.242694       NaN -0.673298
4 -0.497041 -0.301435       NaN

 

In [17]: df.fillna(method='bfill') # Fill values backward

Out[17]:

         C1        C2        C3
0 -0.834515 -0.228791 -0.850988
1 -0.834515  0.564767 -0.566917
2 -0.834515 -0.301435 -0.566917
3  0.242694 -0.301435 -0.673298
4 -0.497041 -0.301435       NaN


In [18]: df.fillna(method='backfill') # Fill values backward

Out[18]:

         C1        C2        C3
0 -0.834515 -0.228791 -0.850988
1 -0.834515  0.564767 -0.566917
2 -0.834515 -0.301435 -0.566917
3  0.242694 -0.301435 -0.673298
4 -0.497041 -0.301435       NaN

 

 

 

 

  (3) 앞/뒤 방향으로 결측값 채우는 회수를 제한하기 (limit the amount of filling)

     : fillna(method='ffill', limit=number), fillna(method='bfill', limit=number)

 

앞 방향이나 뒷 방향으로 채워나갈 때 fillna(limit=1) 를 사용해서 결측값 채우는 '개수'를 '1'개로 한정해 보겠습니다.  시계열 데이터 분석할 때 유용하게 사용하는 기능 중의 하나입니다.  

 

아래 예에서 빨간색으로 밑줄 친 부분을 유심히 살펴보시면 이해하기 편하실 거예요.

 

 

In [10]: df

Out[10]:

         C1        C2        C3
0       NaN -0.228791 -0.850988
1       NaN  0.564767       NaN
2 -0.834515       NaN -0.566917
3  0.242694       NaN -0.673298
4 -0.497041 -0.301435       NaN

 

In [19]: df.fillna(method='ffill', limit=1) # fill values forward with limit

Out[19]:

         C1        C2        C3
0       NaN -0.228791 -0.850988
1       NaN  0.564767 -0.850988
2 -0.834515  0.564767 -0.566917
3  0.242694       NaN -0.673298
4 -0.497041 -0.301435 -0.673298


In [20]: df.fillna(method='bfill', limit=1) # fill values backward with limit

Out[20]:

         C1        C2        C3
0       NaN -0.228791 -0.850988
1 -0.834515  0.564767 -0.566917
2 -0.834515       NaN -0.566917
3  0.242694 -0.301435 -0.673298
4 -0.497041 -0.301435       NaN

 

 

 

 

  (4) 결측값을 변수별 평균으로 대체하기(filling missing values with mean per columns)

      : df.fillna(df.mean()), df.where(pd.notnull(df), df.mean(), axis='columns')

 

 

In [10]: df

Out[10]:

         C1        C2        C3
0       NaN -0.228791 -0.850988
1       NaN  0.564767       NaN
2 -0.834515       NaN -0.566917
3  0.242694       NaN -0.673298
4 -0.497041 -0.301435       NaN

 

# mean per columns

In [21]: df.mean()

Out[21]:

C1 -0.362954

C2 0.011514

C3 -0.697068

dtype: float64

 

# filling missing values with mean per columns

# way 1

In [22]: df.fillna(df.mean())

Out[22]:

         C1        C2        C3
0 -0.362954 -0.228791 -0.850988
1 -0.362954  0.564767 -0.697068
2 -0.834515  0.011514 -0.566917
3  0.242694  0.011514 -0.673298
4 -0.497041 -0.301435 -0.697068

 

# way 2

In [23]: df.where(pd.notnull(df), df.mean(), axis='columns')

Out[23]:

         C1        C2        C3
0 -0.362954 -0.228791 -0.850988
1 -0.362954  0.564767 -0.697068
2 -0.834515  0.011514 -0.566917
3  0.242694  0.011514 -0.673298
4 -0.497041 -0.301435 -0.697068

 

 

 

위의 예시는 각 칼럼의 평균으로 -> 각 칼럼의 결측값을 대체하는 방식이었습니다.

아래 예시는 'C1' 칼럼의 평균을 가지고 'C1', 'C2', 'C3' 칼럼의 결측값을 대체하는 방법입니다.

 

 

In [24]: df.mean()['C1']

Out[24]: -0.36295411360962238


In [25]: df.fillna(df.mean()['C1'])

Out[25]:

         C1        C2        C3
0 -0.362954 -0.228791 -0.850988
1 -0.362954  0.564767 -0.362954
2 -0.834515 -0.362954 -0.566917
3  0.242694 -0.362954 -0.673298
4 -0.497041 -0.301435 -0.362954

 

 

 

 

아래의 예시는 'C1'칼럼과 'C2' 칼럼에 대해서만 각 칼럼의 평균을 가지고 -> 각 칼럼에 있는 대체값을 대체하는 경우입니다.  좀 헷갈릴 수 있는데요, 위의 2개의 예시의 혼합 형태라고 보시면 되겠습니다.

('C3'의 NaN 값은 결측값 그대로 있습니다.)

 

 

In [26]: df.mean()['C1':'C2']

Out[26]:

C1   -0.362954
C2    0.011514
dtype: float64


In [27]: df.fillna(df.mean()['C1':'C2'])

Out[27]:

         C1        C2        C3
0 -0.362954 -0.228791 -0.850988
1 -0.362954  0.564767       NaN
2 -0.834515  0.011514 -0.566917
3  0.242694  0.011514 -0.673298
4 -0.497041 -0.301435       NaN

 

 

 

 

  (5) 결측값을 다른 변수의 값으로 대체하기

      (filling missing values with another columns' values)

 

두가지 방법이 있는데요, 먼저 np.where()와 pd.notnumm() 를 사용해서 np.where(pd.notnull(df['C2']) == True, df['C2'], df['C1']) 처럼 'C2' 칼럼에서 결측값이 없으면 'C2' 칼럼의 값을 그대로 사용하고, 'C2'칼럼에 결측값이 있으면 'C1' 칼럼의 값을 가져다가 결측값을 채워보겠습니다.

 

 

In [28]: df_2 = pd.DataFrame({'C1': [1, 2, 3, 4, 5],

    ...: 'C2': [6, 7, 8, 9, 10]})

    ...:


In [29]: df_2.ix[[1, 3], ['C2']] = np.nan


In [30]: df_2

Out[30]:

   C1    C2
0   1   6.0
1   2   NaN
2   3   8.0
3   4   NaN
4   5  10.0

 

## making new column by filling missing values with another column's value

# way 1 : by np.where => quick

In [31]: df_2['C2_New'] = np.where(pd.notnull(df_2['C2']) == True, df_2['C2'], df_2['C1'])


In [32]: df_2

Out[32]:

   C1    C2    C2_New
0   1   6.0       6.0
1   2   NaN     2.0
2   3   8.0       8.0
3   4   NaN     4.0
4   5  10.0      10.0

 

 

 

 

아래의 loop programming은 위와 동일한 결과를 반환하지만 시간은 훨~씬 오래 걸린다는 점 유의하시구요, 그냥 '아, 이렇게도 할 수 있구나...' 정도로만 참고하시기 바랍니다.

(당연히, 위의 np.where()와 pd.notnull() 을 사용하는 것이 속도도 빠르고 코드도 짧고 쉽기 때문에 추천)

 

 

# way 2 : by loop programming => takes long time

In [33]: for i in df_2.index:

    ...:     if pd.notnull(df_2.ix[i, 'C2']) == True:

    ...:         df_2.ix[i, 'C2_New_2'] = df_2.ix[i, 'C2']

    ...:     else:

    ...:         df_2.ix[i, 'C2_New_2'] = df_2.ix[i, 'C1']

    ...:

    ...:


In [34]: df_2

Out[34]:

   C1    C2  C2_New  C2_New_2
0   1   6.0     6.0       6.0
1   2   NaN     2.0       2.0
2   3   8.0     8.0       8.0
3   4   NaN     4.0       4.0
4   5  10.0    10.0      10.0

 

 

 

결측값을 그룹별 평균으로 대체하기는 http://rfriend.tistory.com/402 를 참고하세요. 


많은 도움 되었기를 바랍니다.

 

 

Posted by R Friend R_Friend

지난번 포스팅에서는 Python pandas DataFrame 에서

 

 - 결측값이 있는지 여부 확인 : isnull(), notnull()

 - 열별 결측값 개수 : df.isnull().sum()

 - 행별 결측값 개수 : df.isnull().sum(1)

 

확인하는 방법을 소개하였습니다. (바로가지 ☞ http://rfriend.tistory.com/260)

 

 

이번 포스팅에서는 결측값 연산 (calculations with missing data) 에 대해서 알아보겠습니다.

 

 

 

 

먼저, 필요한 모듈 importing 하고, 결측값 들어있는 DataFrame을 만들어보겠습니다.

 

 

In [1]: import pandas as pd


In [2]: import numpy as np


In [3]: from pandas import DataFrame


In [4]: df = DataFrame(np.arange(10).reshape(5,2),

   ...: index=['a', 'b', 'c', 'd', 'e'],

   ...: columns=['C1', 'C2'])

   ...:


In [5]: df

Out[5]:

   C1  C2
a   0   1
b   2   3
c   4   5
d   6   7
e   8   9


In [6]: df.ix[['b', 'e'], ['C1']] = None


In [7]: df.ix[['b', 'c'], ['C2']] = None


In [8]: df

Out[8]:

    C1   C2
a  0.0  1.0
NaN  NaN
c  4.0  NaN
d  6.0  7.0
NaN  9.0

 

 

 

 

  (1) sum(), cumsum() methods 계산 시 : NaN은 '0'으로 처리

 

 

# When summing data, NA (missing) values will be treated as zero

In [9]: df.sum() # sum by columns

Out[9]:

C1    10.0
C2    17.0
dtype: float64


In [10]: df['C1'].sum() # sum of 'C1' column

Out[10]: 10.0


In [11]: df['C1'].cumsum() # cumulative sum of 'C1' column

Out[11]:

a     0.0
b     NaN
c     4.0
d    10.0
e     NaN
Name: C1, dtype: float64

 

 

 

 

  (2) mean(), std() 연산 시 : NaN은 분석 대상(population)에서 제외

 

 

In [8]: df

Out[8]:

    C1   C2
a  0.0  1.0
NaN  NaN
c  4.0  NaN
d  6.0  7.0
NaN  9.0

 

 

# As for mean(), std() methods, NA (missing) values will be ignored

In [12]: df.mean() # mean by columns

Out[12]:

C1    3.333333  # (0+4+6)/3 = 3.333333
C2    5.666667  # (1+7+9)/3 = 5.66667
dtype: float64


In [13]: df.mean(1) # mean by row

Out[13]:

a    0.5
b    NaN
c    4.0
d    6.5
e    9.0
dtype: float64

 

In [14]: df.std()

Out[14]:

C1    3.055050
C2    4.163332
dtype: float64

 

 

 

 

  (3) DataFrame 칼럼 간 연산 시 : NaN이 하나라도 있으면 NaN 반환

 

아래 예시의 'C3' 칼럼에서 'c', 'e' index 값을 유심히 보시기 바랍니다.  '+'을 하는 'C1'과 'C2' 칼럼의 값 중에서 하나라도 NaN 이면 'C3' 값은 NaN 입니다. (물론 'C1'과 'C2' 모두 NaN이면 이들의 합인 'C3'는 NaN이구요.)

 

 

In [8]: df

Out[8]:

    C1   C2
a  0.0  1.0
NaN  NaN
c  4.0  NaN
d  6.0  7.0
NaN  9.0

 

In [15]: df['C3'] = df['C1'] + df['C2']


In [16]: df

Out[16]:

    C1   C2    C3
a  0.0  1.0   1.0
b  NaN  NaN   NaN
c  4.0  NaN   NaN
d  6.0  7.0  13.0
e  NaN  9.0   NaN

 

 

 

 

  (4) DataFrame 간 연산 : 동일한 칼럼끼리는 NaN을 '0'으로 처리하여 연산,

      동일한 칼럼이 없는 경우(한쪽에만 칼럼이 있는 경우)는 모든 값을 NaN으로 반환

 

아래 예제의 df, df_2 의 두 개의 DataFrame에서는 'C1' 만이 동일한 (공통의) 칼럼이며, 나머지는 한쪽 DataFrame에만 있는 칼럼들로 구성이 되어 있습니다.

 

이들 df, df_2 두 개의 DataFrame을 '+' 하면 'C1' 만 제대로 덧셈 연산이 되고 ( NaN 은 '0'으로 처리하여 연산 ), 나머지 칼럼은 모든 값이 NaN으로 변환되었음을 알 수 있습니다.

 

 

In [17]: df_2 = DataFrame({'C1' : [1, 1, 1, 1, 1],

    ...: 'C4' : [1, 1, 1, 1, 1]},

    ...: index=['a', 'b', 'c', 'd', 'e'])

    ...:


In [18]: df

Out[18]:

    C1   C2    C3
0.0  1.0   1.0
NaN  NaN   NaN
4.0  NaN   NaN
6.0  7.0  13.0
NaN  9.0   NaN


In [19]: df_2

Out[19]:

   C1  C4
a   1   1
b   1   1
c   1   1
d   1   1
e   1   1


In [20]: df + df_2

Out[20]:

    C1  C2  C3  C4
1.0 NaN NaN NaN
NaN NaN NaN NaN
5.0 NaN NaN NaN
7.0 NaN NaN NaN
NaN NaN NaN NaN

 

 

 

이상으로 결측값 연산을 마치도록 하겠습니다.

 

다음번 포스팅에서결측값 채우기, 결측값 대체 대해서 알아보겠습니다.

 

Posted by R Friend R_Friend

DataFrame을 가지고 분석을 진행하다 보면 대부분의 경우 결측값(missing value)이 골치거리로 따라 다닙니다.

 

데이터가 원래 수집 혹은 측정이 안되었을 수도 있고, 다수의 DataFrame을 서로 병합하는 과정에서 결측값이 생길 수도 있으며, index를 재설정(reindex)하는 경우에도 결측값이 생길 수 있습니다.

 

이처럼 다양한 이유로 인해서 생기는 결측값은 분석 오류가 발생시키거나 혹은 왜곡시킬 위험이 있습니다. 따라서 분석할 DataFrame을 생성했으면 결측값(missing value)이 있는지 여부에 대해서 꼭 확인하고 조치하여야 합니다.

 

이번 포스팅에서는 Python pandas의 isnull(), notnull() 메소드를 활용해서 결측값이 있는지 여부를 확인하는 방법을 소개하겠습니다.

 

 

 

 

Python pandas에서는 결측값을 'NaN' 으로 표기하며, 'None'도 결측값으로 인식합니다.

 

 

먼저 결측값이 있는 DataFrame을 만들어보겠습니다.

 

 

# making DataFrame with missing values

In [1]: import pandas as pd


In [2]: from pandas import DataFrame


In [3]: df_left = DataFrame({'KEY': ['K0', 'K1', 'K2', 'K3'],

   ...: 'A': ['A0', 'A1', 'A2', 'A3'],

   ...: 'B': [0.5, 2.2, 3.6, 0.4]})


In [4]: df_right = DataFrame({'KEY': ['K2', 'K3', 'K4', 'K5'],

   ...: 'C': ['C2', 'C3', 'C4', 'C5'],

   ...: 'D': ['D2', 'D3', 'D4', 'D5']})


In [5]: df_all = pd.merge(df_left, df_right, how='outer', on='KEY')


In [6]: df_all

Out[6]:

     A    B KEY    C    D
0   A0  0.5  K0  NaN  NaN
1   A1  2.2  K1  NaN  NaN
2   A2  3.6  K2   C2   D2
3   A3  0.4  K3   C3   D3
NaN  NaN  K4   C4   D4
NaN  NaN  K5   C5   D5

 

 

 

 

  (1) DataFrame 전체의 결측값 여부 확인 : df.isnull(), isnull(df), df.notnull(), notnull(df)

 

isnull() 메소드는 관측치가 결측이면 True, 결측이 아니면 False boollean 값을 반환합니다.

notnull() 메소드는 관측치가 결측이면 False, 결측이 아니면 True를 반환합니다.(isnull() 과 정반대)

 

isnull(DataFrame) 과 DataFrame.isnull() 은 동일한 값을 반환하며, notnull(DataFrame)과 DataFrame.notnull() 역시 동일한 의미의 script 입니다.

 

 

In [7]: pd.isnull(df_all)

Out[7]:

       A      B    KEY      C      D
0  False  False  False   True   True
1  False  False  False   True   True
2  False  False  False  False  False
3  False  False  False  False  False
4   True   True  False  False  False
5   True   True  False  False  False


In [8]: df_all.isnull()

Out[8]:

       A      B    KEY      C      D
0  False  False  False   True   True
1  False  False  False   True   True
2  False  False  False  False  False
3  False  False  False  False  False
4   True   True  False  False  False
5   True   True  False  False  False


In [9]: pd.notnull(df_all)

Out[9]:

       A      B   KEY      C      D
0   True   True  True  False  False
1   True   True  True  False  False
2   True   True  True   True   True
3   True   True  True   True   True
False  False  True   True   True
False  False  True   True   True

 

In [10]: df_all.notnull()

Out[10]:

       A      B   KEY      C      D
0   True   True  True  False  False
1   True   True  True  False  False
2   True   True  True   True   True
3   True   True  True   True   True
False  False  True   True   True
False  False  True   True   True

 

 

 

  (2) 특정 변수, 원소에 결측값 추가하기, 결측값 여부 확인하기 : indexing & None

 

아래 예시의 'df_all' DataFrame 에서 ['A', 'B'] 칼럼의 ['0', '1'] index 위치에 있는 관측치에 'None'을 할당하여 결측치를 만들어보았습니다.

 

'A'칼럼의 경우 'string' 데이터 형식인데요, 'None'을 할당하니 'None'으로 입력되었습니다.  반면에, 'B' 칼럼의 경우 'float' 데이터 형식인데요, 'None'을 할당하니 'NaN'으로 자동으로 입력되었습니다.

 

DataFrame의 행, 열을 기준으로 indexing을 하고 싶을 때는 DataFrame.ix[[row1, row2], ['col1', 'col2']] 을 사용하면 됩니다.  아래 예시를 참고하세요.

 

 

In [11]: df_all

Out[11]:

     A        B  KEY    C    D
0   A0      0.5  K0  NaN  NaN
1   A1      2.2  K1  NaN  NaN
2   A2      3.6  K2   C2   D2
3   A3      0.4  K3   C3   D3
NaN  NaN  K4   C4   D4
NaN  NaN  K5   C5   D5

 

In [12]: df_all.ix[[0, 1], ['A', 'B']] = None


In [13]: df_all

Out[13]:

      A         KEY    C      D
None  NaN  K0  NaN  NaN
None  NaN  K1  NaN  NaN
2    A2     3.6   K2   C2   D2
3    A3     0.4   K3   C3   D3
4   NaN  NaN  K4   C4   D4
5   NaN  NaN  K5   C5   D5


In [14]: df_all[['A', 'B']].isnull()

Out[14]:

       A      B
0   True   True
1   True   True
2  False  False
3  False  False
4   True   True
5   True   True

 

 

 

 

  (3) 칼럼별 결측값 개수 구하기 : df.isnull().sum()

 

 

# counting missing value numbers for all columns

In [15]: df_all.isnull().sum()

Out[15]:

A      2
B      2
KEY    0
C      2
D      2
dtype: int64

 

# counting missing value numbers for 'A' column

In [16]: df_all['A'].isnull().sum()

Out[16]: 2

 

 

 

 

반대로, 칼럼별 결측값이 아닌 값의 개수를 구하려면 df.notnull().sum() 을 사용하면 됩니다.

 

 

# counting notnull value numbers for all columns

In [17]: df_all.notnull().sum()

Out[17]:
A      4
B      4
KEY    6
C      4
D      4
dtype: int64

 

 

 

 

  (4) 행(row) 단위로 결측값 개수 구하기 : df.isnull().sum(1)

       행(row) 단위로 실측값 개수 구하기 : df.notnull().sum(1)

 

 

In [18]: df_all

Out[18]:

     A    B KEY    C    D
0   A0  0.5  K0  NaN  NaN
1   A1  2.2  K1  NaN  NaN
2   A2  3.6  K2   C2   D2
3   A3  0.4  K3   C3   D3
4  NaN  NaN  K4   C4   D4
5  NaN  NaN  K5   C5   D5


In [19]: df_all['NaN_cnt'] = df_all.isnull().sum(1)


In [20]: df_all['NotNull_cnt'] = df_all.notnull().sum(1)


In [21]: df_all

Out[21]:

     A      B    KEY   C     D     NaN_cnt   NotNull_cnt
0   A0    0.5   K0  NaN  NaN      2            4
1   A1    2.2   K1  NaN  NaN      2            4
2   A2    3.6   K2   C2    D2        0            6
3   A3    0.4   K3   C3    D3        0            6
4  NaN  NaN  K4   C4    D4        2            4
5  NaN  NaN  K5   C5    D5        2            4

 

 

 

 

다음번 포스팅에서는 결측값 연산에 대해서 소개하겠습니다.

 

 

Posted by R Friend R_Friend

지난번 포스팅에서는 Python pandas의 merge() 함수를 사용해서 Key를 기준으로 DataFrame을 합치는 방법을 소개하였습니다.

 

이번 포스팅에서는 pandas의 merge(), join() 함수를 사용해서 index를 기준으로 DataFrame을 합치는 방법을 소개하도록 하겠습니다.

 

SQL이나 R 사용자라면 index 사용하는게 좀 낯설을 수도 있을 것 같습니다.

 

 

 

먼저 필요한 Library를 importing하고, 간단한 DataFrame 을 예로 만들어 보겠습니다.

 

 

In [1]: import pandas as pd


In [2]: from pandas import DataFrame


In [3]: df_left = DataFrame({'A': ['A0', 'A1', 'A2', 'A3'],

   ...: 'B': ['B0', 'B1', 'B2', 'B3']},

   ...: index=['K0', 'K1', 'K2', 'K3'])


In [4]: df_right = DataFrame({'C': ['C2', 'C3', 'C4', 'C5'],

   ...: 'D': ['D2', 'D3', 'D4', 'D5']},

   ...: index=['K2', 'K3', 'K4', 'K5'])

   ...:


In [5]: df_left

Out[5]:

     A   B
K0  A0  B0
K1  A1  B1
K2  A2  B2
K3  A3  B3


In [6]: df_right

Out[6]:

     C   D
K2  C2  D2
K3  C3  D3
K4  C4  D4
K5  C5  D5

 

 

 

 

index를 기준으로 DataFrame을 합치는 방법에는 pd.merge() 와 join() 두 가지 방법이 있는데요, join() 이 code가 간결한 편이며, code에 대한 가독성은 pd.merge()가 좀더 명확한 편입니다.

 

 

  (1) index를 기준으로 Left Join 하기 (Left join on index)

 

 

# Left joining on index

# way 1 : by merge()

In [7]: pd.merge(df_left, df_right,

   ...: left_index=True, right_index=True,

   ...: how='left')

Out[7]:

     A   B    C    D
K0  A0  B0  NaN  NaN
K1  A1  B1  NaN  NaN
K2  A2  B2   C2   D2
K3  A3  B3   C3   D3

 

# way 2 : by join

In [8]: df_left.join(df_right, how='left')

Out[8]:

     A   B    C    D
K0  A0  B0  NaN  NaN
K1  A1  B1  NaN  NaN
K2  A2  B2   C2   D2
K3  A3  B3   C3   D3

 

 

 

 

  (2) index를 기준으로 Right Join 하기 (Right join on index)

 


# Right join on index

# way 1 : merge()

In [9]: pd.merge(df_left, df_right,

   ...: left_index=True, right_index=True,

   ...: how='right')

Out[9]:

      A    B   C   D
K2   A2   B2  C2  D2
K3   A3   B3  C3  D3
K4  NaN  NaN  C4  D4
K5  NaN  NaN  C5  D5

 

# way 2 : join()

In [10]: df_left.join(df_right, how='right')

Out[10]:

      A    B   C   D
K2   A2   B2  C2  D2
K3   A3   B3  C3  D3
K4  NaN  NaN  C4  D4
K5  NaN  NaN  C5  D5

 

 

 

 

  (3) index를 기준으로 inner join 하기 (inner join on index)

 

 

# inner join on index

# way 1 : by merge()

In [11]: pd.merge(df_left, df_right,

    ...: left_index=True, right_index=True,

    ...: how='inner')

Out[11]:

     A   B   C   D
K2  A2  B2  C2  D2
K3  A3  B3  C3  D3

 


# way 2 : by join()

In [12]: df_left.join(df_right, how='inner')

Out[12]:

     A   B   C   D
K2  A2  B2  C2  D2
K3  A3  B3  C3  D3

 

 

 

 

  (4) index를 기준으로 outer join 하기 (outer join on index)

 

 

# outer join on index

# way 1 : by pd.merge()

In [13]: pd.merge(df_left, df_right,

    ...: left_index=True, right_index=True,

    ...: how='outer')

Out[13]:

      A    B    C    D
K0   A0   B0  NaN  NaN
K1   A1   B1  NaN  NaN
K2   A2   B2   C2   D2
K3   A3   B3   C3   D3
K4  NaN  NaN   C4   D4
K5  NaN  NaN   C5   D5

 


# way 2 : by join()

In [14]: df_left.join(df_right, how='outer')

Out[14]:

      A    B    C    D
K0   A0   B0  NaN  NaN
K1   A1   B1  NaN  NaN
K2   A2   B2   C2   D2
K3   A3   B3   C3   D3
K4  NaN  NaN   C4   D4
K5  NaN  NaN   C5   D5

 

 

 


위의 4개의 index 기준 DataFrame 병합 사례에서는 양쪽 DataFrame 모두 index를 사용했습니다. 

 

그런데 만약 한쪽 DataFrame은 index를 기준으로 하고, 나머지 한쪽 DataFrame에서는 Key 변수를 기준으로 해서 두 DataFrame을 합쳐야 한다면 어떻게 해야 할까요?

 

pd.merge()와 join() 두 가지 방법을 how='left' 의 경우만 예를 들어서 설명하겠습니다.  역시 join() 이 script가 간결한 반면, pd.merge()가 병합의 기준을 명시해줌으로써 가독성은 더 좋습니다. 뭘 사용할지는 개인의 취향에 따라 선택하시면 됩니다.

 

 

  (5) index와 Key를 혼합해서 DataFrame 합치기 (Joining key columns on an index)

 

먼저 df_left_2 는 'KEY' 를 가진 DataFrame으로 만들고, df_right_2는 index를 가진 DataFrame으로 만든 후에 이 둘을 'KEY'와 index를 혼합해서 사용해서 합쳐보겠습니다.

 

 

# making DataFrame 

In [15]: df_left_2 = DataFrame({'KEY': ['K0', 'K1', 'K2', 'K3'],

    ...: 'A': ['A0', 'A1', 'A2', 'A3'],

    ...: 'B': ['B0', 'B1', 'B2', 'B3']})

    ...:


In [16]: df_right_2 = DataFrame({'C': ['C2', 'C3', 'C4', 'C5'],

    ...: 'D': ['D2', 'D3', 'D4', 'D5']},

    ...: index=['K2', 'K3', 'K4', 'K5'])

    ...:


In [17]: df_left_2  # with 'KEY'

Out[17]:

    A   B KEY
0  A0  B0  K0
1  A1  B1  K1
2  A2  B2  K2
3  A3  B3  K3


In [18]: df_right_2  # with 'index'

Out[18]:

     C   D
K2  C2  D2
K3  C3  D3
K4  C4  D4
K5  C5  D5

 

 

 

 

이제 Key와 index를 혼합해서 두 DataFrame을 합쳐보겠습니다.

 

 

# joining key columns on an index

# way 1 : pd.merge()

In [19]: pd.merge(df_left_2, df_right_2,

    ...: left_on='KEY', right_index=True,

    ...: how='left')

    ...:

Out[19]:

    A   B KEY    C    D
0  A0  B0  K0  NaN  NaN
1  A1  B1  K1  NaN  NaN
2  A2  B2  K2   C2   D2
3  A3  B3  K3   C3   D3

 

 

# way 2 : join()

In [20]: df_left_2.join(df_right_2, on='KEY', how='left')

Out[20]:

    A   B KEY    C    D
0  A0  B0  K0  NaN  NaN
1  A1  B1  K1  NaN  NaN
2  A2  B2  K2   C2   D2
3  A3  B3  K3   C3   D3

 

 

 

이상으로 DataFrame을 index 기준으로 합치는 방법에 대한 소개를 마치겠습니다.

 

 

Posted by R Friend R_Friend