반응형

pandas는 Series, DataFrame 두개를 중심으로 데이터를 다룬다.

그 중 DataFrame에서 주로 사용하는 명령을 먼저 간단히 정리해 본 다음, loc와 iloc를 알아볼 것이다.

먼저 라이브러리를 읽어들인다.

import pandas as pd
import numpy as np

그 다음 사용할 데이터를 DataFrame 데이터 유형으로 만든다.

dates = pd.date_range('2023-09-01', periods=6)
df = pd.DataFrame(np.random.randn(6,5), index = dates, columns=['A', 'B', 'C', 'D', 'E'])
df

head() 명령을 사용하면 기본적으로 첫 5행을 보여준다. 괄호에 숫자를 기입하면 그 숫자만큼 행을 더 볼 수 있다.

df.head()

index, columns 명령을 사용하면 DataFrame의 컬럼과 인덱스를 확인할 수 있다.

df.index

df.columns

DataFrame에 값들은 values 명령을 사용해 확인하면 된다. 

df.values

info() 명령을 사용하면 DataFrame의 개요를 알 수 있다.

df.info()

describe() 명령을 사용하면 통계적 개요를 확인할 수 있다. 

df.describe()

sort_values() 명령은 by로 지정된 컬럼을 기준으로 정렬된다. ascending 옵션을 사용하면 오름차순(=True)이나 내림차순(=False)으로 정렬할 수 있다.

df.sort_values(by='C', ascending=True)

반응형

DataFrame.loc

인덱스인 dates 변수를 사용해 특정 날짜의 데이터만 보고 싶으면 df.loc 명령을 사용하면 된다. loc는 location 옵션으로 슬라이싱할 때 loc 옵션을 이용해서 위치 값을 지정할 수 있다.

df.loc[dates[0]]

컬럼을 지정한 후 모든 행을 보고 싶다면, 다음과 같이 하면 된다.

df.loc[:, ['B', 'D']]

행과 열의 범위를 모두 지정해 볼 수도 있다.

df.loc['2023-09-03':'2023-09-05', ['B', 'D']]

 

DataFrame.iloc

loc 명령과 달리 행과 열의 번호를 이용해 데이터에 바로 접근하려고 할 때는 iloc 명령을 사용한다.
iloc를 사용하면 행이나 열의 범위를 지정하면 된다. 특히 콜론(:)을 사용하면 전체 데이터를 불러온다.

아래 명령 iloc[4]는 5번째 행의 전체 컬럼 값을 불러오게 된다. 0번부터 시작하기 때문에 5번 행을 불러오게 된다.

df.iloc[4]

다음과 같이 범위를 정해서 불러올 수도 있다. 2번째 행부터 5번째 앞, 즉 2번째~4번째 행과 0번부터 2번째 열의 데이터만 가져오게 된다.

df.iloc[2:5, 0:3]

범위가 아니라 콤마(,)로 행이나 열을 지정해 데이터를 가져올 수도 있다. 행이나 열에 대해 전체를 가져오고 싶은 곳에는 그냥 콜론(:)을 사용한다.

df.iloc[1:4, :]

DataFrame에서 특정 조건을 만족하는 데이터만 가져올 수도 있다.
다음과 같이 조건을 입력해서 사용한다.

df[df.B > 0]

 

반응형
반응형

컴퓨터 비전이나 텍스트 분석은 성능 좋은 오픈 API나 노하우가 축적되고 공유되어 빠르게 발전하고 있다. 하지만 투자 업계에서는 금융 데이터를 손쉽게 처리해주는 판다스 같은 라이브러리가 있어도, 성능 좋은 알고리즘이나 방법론이 공유되는 경우가 거의 없다.

세계 경제가 긴밀하게 연동하고 경제 주체들의 투자 패턴이 다양해짐에 따라 고려해야 할 변수가 기하급수적으로 증가한 반면 시계열 데이터를 기본으로 한 투자 데이터는 그 양이 한정적이다. 애널리스트 분석에 자주 사용되는 OECD 경기선행지수, 국가별 GDP, 금리 자료 등은 업데이트 주기가 길다. 이러한 데이터의 한계로 인해 좋은 모델을 만들기가 어렵다고 한다. 

금융은 자본주의 사회에서 우리의 삶에 깊숙이 침투하여 개인의 일상생활과 밀접한 관계를 맺고 있고 우리가 살아가며 생산하는 수많은 데이터를 통해 연결되어 있다. 많은 의사결정 프로세스가 데이터 기반으로 전환하는 시대에 투자라고 예외일 수 없다. 나날이 복잡다단해지는 투자 환경에서 사람의 '감'에 기반한 투자 의사결정은 점점 힘을 잃어갈 것이다.

투자 영역에서 활용하는 데이터('실전 금융 머신러닝 완벽분석'의 저자인 마르코스 로페즈가 분류)

재무제표 데이터 마켓 데이터 분석 데이터 대체 데이터
자산 가격/변동성 애널리스트 추천 위성/CCTV 이미지
부채 거래량 신용 등급 구글 검색어
판매량 배당 이익 예측 트윗/SNS
비용/이익 이자율 감성 분석 메타데이터
거시 변수 상장/폐지 ... ...

 

파이썬으로 만드는 투자전략과 주요 지표

1. 바이앤홀드(Buy & Hold) 전략

바이앤홀드는 주식을 매수한 후 장기 보유하는 투자 전략이다. 즉 매수하려는 종목이 충분히 저가라고 판단될 때 주기적으로 매수한 후 장기간 보유하는 식으로 투자하는 방법이다. 
주가는 예측이 불가하지만 경제가 성장함에 따라 장기적으로 우상향한다는 투자 철학의 관점에서 보면 합리적인 투자 방법이다.

주피터 노트북(Jupyter notebook) 환경에서 실행한다고 가정하고, 관련 라이브러리를 다음과 같이 설치해야 한다.

!pip install matplotlib
!pip install pandas
!pip install -U finance-datareader # 국내 금융데이터를 포함 pandas-datareader를 대체

준비가 되면, 관련 라이브러리를 불러온다

import pandas as pd
import numpy as np
import FinanceDataReader as fdr

본격적으로 바이앤홀드 전략을 구현해 보자. FinanceDataReader 라이브러리에서 직접 테슬라(TSLA) 데이터를 추출하여, 판다스의 head()함수를 사용해 데이터를 살펴본다.

df = fdr.DataReader('TSLA', '2013-01-01', '2023-08-31')
df.head()

데이터는 'Date'가 인덱스로 설정되고, 시작가(Open), 고가(High), 저가(Low), 종가(Close), 수정 종가(Adj Close), 거래량(Volume)으로 구성된다.

결측치(데이터에 값이 없는 것, NA)가 있는 지 살펴본다.

df.isin([np.nan, np.inf, -np.inf]).sum()

결측치가 없는 것을 확인했으니, 바이앤홀드 전략을 수정 종가(Adj Close)를 이용해 테스트한다.
보통 전략을 테스트할 때는 종가를 기준으로 처리한다.

수정 종가를 슬라이스해 별도의 데이터셋을 만든다.

price_df = df.loc[:,['Adj Close']].copy()
price_df.plot(figsize=(16,9))

수정 종가(Adj Close)로 DataFrame을 만들고 종가(Close) 모양이 어떻게 생겼는지 그래프를 통해 살펴본다.
전체 기간을 보면 주가가 많이 상승했다. 하지만 짧은 시점을 확인해 보면 다를 수 있다.
테슬라는 최근 2022~2023년에 주가 변동성이 매우 큰 것을 알 수 있다. 

from_date = '2022-01-01'
to_date = '2023-08-31'
price_df.loc[from_date:to_date].plot(figsize=(16,9))

2022년 400달러에 달하던 주가가 108달러까지 떨어지는 등 최고점 투자 대비 70% 가량까지 하락했다.
이렇게 최고점 대비 현재까지 하락한 비율 중 최대 하락률을 최대 낙폭(maximum draw down, MDD)이라고 한다.

그 다음으로 일별 수익률을 계산해 보자.

price_df['daily_rtn'] = price_df['Adj Close'].pct_change()
price_df.head(10)

바이앤홀드 전략에서 일별 수익률을 계산하는 이유는 매수한 시점부터 매도한 시점까지 보유하게 되는데 일별 수익률을 누적으로 곱하면 최종적으로 매수한 시점 대비 매도한 시점의 종가 수익률로 계산되기 때문이다.

다음에는 바이앤홀드 전략의 누적 곱을 계산해 보자. 판다스 cumprod() 함수를 사용하면 쉽게 계산된다.

price_df['st_rtn'] = (1+price_df['daily_trn']).cumprod()
price_head(10)
price_df['st_rtn'].plot(figsize=(16,9))

이번에는 매수 시점을 정해서 수익률을 계산해 본다.

base_date= '2020-01-02'
tmp_df = price_df.loc[base_date:,['st_rtn']] / price_df.loc[base_date,['st_rtn']]
last_date = tmp_df.index[-1]
print('누적 수익 : ',tmp_df.loc[last_date,'st_rtn'])
tmp_df.plot(figsize=(16,9))

base_date변수를 선언해 새로운 기준 일자를 정한다. 특정 일자를 기준으로 수익률을 계산하고 누적 수익을 보니 8.95까지 상승했다. 2020년 1월 2일에 처음 테슬라 주식을 매수했다면 8.95배의 수익률을 얻을 수 있었다는 뜻이다.

사실 지금 보여준 바이앤홀드 전략에는 복잡한 코딩은 없었다. 단지 주어진 기간의 수익률만 확인했을 뿐이다.
여기에 신호(매수/매도 신호)를 추가한다면 다양한 전략으로 응용할 수 있다.

반응형

- 연평균 복리 수익률(CAGR)

수익률 성과를 분석할 때 산술평균 수익률보다 기하평균 수익률을 더 선호한다. 기하평균 수익률이 복리 성질과 주가 변동이 심한 때에 따라 변동성을 표현해 주기 때문이다. 

이 CAGR 수식을 파이썬 코드로 구현하면 다음과 같다.

CAGR = price_df.loc['2023-08-30', 'st_rtn'] ** (252./len(price_df.index)) -1

우리가 가진 데이터셋의 마지막 날짜가 2023년 8월 30일이다. 해당일자의 최종 누적 수익률의 누적 연도 제곱근을 구하는 것이다. 또한 우리는 일(Daily) 데이터를 사용했으므로 전체년도를 구하기 위해 전체 데이터 기간을 252(금융공학에서 1년은 252 영업일로 계산)로 나눈 역수를 제곱(a**b) 연산한다. 그리고 -1을 하면 수익률이 나온다.

- 최대 낙폭(MDD)

최대 낙폭은 최대 낙폭 지수로, 투자 기간에 고점부터 저점까지 떨어진 낙폭 중 최댓값을 의미한다. 이는 투자자가 겪을 수 있는 최대 고통을 측정하는 지표로 사용되며, 낮을수록 좋다.

이 MDD 수식을 파이썬 코드로 구현하면 다음과 같다.

historical_max = price_df['Adj Close'].cummax()
daily_drawdown = price_df['Adj Close'] / historical_max - 1.0
historical_dd = daily_drawdown.cummin()
historical_dd.plot()

수정 종가에 cummax() 함수 값을 저장한다. cummax()는 누적 최댓값을 반환한다. 전체 최댓값이 아닌 행row별 차례로 진행함녀서 누적 값을 갱신한다. 현재 수정 종가에서 누적 최댓값 대비 낙폭률을 계산하고 cummin() 함수를 사용해 최대 하락률을 계산한다. 출력 그래프를 보면 최대 하락률의 추세를 확인할 수 있다.

- 변동성(Vol)

주가 변화 수익률 관점의 변동성을 알아보자. 변동성은 금융 자산의 방향성에 대한 불확실성과 가격 등락에 대한 위험 예상 지표로 해석하며, 수익률의 표준 편차를 변동성으로 계산한다.

만약 영업일 기준이 1년에 252일이고 일별 수익률의 표준 편차가 0.01이라면, 연율화된 변동성은 다음 수식과 같이 계산된다.

변동선 수익을 파이썬 코드로 구현하면 다음과 같다.

VOL = np.std(price_df['daily_rtn']) * np.sqrt(252.)

변동성은 수익률의 표준편차로 계산한다. 이는 일Daily 단위 변동성을 의미하는데, 루이 바슐리에의 '투기이론'에서 주가의 변동폭은 시간의 제곱근에 비례한다는 연구 결과에 따라 일 단위 변동성을 연율화할 때 252의 제곱근을 곱한다.

- 샤프 지수

샤프 지수는 위험 대비 수익성 지표라고 볼 수 있다. 

샤프 지수를 파이썬 코드로 구현하면 다음과 같다.

Sharpe = np.mean(price_df['daily_rtn']) / np.std(price_df['daily_rtn']) * np.sqrt(252.)

사후적 샤프 비율을 사용했다. 실현 수익률의 산술평균/실현 수익률의 변동성으로 계산하므로 넘파이의 평균을 구하는 함수와 연율화 변동성을 활용해 위험 대비 수익성 지표를 계산한다.

- 성과 분석 결과

최종 성과를 분석해 보자. 

CAGR = price_df.loc['2023-08-30', 'st_rtn'] ** (252./len(price_df.index)) -1
Sharpe = np.mean(price_df['daily_rtn']) / np.std(price_df['daily_rtn']) * np.sqrt(252.)
VOL = np.std(price_df['daily_rtn']) * np.sqrt(252.)
MDD = historical_dd.min()

print('CAGR : ',round(CAGR*100,2), '%')
print('Sharpe : ',round(Sharpe,2))
print('VOL : ',round(VOL*100,2), '%')
print('MDD : ',round(-1*MDD*100,2), '%')

CAGR : 55.34%
Sharpe : 1.06
VOL : 57.18%
MDD : 73.63%

테슬라는 2013년부터 현재(2023년 8월 30일 기준)까지 연평균 복리 수익률 CAGR로 55% 성장했다. 샤프 지수 Sharpe는 1 이상만 되어도 좋다고 판단한다.

다음으로 변동성 VOL을 보면 57%인 것을 확인할 수 있는데, 이는 주가 수익률이 꽤 많이 출렁인 것을 의미한다. 장기간의 시점에서 주가를 바라볼 때는 안정적으로 우상향했다고 생각할 수 있지만, 하루하루 주가 흐름은 그닥 안정적이지 않았다는 뜻이다.

마지막으로 최대 낙폭 MDD는 73%가 하락한 경우가 있음을 알 수 있다. 최고점에서 주식을 구입한 경우에는 견디가 어려운 낙폭임을 인지할 필요가 있다.

기업 성장성이 확실하다고 판단한 주식은 싸다고 생각되는 시장이 어려운 시기에 사서 장기적으로 보유하다가 고점이라고 생각되는 시점인 대중이 열광하는 시점에 처분한다는 자세를 잊지 말아야겠다.

반응형
반응형

머신러닝에 있어, 가장 먼저해야 하는 일 중 하나가 데이터 정제(Data Cleaning)입니다.

왜냐하면 바로 모델을 훈련할 수 있는 데이터셋을 확보하는 것이 실제로는 매우 어렵기 때문입니다.

따라서, 결측값(NaN)은 없는지, 이상치(outlier)는 없는지 알아보기 위해 데이터셋을 주의깊게 살펴보아야 합니다. 

값이 큰 열이 있는 경우 정규화를 통한 보정이 필요하기도 합니다. 

이번에는 데이터 정제(Data Cleaning)에 필요한 일반적인 작업에 대해 알아보도록 하겠습니다.

 

결측값(NaN)이 있는 열 정제하기

다음 데이터로 된 NaNDataset.csv 파일이 있다고 가정하겠습니다.

눈으로 봐도 몇개 열에 결측값이 있는 것을 확인할 수 있습니다.

작은 데이터셋에서는, 쉽게 결측값을 찾을 수 있습니다.

하지만, 큰 데이터셋에서는, 눈으로 알아내는 게 거의 불가능할 것입니다.

결측값을 찾아내는 효과적인 방법은 판다스(Pandas) 데이터프레임으로 데이터셋을 로드해서 데이터프레임의 빈 값(NaN) 여부를 확인하기 위해 isnull() 함수를 사용하는 것입니다.

>>> import pandas as pd
>>> df = pd.read_csv('NaNDataset.csv')
>>> df.isnull().sum()

B 컬럼에 두개의 빈 값이 있는 것을 볼 수 있습니다.

판다스(Pandas)에서 빈 값이 포함된 데이터셋을 로드할 때, 빈 필드를 나타내는 NaN을 사용할 것입니다.

다음은 데이터프레임의 결과물입니다.

컬럼의 평균값으로 NaN 대체하기

데이터셋의 NaN(빈 값)을 처리하는 방법 중 하나는 그 빈 값이 위치한 컬럼의 평균값으로 빈 값을 대체 처리하는 것입니다.

다음의 스니펫 코드는 B 컬럼의 모든 빈 값(NaN)을 B 컬럼의 평균값으로 대체합니다.

>>> df.B = df.B.fillna(df.B.mean()) # NaN(빈 값)을 B 컬럼의 평균값으로 대체합니다.
>>> df

열 제거하기

데이터셋에서 빈 값(NaN)을 처리하는 다른 방법은 빈 값이 포함된 열을 제거하는 것입니다.

아래와 같이 dropna() 함수를 사용해서 처리할 수 있습니다.

>>> df = pd.read_csv('NaNDataset.csv')
>>> df = df.dropna()
>>> df

NaN이 포함된 행을 제거한 후에 인덱스 순번이 더 이상 맞지 않는다는 것을 알 수 있습니다.

인덱스를 재설정하고 싶다면, reset_index() 함수를 사용합니다.

>>> df = df.reset_index(drop=True) # 인덱스를 재설정합니다
>>> df

반응형

중복된 열 제거하기

다음 데이터로 된 DuplicateRows.csv 파일이 있다고 가정하겠습니다.

중복된 모든 열을 찾기 위해, 먼저 데이터셋을 데이터프레임에 로드합니다.

그리고, duplicated() 함수를 적용합니다.

>>> df = pd.read_csv('DuplicateRows.csv') # 판다스(Pandas) 라이브러리는 이미 로드했다고 가정합니다.
>>> df.duplicated(keep=False))

어떤 열이 중복되었는지 알려줍니다. 위 예에서는, 인덱스 1, 2, 5, 6열이 중복입니다. 

keep 인수를 사용하면 중복을 표시하는 방법을 지정할 수 있습니다.

  • 기본값은 'first' : 첫번째 나타나는 것을 제외한, 모든 중복이 True로 표시됩니다.
  • 'last' : 마지막으로 나타나는 것을 제외한, 모든 중복이 True로 표시됩니다.
  • False : 모든 중복이 True로 표시됩니다.

만약 keep 인수를 'first'로 설정하면, 다음과 같은 결과물을 보게 될 것입니다:

따라서, 모든 중복 열들을 보고 싶다면, keep 인수를 False로 설정해야 합니다. 

>>> df[df.duplicated(keep=False)]

중복 행을 삭제하려면 drop_duplicates() 함수를 사용할 수 있습니다.

>>> df.drop_duplicates(keep='first', inplace=True) # 처음 열은 그대로 두고, 그 다음 중복 열만 제거합니다.
>>> df

기본적으로, drop_duplicates() 함수는 원본 데이터프레임을 수정하지 않고, 제거된 열이 포함된 데이터프레임을 반환합니다.

만약 원본 데이터프레임을 수정하고 싶다면, inplace 파라미터를 True로 설정해야 합니다.

때로는 데이터셋의 특정 열에서 발견된 중복만 제거하고 싶은 경우가 있습니다.

예를 들어, 3, 4열의 B컬럼은 값이 다르지만, A, C 컬럼은 동일합니다. 이를 기준으로 제거해 보도록 하겠습니다.

>>> df.drop_duplicates(subset=['A', 'C'], keep='last', inplace=True) # A, C 컬럼에 모든 중복을 제거하고, 마지막 열을 남깁니다.
>>> df

컬럼 정규화하기

정규화는 데이터 정리 프로세스 중에 자주 적용되는 기술입니다.

정규화의 목적은 데이터 범위의 숫자 열 값을 변경하여, 값 범위의 차이를 수정하지 않고 공통 척도를 적용하는 것입니다.

일부 알고리즘은 데이터를 올바르게 모델링하기 위해 정규화가 중요합니다. 

예를 들어, 데이터셋 열 중 하나는 0에서 1까지의 값을 포함하고 다른 열은 400,000에서 500,000까지의 값을 가질 수 있습니다. 

두 개의 열을 사용하여 모델을 훈련하면 숫자의 척도가 크게 달라질 수 있습니다. 

정규화를 사용하면 두 열의 값 비율을 제한된 범위로 유지하면서 값의 비율을 유지할 수 있습니다.

판다스(Pandas)에서는 MinMaxScaler 클래스를 사용하여 각 열을 특정 값 범위로 확장할 수 있습니다.

다음 데이터로 된 NormalizeColumns.csv 파일이 있다고 가정하겠습니다.

다음 스니펫 코드는 모든 열의 값을 (0,1) 범위로 조정합니다.

>>> import pandas as pd
>>> from skleran import preprocessing
>>> df = pd.read_csv('NormalizeColumns.csv')
>>> x = df.values.astype(float)
>>> min_max_scaler = preprocessing.MinMaxScaler()
>>> x_scaled = min_max_scaler.fit_transform(x)
>>> df = pd.DataFrame(x_scaled, columns=df.columns)
>>> df

이상치(outlier) 제거하기

통계에서 이상치(이상점, outlier)는 관측된 다른 점들과 먼 지점의 점입니다.

예를 들어, 다음과 같은 값들(234, 267, 1, 200, 245, 300, 199, 250, 8999, 245)이 세트로 주어졌다고 하면, 이 중에서 명백하게 1과 8999는 이상치(oulier)입니다. 

그들은 나머지 값들과 뚜렷이 구별되며, 데이터셋의 대부분의 다른 값들과 달리 "바깥에 위치합니다". 

이상치는 주로 기록 또는 실험 오류의 오류로 인해 발생하며 머신러닝에서는 모델을 학습하기 전에 이상치를 제거해야 합니다. 

그렇지 않으면 모델을 왜곡시킬 수 있습니다.

이상치를 제거하는 데는 여러 가지 기술이 있으며,이번에서는 두 가지를 논의합니다.

  • Tukey Fences
  • Z-Score

Tukey Fences

Tukey Fences는 사분위 범위(IQR, interquartile range)를 기반으로 합니다. 

Q1이라고 표시된 첫번째 사분위수는 데이터셋의 값 중 첫번째 25 %를 보유하는 값입니다.

3분위수(Q3)은 데이터셋의 값 중 3번째의 25 %를 보유하는 값입니다. 

따라서, 정의에 따르면, IQR = Q3-Q1입니다.

아래 그림은 짝수 및 홀수 값을 가진 데이터셋에 대해 IQR을 얻는 방법의 예를 보여줍니다.

Tukey Fences에서 이상치(outlier)는 다음과 같은 값입니다.

  • Q1 - (1.5 * IQR) 미만 or
  • Q3 + (1.5 * IQR) 초과

다음 스니펫 코드는 파이썬을 사용해 Tukey Fences를 실행하는 방법을 보여줍니다.

>>> import numpy as np
>>> def outliers_iqr(data):
              q1, q3 = np.percentile(data, [25, 75])
              iqr = q3 - q1
              lower_bound = q1 - (iqr * 1.5)
              upper_bound = q3 + (iqr * 1.5)
              return np.where((data > upper_bound) | (data < lower_bound))

np.where() 함수는 조건에 만족하는 아이템들의 위치를 반환합니다. 

outliers_iqr() 함수는 첫 번째 요소가 이상치(oulier)값을 갖는 행의 인덱스 배열인 튜플을 반환합니다.

Tukey Fences를 테스트하기 위해, 부모와 자녀의 키에 대해 유명한 Galton 데이터셋을 사용해 보도록 하겠습니다. 

이 데이터셋에는 Francis Galton이 1885년에 실시한 유명한 아동 연구결과를 기반으로 한 데이터가 포함되어 있습니다. 

각각의 경우는 성인용이며 변수는 다음과 같습니다.

  • Family : 자녀가 속한 가족으로서 1에서 204 사이의 숫자와 136A로 표시됩니다.
  • Father : 아빠의 키(인치)
  • Mother : 엄마의 키(인치)
  • Gender : 아이들의 성, 남성(M) 또는 여성(F)
  • Height : 아이들의 키(인치)
  • Kids : 아이들의 가정에서, 아이들의 숫자

이 데이터셋은 898 케이스를 갖고 있습니다. 

먼저 데이터를 읽어들입니다:

>>> import pandas as pd
>>> df = pd.read_csv('http://www.mosaic-web.org/go/datasets/galton.csv')
>>> df.head()

height 컬럼에서 이상치(outlier)를 찾고 싶다면, 다음과 같이 outliers_iqr() 함수를 불러옵니다.

>>> print('Outliers using ourliers_iqr()')
>>> print('=====================')
>>> for i in outliers_iqr(df.height)[0]:
                 print(df[i:i+1])

다음과 같은 결과를 볼 수 있습니다:

Tukey Fences 메서드를 사용해, height 컬럼에 하나의 이상치(outlier)가 있다는 것을 알 수 있었습니다.

Z-Score

이상치(outlier)를 결정하는 두번째 방법은 Z-Score 메서드를 사용하는 것입니다. 

Z-Score는 데이터 포인트가 평균에서 얼마나 많은 표준 편차를 가지는지 나타냅니다.

Z-Score의 공식은 다음과 같습니다.

여기서 xi는 데이터 포인트, μ는 데이터셋의 평균, σ는 표준편차입니다.

  • 음의 Z-Score는 데이터 포인트가 평균보다 작음을 나타내고 양의 Z-Score는 문제의 데이터 포인트가 평균보다 큰 것을 나타냅니다.
  • Z-Score가 0이면 데이터 포인트가 중간(평균)이고 Z-Score가 1이면 데이터 포인트가 평균보다 1 표준편차가 높다는 것을 알 수 있습니다.
  • 3보다 크거나 -3보다 작은 모든 Z-Score는 이상치(outlier)로 간주됩니다.

다음 스니펫 코드는 파이썬을 사용해 Z-Score를 실행하는 방법을 보여줍니다.

>>> def outliers_z_score(data):
           threshold = 3
           mean = np.mean(data)
           std = np.std(data)
           z_scores = [(y - mean) / std for y in data]
           return np.where(np.abs(z_scores) > threshold)

이전에 사용한 것과 동일한 Galton 데이터셋에 대해 outliers_z_score()함수를 사용해 height 컬럼에 대한 이상치(outlier)를 찾을 수 있습니다.

>>> print('Outliers using ourliers_z_score()')
>>> print('=========================')
>>> for i in outliers_z_score(df.height)[0]:
                 print(df[i:i+1])

다음과 같은 결과물을 볼 수 있습니다.

Z- Score 메서드를 사용하면 height 컬럼에 3개의 이상치(outlier)가 있음을 알 수 있습니다.

(Source : Python Machine Learning, Wiley, 2019)

반응형
반응형

Scikit-learn 라이브러리는 파이썬에서 가장 유명한 머신러닝 라이브러리 중 하나로, 분류(classification), 회귀(regression), 군집화(clustering), 의사결정 트리(decision tree) 등의 다양한 머신러닝 알고리즘을 적용할 수 있는 함수들을 제공합니다.

이번에는 머신러닝 수행 방법을 알아보기 전에, 다양한 샘플 데이터를 확보할 수 있는 방법들을 알아보려고 합니다.  

데이터셋(Datasets) 얻기

머신러닝을 시작할 때, 간단하게 데이터셋을 얻어서 알고리즘을 테스트해 보는 것이 머신러닝을 이해하는데 있어 매우 유용합니다. 간단한 데이터셋으로 원리를 이해한 후, 실제 생활에서 얻을 수 있는 더 큰 데이터셋을 가지고 작업하는 것이 좋습니다.

우선 머신러닝을 연습하기 위해, 간단한 데이터셋을 얻을 수 있는 곳은 다음과 같습니다. 하나씩 차례대로 알아보도록 하겠습니다.

  • 사이킷런의 빌트인 데이터셋
  • 캐글(Kaggle) 데이터셋
  • UCI(캘리포니아 대학, 얼바인) 머신러닝 저장소

<사이킷런 데이터셋 사용하기>

사이킷런에는 머신러닝을 쉽게 배울 수 있도록 하기 위해, 샘플 데이터셋을 가지고 있습니다. 

샘플 데이터셋을 로드하기 위해, 데이터셋 모듈을 읽어들입니다. 다음은 Iris 데이터셋을 로드한 코드입니다.

>>> from sklearn import datasets
>>> iris = datasets.load_iris() # 아이리스 꽃 데이터셋 또는 피셔 아이리스 데이터셋은 영국의 통계 학자이자 생물학자인 로널드 피셔 (Ronald Fisher)가 소개한 다변수 데이터셋입니다. 데이터셋은 3종의 아이리스(Iris)로 된 50개 샘플로 구성되어 있습니다. 각 샘플로부터 4개의 피쳐(features:피쳐를 우리말로 변수 또는 요인이라고 표현하기도 함)를 측정할 수 있습니다: 꽃받침과 꽃잎의 길이와 너비입니다. 이러한 4가지 피쳐(features)의 결합을 바탕으로 피셔는 종을 서로 구분할 수 있는 선형 판별 모델을 개발했습니다. 

로드된 데이터셋은 속성-스타일 접근을 제공하는 파이썬 딕셔너리, 번치(bunch) 객체로 표현됩니다. 

>>> print(iris.DESCR) # DESCR 속성을 사용해 데이터셋의 정보를 다음과 같이 얻을 수 있습니다.

>>> print(iris.data) # data 속성을 사용해 피쳐를 알아볼 수 있습니다. 

>>> print(iris.feature_names) # feature_names 속성으로 피쳐 이름을 알아낼 수 있습니다.

이것은 데이터셋이 꽃받침 길이, 꽃받침 너비, 꽃잎 길이, 꽃잎 너비 등 4개의 컬럼들로 구성되어 있다는 것을 의미합니다.

꽃의 꽃잎(petal)과 꽃받침(sepal)

>>> print(iris.target) # 레이블을 알 수 있습니다.

>>> print(iris.target_names) # 레이블 이름을 알 수 있습니다.

여기서 0은 'setosa'를, 1은 'versicolor'를 2는 'virginica'를 나타냅니다.

(사이킷런의 모든 샘플 데이터가 feature_names, target_names 속성을 지원하는 것은 아닙니다)

여기서, 데이터를 쉽게 다루기 위해, 판다스(Pandas)의 데이터프레임으로 변환하는 것이 유용합니다.

>>> import pandas as pd # pandas 라이브러리를 읽어들입니다.
>>> df = pd.DataFrame(iris.data) 
>>> df.head()

<캐글(Kaggle) 데이터셋 사용하기>

 데이터 과학자 및 머신러닝 학습자들에게 있어, 캐글(Kaggle)은 세계에서 가장 큰 커뮤니티입니다.

머신러닝 경쟁을 제공하는 플랫폼에서 시작하여, 현재 캐글(Kaggle)은 공개 데이터 플랫폼과 데이터 과학자를 위한 클라우드 기반 워크 벤치도 제공합니다.

구글이 2017년 3월에 캐글(Kaggle)을 인수했습니다. 

우리는 머신러닝 학습자들을 위해, 캐글(Kaggle)에서 제공된 샘플 데이터셋을 이용할 수 있습니다.

몇가지 흥미로운 데이터셋이 있는데, 다음과 같습니다.

<캘리포니아 대학, 어바인의 머신러닝 저장소 사용하기>

캘리포니아 대학, 어바인의 머신러닝 저장소는 머신러닝 알고리즘의 데이터 생성 경험적 분석을 위해, 머신러닝 커뮤니티에서 사용하는 데이터베이스, 도메인 이론 및 데이터 생성기 모음입니다.

이 거대한 데이터셋 모음 중에서 흥미로운 몇가지 데이터셋을 살펴보면 다음과 같습니다.

< 직접 자신의 데이터셋 생성하기>

실험을 위한 적당한 데이터셋을 찾을 수가 없다면, 직접 자신의 데이터셋을 생성합니다.

사이킷런(Scikit-learn) 라이브러리의 sklearn.datasets.samples_generator 모듈에는 다양한 유형의 문제에 대해 서로 다른 유형의 데이터 세트를 생성할 수 있는 많은 함수가 포함되어 있습니다.

다음과 같은 데이터셋들을 만들 수 있습니다.

  • 선형으로 분산된 데이터셋
  • 군집화된 데이터셋
  • 순환 방식으로 분산되고 군집화된 데이터셋

1. 선형으로 분산된 데이터셋

make_regression() 함수를 사용해 선형으로 분산된 데이타를 생성합니다. 아웃풋에 적용된 가우스 노이즈의 표준 편차뿐만 아니라, 원하는 피쳐의 수를 지정할 수도 있습니다.

>>> % matplolib inline
>>> import matplotlib.pyplot as plt
>>> from sklearn.datasets.samples_generator import make_regression
>>> X, y = make_regression(n_samples=100, n_features=1, noise=5.4)
>>> plt.scatter(X, y)

2. 군집화된 데이터셋

make_blobs()함수는 n개의 무작위 데이터 클러스터를 생성합니다. 이것은 비지도(자율)학습에서 군집화를 수행할 때 매우 유용합니다.

>>> %matplotlib inline
>>> import matplotlib.pyplot as plt
>>> import numpy as np
>>> from sklearn.datasets import make_blobs
>>> X, y = make_blobs(500, centers=3) # 군집화를 위한 등방성 가우시안 블롭 생성
>>> rgb = np.array(['r', 'g', 'b'])
>>> plt.scatter(X[:, 0], X[:, 1], color=rgb[y]) # 산포도와 컬러 코딩을 사용해 그립니다.

3. 순환 방식으로 분산되고 군집화된 데이터셋

make_circles()함수는 두 개의 차원에 작은 원을 포함하는 큰 원이 포함된 임의의 데이터셋을 생성합니다. SVM(

Support Vector Machines)과 같은 알고리즘을 사용하여 분류(classifications)를 수행할 때 유용합니다.

>>> %matplotlib inline
>>> import matplotlib.pyplot as plt
>>> import numpy as np
>>> from sklearn.datasets import make_circles
>>> X, y = make_circles(n_samples=100, noise=0.09)
>>> rgb = np.array(['r', 'g', 'b'])
>>> plt.scatter(X[:, 0], X[:, 1], color=rgb[y])

다음 번에는 간단한 선형 회귀(linear regression) 알고리즘을 구현해 보면서 사이킷런(Scikit-Learn) 기초 사용법을 익혀 보겠습니다.

 

(Source : Python Machine Learning, Wiley, 2019)

 

반응형
반응형

이번에는 pandas에서 데이터를 삭제하는 방법에 대해 알아보고자 합니다.

1. pandas, numpy 라이브러리를 불러들입니다.

>>> import pandas as pd
>>> numpy as np

2. 다음 주소에서 데이터셋을 읽어들입니다.

>>> url = 'https://archive.ics.uci.edu/ml/machine-learning-databases/wine/wine.data'

3. 읽어들인 데이터셋을 wine 변수에 저장합니다.

>>> wine = pd.read_csv(url)
>>> wine.head()

4. 컬럼들 중에서 첫번째, 네번째, 일곱번째, 아홉번째, 열두번째, 열세번째, 열네번째 컬럼을 삭제합니다.

>>> wine = wine.drop(wine.columns[[0, 3, 6, 8, 11, 12, 13]], axis=1) # drop 메서드를 사용해서, 컬럼을 삭제합니다. axis=1 인수로 열을 삭제한다는 것을 명시합니다.
>>> wine.head()

5. 아래와 같이 열을 지정합니다. 

1) alcohol 2) malic_acid 3) alcalinity_of_ash 4) magnesium 5) flavanoids 6) proanthocyanins 7) hue

>>> wine.columns = ['alcohol', 'malic_acid', 'alcalinity_of_ash', 'magnesium', 'flavanoids', 'proanthocyanins', 'hue']
>>> wine.head()

6. alcohol 컬럼 첫 3행의 값을 NaN으로 설정합니다.

>>> wine.iloc[0:3, 0] = np.nan # iloc 메서드로 첫번째 열(0)부터 세번째 열(2)에, 첫번째 컬럼(0)에 적용합니다. 0부터 시작입니다.

>>> wine.head()

7. magnesium 컬럼의 3, 4행 값을 NaN으로 설정합니다.

>>> wine.iloc[2:4, 3] = np.nan # iloc 메서드로 세번째 열(2)부터 네번째 열(3)에, 세번째 컬럼(3)에 적용합니다. 0부터 시작입니다. 

>>> wine.head()

8. alcohol 컬럼의 NaN 값을 10으로 채우고, magnesium 컬럼의 NaN은 100으로 채웁니다.

>>> wine.alcohol.fillna(10, inplace = True) # fillna 메서드로 NaN 값을 10으로 바꿉니다. inplace=True로 다른 객체를 만드는 게 아니라 기존 객체를 바꿉니다.
>>> wine.magnesium.fillna(100, inplace = True) 
>>> wine.head()

9. 결측 값의 숫자를 합산합니다.

>>> wine.isnull().sum() # 결측 값을 가진 데이터가 없습니다.

10. 10까지의 범위에서 랜덤으로 숫자 배열을 생성합니다.

>>> random = np.random.randint(10, size = 10)
>>> random

11. 생성한 난수를 인덱스로 사용하고 각 셀에 NaN 값을 할당합니다.

>>> wine.alcohol[random] = np.nan
>>> wine.head(10)

12. 얼마나 많은 결측 값이 있는지 확인합니다.

>>> wine.isnull().sum()

13. 결측 값을 가진 행들을 삭제합니다.

>>> wine = wine.dropna(axis=0, how = 'any') # dropna 메서드로 결측값을 찾습니다. axis=0으로 행을 선택하고, how='any'로 하나라도 결측값이 있는 경우를 포함합니다.
>>> wine.head()

14. 인덱스를 재설정합니다. 

>>> wine = wine.reset_index(drop = True)
>>> wine.head()

 

(Source : Pandas exercises 깃헙)

반응형
반응형

1. pandas, numpy, matplotlib, seaborn 등 필요한 라이브러리를 읽어들입니다. 

>>> import pandas as pd
>>> import numpy as np
>>> import matplotlib.pyplot as plt # 파이썬에서 시각화를 처리하는데 필요한 대표적인 라이브러리로 생각하면 됩니다.
>>> import seaborn as sns # matplotlib를 바탕으로 해서 시각화를 더 멋지게 만들어줍니다.
% matplotlib inline # jupyter notebook(쥬피터 노트북) 내에서 그래프를 보여주도록 해줍니다.
sns.set(style='ticks') # 더 나은 스타일로 그래프를 보여주도록 seaborn을 설정합니다.

2. 다음 주소에서 데이터셋을 읽어들입니다.

>>> path = 'https://raw.githubusercontent.com/guipsamora/pandas_exercises/master/07_Visualization/Online_Retail/Online_Retail.csv'

3. online_rt라는 변수에 데이터셋을 할당합니다.

>>> online_rt = pd.read_csv(path, encoding = 'latin1') # encoding 인수로 적합한 언어 인코딩을 적용합니다.
>>> online_rt.head()

4. 영국을 제외하고 수량(Quantity)이 가장 많은 10개 국가에 대한 히스토그램을 만듭니다.

>>> countries = online_rt.groupby('Country').sum() # groupby 메서드를 사용해 국가별 합계를 구하고 countries 변수에 저장합니다.
>>> countries = countries.sort_values(by = 'Quantity', ascending=False) # sort_values 메서드로 정렬합니다. 이때 정렬 기준은 by인수를 사용해 'Quantity'로 정하고, ascending=False를 사용해 내림차순으로 정리합니다.
>>> countries['Quantity'].plot(kind='bar') # 그래프를 만듭니다. 
>>> plt.xlabel('Countries') # x축 라벨을 정합니다.
>>> plt.ylabel('Quantity') # y축 라벨을 정합니다.
>>> plt.title('10 Countries with most orders') # 제목을 정합니다.
>>> plt.show() # 그래프를 보여줍니다.

5. 마이너스 수량은 제외하도록 처리합니다.

>>> online_rt = online_rt[online_rt.Quantity > 0] # 수량이 0보다 큰 경우에만 선택해서 online_rt 변수에 재배정합니다.
>>> online_rt.head()

6. 상위 3개 국가의 고객 ID별 단가별 수량을 사용하여 산점도를 만듭니다.

>>> customers = online_rt.groupby(['CustomerID', 'Country']).sum() # groupby 메서드를 사용해 CustomerID와 Country 컬럼에 대한 합계를 구해 customers 변수에 저장합니다.
>>> customers = customers[customers.UnitPrice > 0] # UnitPrice가 0보다 큰 데이타만 customers 변수에 재할당합니다.
>>> customers['Country'] = customers.index.get_level_values(1) # index.get_level_values() 메서드로 요청한 수준의 인덱스를 반환합니다. 레벨은 0부터 시작합니다.
>>> top_countries = ['Netherlands', 'EIRE', 'Germany']
>>> customers = customers[customers['Country'].isin(top_countries)] # top_countries에서 정한 국가들을 선택하기 위해 데이터 프레임을 필터링합니다.
>>> g = sns.FacetGrid(customers, col='Country') # FaceGrid를 만듭니다. FaceGrid가 만드는 플롯은 흔히 "격자", "격자"또는 "작은 다중 그래픽"이라고 불립니다.
>>> g.map(plt.scatter, 'Quantity', 'UnitPrice', alpha=1) # map 메서드로 각 Facet의 데이터 하위 집합에 플로팅 기능을 적용합니다.
>>> g.add_legend() # 범례를 추가합니다.

7. 앞의 결과가 왜 이렇게 보잘 것 없는지를 조사합니다.

>>> customers = online_rt.groupby(['CustomerID', 'Country']).sum()
>>> customers

7-1. 수량(Quantity)과 단가(UnitPrice)를 별도로 보는 게 의미가 있을까?

>>> display(online_rt[online_rt.CustomerID == 12347.0].sort_values(by='UnitPrice', ascending=False).head())
>>> display(online_rt[online_rt.CustomerID == 12346.0].sort_values(by='UnitPrice', ascending=False).head()) # 고객ID 12346.0번은 다른 나라와 다르게 수량이 매우 많고, 단가는 매우 낮게 나옵니다. 그 이유를 알아볼 필요가 있어서 살펴보고자 합니다. 아래 데이터에서 보듯이 고객 ID 12346.0은 단 한건의 주문으로 대량 주문한 경우가 되겠습니다. 

7-2. 6번 최초의 질문으로 돌아가 보면, '상위 3개 국가의 고객 ID별 단가별 수량을 사용하여 산점도를 만듭니다'에 대해 구체화해서 생각해 봐야 합니다. 총 판매량이냐? 아니면 총 수익으로 계산해야 할 것인가? 먼저 판매량에 따라 분석해 보도록 하겠습니다.

>>> sales_volume = online_rt.groupby('Country').Quantity.sum().sort_values(ascending=False)
>>> top3 = sales_volume.index[1:4] # 영국을 제외합니다.
>>> top3

7-3. 이제 상위 3개국을 알게 되었습니다. 이제 나머지 문제에 집중합니다. 국가 ID는 쉽습니다. groupby 메서드로 'CustomerID'컬럼을 그룹핑하면 됩니다. 'Quantity per UnitPrice'부분이 까다롭습니다. 단순히 Quantity 또는 UnitPrice로 계산하는 것은 원하는 단가별 수량을 얻기 어렵습니다. 따라서, 두개 컬럼을 곱해 수익 'Revenue'라는 컬럼을 만듭니다.

>>> online_rt['Revenue'] = online_rt.Quantity * online_rt.UnitPrice
>>> online_rt.head()

7-4. 각 국가 주문별로 평균 가격(수익/수량)을 구합니다. 

>>> grouped = online_rt[online_rt.Country.isin(top3)].groupby(['CustomerID', 'Country])
>>> plottable = grouped['Quantity', 'Revenue'].agg('sum')
>>> plottable['Country'] = plottable.index.get_level_values(1)
>>> plottable.head()

7-5. 그래프 그리기.

>>> g = sns.FacetGrid(plottable, col='Country') # FaceGrid를 만듭니다. FaceGrid가 만드는 플롯은 흔히 "격자", "격자"또는 "작은 다중 그래픽"이라고 불립니다.
>>> g.map(plt.scatter, 'Quantity', 'AvgPrice', alpha=1) # map 메서드로 각 Facet의 데이터 하위 집합에 플로팅 기능을 적용합니다.
>>> g.add_legend() # 범례를 추가합니다.

7-6. 아직 그래프의 정보가 만족스럽지 못합니다. 많은 데이타가 수량은 50000 미만, 평균 가격은 5 이하인 경우라는 것을 확인할 수 있습니다. 트렌드를 볼 수 있을 것 같은데, 이 3개국 만으로는 부족합니다.

>>> grouped = online_rt.groupby(['CustomerID'])
>>> plottable = grouped['Quantity', 'Revenue'].agg('sum')
>>> plottable['AvgPrice'] = plottable.Revenue / plottable.Quantity
>>> plt.scatter(plottable.Quantity, plottable.AvgPrice)
>>> plt.plot()

7-7. 커브를 명확하게 보기 위해 확대해 봅니다.

>>> grouped = online_rt.groupby(['CustomerID', 'Country'])
>>> plottable = grouped.agg({'Quantity' : 'sum', 'Revenue' : 'sum'})
>>> plottable['AvgPrice'] = plottable.Revenue / plottable.Quantity
>>> plt.scatter(plottable.Quantity, plottable.AvgPrice)
>>> plt.xlim(-40, 2000) # 확대하기 위해 x축을 2000까지만 표시합니다.
>>> plt.ylim(-1, 80) # y축은 80까지만 표시합니다.
>>> plt.plot() # 아래 그래프에서 우리는 인사이트를 볼 수 있습니다. 평균 가격이 높아질수록, 주문 수량은 줄어든다는 것입니다. 

8. 단가 (x) 당 수익 (y)을 보여주는 선형 차트를 그립니다.

8-1. 가격 [0~50]을 간격 1로하여 단가를 그룹화하고 수량과 수익을 그룹핑니다.

>>> price_start = 0
>>> price_end = 50
>>> price_interval = 1
>>> buckets = np.arange(price_start, price_end, price_interval)
>>> revenue_per_price = online_rt.groupby(pd.cut(online_rt.UnitPrice, buckets)).Revenue.sum()
>>> revenue_per_price.head()

8-2. 그래프를 그려봅니다.

>>> revenue_per_price.plot()
>>> plt.xlabel('Unit Price (in intervals of ' +str(price_interval_+')')
>>> plt.ylabel('Revenue')
>>> plt.show()

8-3. 좀 더 멋지게 그려보도록 합니다.

>>> revenue_per_price.plot()
>>> plt.xlabel('Unit Price (in buckets of '+str(price_interval)+')')
>>> plt.ylabel('Revenue')
>>> plt.xticks(np.arange(price_start, price_end, 3), np.arange(price_start, price_end, 3))
>>> plt.yticks(0, 500000, 1000000, 1500000, 2000000, 2500000], ['0', '$0.5M', '$1M', '$1.5M', '$2M', '$2.5M'])
>>> plt.show()

(Source : Pandas exercises 깃헙)

반응형
반응형

판다스(Pandas)의 기능 중 데이터셋으로 기본적인 통계작업을 하는 명령어들을 알아보도록 합니다.

1. pandas 및 datetime 라이브러리를 읽어들입니다. 

>>> import pandas as pd
>>> import datetime

2. data_url 변수에 다음 주소를 저장합니다.

>>> data_url = 'https://raw.githubusercontent.com/guipsamora/pandas_exercises/master/06_Stats/Wind_Stats/wind.data'

3. pandas로 위 주소를 data 변수로 읽어들이되, 처음 3개 컬럼을 datetime 인덱스로 대체합니다.

>>> data = pd.read_table(data_url, sep = '\s+', parse_dates = [[0, 1, 2]]) # parse_dates 인수는 불린값 또는 숫자 리스트 또는 여러 컬럼들 값을 읽어들여서 날짜로 처리할 수 있습니다. 여기서는 맨 앞에 3개의 컬럼 값으로 날짜를 인식하도록 합니다.
>>> data.head() # 데이터셋의 구조를 알아보기 위해 상위 열 5개를 조회합니다.

4. 년도가 2061? 이 년도의 데이터가 실제로 있을까요? 이것을 수정해서 적용할 수 있는 함수를 만들어 봅시다.

>>> def fix_century(x):
               year = x.year - 100 if x.year > 1989 else x.year
               return datetime.date(year, x.month, x.day)      # 년도 데이터를 1900년대와 2000년대 구분을 위해 1989보다 많은 경우에는 1900년대으로 변경하도록 if문으로 간단한 함수를 만듭니다.
>>> data['Yr_Mo_Dy'] = data['Yr_Mo_Dy'].apply(fix_century) # apply 메서드를 사용해 'Yr_Mo_Dy'] 컬럼 전체에 함수를 적용합니다. 
>>> data.head() # 다시 데이터셋의 구조를 알아보기 위해 상위 열 5개를 조회합니다.

5. 날짜를 인덱스로 설정합니다. 이때 데이터 타입을 변경해서 적용해야 합니다. 데이터 타입은 datetime64[ns]여야 합니다.

>>> data['Yr_Mo_Dr'] = pd.to_datetime(data['Yr_Mo_Dy']) # 'Yr_Mo_Dy' 컬럼의 데이터 타입을 datetime64[ns]로 변경합니다.
>>> data = data.set_index('Yr_Mo_Dy') # set_index 메서드를 사용해 'Yr_Mo_Dy' 컬럼을 인덱스로 설정합니다.
>>> data.head()

6. 전체 데이터 값의 각 컬럼별 누락된 값을 알아봅니다. 

>>> data.isnull().sum() # 각 컬럼 값들 중에서 결측 값(Null)이 있는 곳의 갯수를 확인합니다.

7. 결측 값을 가진 데이터를 제외한 전체 데이터를 계산해 봅니다.

>>> data.shape[0] - data.isnull().sum()

또는

>>> data.notnull().sum()

8. 모든 위치와 전체 시간의 풍속에 대한 평균 값을 계산합니다.

>>> data.fillna(0).values.flatten().mean() # 결측값을 fillna(0)를 사용해 0으로 대체합니다. 그 후 dataframe을 list로 변경하는 flatten() 메서드를 사용한 후, 평균 값을 계산합니다.
>>> 10.223864592840483

9.  data의 각종 통계 수치를 한눈에 볼 수 있도록 표시해 봅니다.

>>> data.describe(percentiles=[])

10. day_stats라는 데이터 프레임을 만들고 모든 위치 및 전체 시간에 대한 풍속의 최소, 최대 및 평균 풍속 및 표준편차를 계산합니다.

>>> day_stats = pd.DataFrame()
>>> day_stats['min'] = data.min(axis = 1) # 최소값
>>> day_stats['max'] = data.max(axis = 1) # 최대값
>>> day_stats['mean'] = data.mean(axis = 1) # 평균
>>> day_stats['std'] = data.std(axis = 1) # 표준편차

11. 각 위치에 대한 1월의 평균 풍속을 찾아 봅니다.

>>> data.loc[data.index.month == 1].mean()

12. 연간 빈도로 각 위치별로 레코드를 다운 샘플링합니다.

>>> data.groupby(data.index.to_period('A')).mean()

13. 월간 빈도로 각 위치별로 레코드를 다운 샘플링합니다.

>>> data.groupby(data.index.to_period('M')).mean()

14. 주간 빈도로 각 위치별로 레코드를 다운 샘플링합니다.

>>> data.groupby(data.index.to_period('W')).mean()

15. 처음 52주 동안, 매주 모든 지역 풍속의 최소, 최대 및 평균 풍속 및 표준 편차를 계산합니다.

>>> weekly = data.resample('W').agg(['min', 'max', 'mean', 'std']) # 데이터를 'W(주)'에 재샘플링하고 agg 메서드를 사용해 최소, 최대, 평균, 표준편차 함수를 적용합니다.
>>> weekly.loc[weekly.index[1:53], 'RPT':'MAL'].head(10) # 처음 52주 동안의 값들 중 상위 10개 데이터 열을 보여줍니다.

(Source : Pandas exercises 깃헙)

반응형
반응형

1. pandas 라이브러리를 읽어들입니다.

>>> import pandas as pd

2. 다음 데이터로 3개의 딕셔너리 데이터셋을 만듭니다.

>>> raw_data_1 = { 'subject_id' : ['1', '2', '3', '4', '5'], 'first_name' : ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'], 'last_name' : ['Anderson', 'Ackerman', 'Ali', 'Aoni', 'Atiches']}
>>> raw_data_2 = {'subject_id' : ['4', '5', '6', '7', '8'], 'first_name' : ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'], 'last_name' : ['Bonder', 'Black', 'Balwner', 'Brice', 'Btisan']}
>>> raw_data_3 = {'subject_id' : ['1', '2', '3', '4', '5', '7', '8', '9', '10', '11'], 'test_id' : [51, 15, 61, 16, 14, 15, 1, 61, 16]}

3. data1, data2, data3라는 변수에 각각 할당합니다.

>>> data1 = pd.DataFrame(raw_data_1, columns = ['subject_id', 'first_name', 'last_name'])
>>> data2 = pd.DataFrame(raw_data_2, columns = ['subject_id', 'first_name', 'last_name'])
>>> data3 = pd.DataFrame(raw_data_3, columns = ['subject_id', 'test_id'])

4. 행을 따라 두 개의 dataframe을 결합하고 all_data 변수에 할당합니다.

>>> all_data = pd.concat([data1, data2])
>>> all_data

5. 컬럼에 따라 두개의 dataframe을 결합하고 all_data_col 변수에 할당합니다.

>>> all_data_col = pd.concat([data1, data2], axis = 1)
>>> all_data_col

6. data3을 출력합니다.

>>> data3

7. subject_id 값을 통해 all_data와 data3를 병합합니다.

>>> pd.merge(all_data, data3, on='subject_id') # on 인수를 통해 기준열을 명시했습니다

8. data1과 data2에 동일한 'subject_id'가 있는 데이터만 병합합니다.

>>> pd.merge(data1, data2, on='subject_id', how='inner') # how 인수를 통해 양쪽 데이터프레임 모두 키가 존재하는 데이터만 보여줍니다. how 인수로 명시하지 않아도 기본적으로 'inner'를 적용한 것으로 처리하기 때문에 양쪽 모두 존재하는 데이터만 보여줍니다.

9. data1과 data2의 키 값이 한쪽에만 있더라도 모든 값들을 병합합니다. 

>>> pd.merge(data1, data2, on='subject_id', how='outer') # 값이 없는 필드에는 NaN(Null 값)으로 표시합니다.

(Source : Pandas exercises 깃헙)

반응형

+ Recent posts