파이썬과 Scikit-Learn을 사용하여 로지스틱 회귀를 구현해보자
이번에 해볼것은 파이썬과 Scikit-Learn을 사용하여 로지스틱 회귀(Logistic Regression)를 구현합니다.
오늘의 날씨가 내일 비가 올지 여부를 예측하는 로지스틱 회귀 분류기를 구축합니다.
로지스틱 회귀를 사용하여 이진 분류 모델을 훈련합니다.
1. 로지스틱 회귀 소개
데이터 과학자들이 새로운 분류 문제를 마주할 때, 가장 먼저 떠오르는 알고리즘은 로지스틱 회귀(Logistic Regression)입니다.
이것은 이산적인 클래스에 대한 예측을 수행하는 지도 학습 분류 알고리즘입니다.
실제로는 관측치를 다른 범주로 분류하는 데 사용됩니다.
따라서 출력값은 이산적인 특성을 가집니다.
로지스틱 회귀는 또한 로짓 회귀(Logit Regression)라고도 불립니다.
이것은 가장 간단하고 직관적이며 다목적으로 사용되는 분류 알고리즘 중 하나이며 분류 문제를 해결하는 데 사용됩니다.
2. 로지스틱 회귀 직관
통계학에서 로지스틱 회귀 모델은 주로 분류를 위해 사용되는 널리 사용되는 통계 모델입니다.
즉, 주어진 관측치 집합에 대해 로지스틱 회귀 알고리즘이 이러한 관측치를 두 개 이상의 이산 클래스로 분류하는 데 도움을 줍니다.
따라서 대상 변수는 이산적인 특성을 가집니다.
로지스틱 회귀 알고리즘은 아래와 같이 작동합니다
선형 방정식 구현
로지스틱 회귀 알고리즘은 독립 또는 설명 변수로 선형 방정식을 구현하여 반응 값을 예측하는 방식으로 작동합니다.
예를 들어, 학습한 시간과 시험 합격 확률의 예를 고려해보겠습니다.
여기서, 학습한 시간은 설명 변수이며 x1로 표시됩니다.
시험 합격 확률은 반응 또는 대상 변수이며 z로 표시됩니다.
만약 설명 변수(x1)와 반응 변수(z)가 하나씩이라면, 선형 방정식은 다음과 같이 수학적으로 표현됩니다.
1
2
3
z = β0 + β1x1
여기서 계수 β0와 β1은 모델의 매개 변수입니다.
여러 개의 설명 변수가 있는 경우, 위의 방정식은 다음과 같이 확장될 수 있습니다.
1
2
3
z = β0 + β1x1+ β2x2+……..+ βnxn
여기서 계수 β0, β1, β2 및 βn은 모델의 매개 변수입니다.
따라서 예측된 반응 값은 위의 방정식에 의해 주어지며 z로 표시됩니다.
Sigmoid 함수
예측된 반응 값을 z로 표시하고 이 값을 0과 1 사이의 확률 값으로 변환합니다.
확률 값으로 변환하기 위해서는 sigmoid 함수를 사용합니다.
이 sigmoid 함수는 어떤 실수 값을 0과 1 사이의 확률 값으로 변환합니다.
기계 학습에서는 sigmoid 함수를 사용하여 예측을 확률로 매핑합니다.
sigmoid 함수는 S 모양의 곡선을 가지며 sigmoid 곡선이라고도 합니다.
Sigmoid 함수는 Logistic 함수의 특수한 경우입니다.
다음 수학적 공식으로 주어집니다.
그래프로는 sigmoid 함수를 다음과 같이 표현할 수 있습니다.
Sigmoid Function
결정 경계 (Decision boundary)
sigmoid 함수는 0과 1 사이의 확률 값을 반환합니다. 이 확률 값을 “0” 또는 “1”인 이진 분류로 매핑해야 합니다. 이를 위해 우리는 결정 경계(Decision boundary)라는 임계값을 선택합니다. 이 결정 경계 위에 있는 확률 값은 클래스 1로 매핑되고, 결정 경계 아래에 있는 값은 클래스 0으로 매핑됩니다.
수학적으로는 다음과 같이 표현할 수 있습니다:
p ≥ 0.5 => class = 1
p < 0.5 => class = 0
일반적으로 결정 경계는 0.5로 설정됩니다. 따라서 확률 값이 0.8 (> 0.5)이면 해당 관측치를 클래스 1로 매핑하고, 확률 값이 0.2 (< 0.5)이면 해당 관측치를 클래스 0으로 매핑합니다. 이것은 아래 그래프에서 나타낼 수 있습니다.
예측하기
이제 로지스틱 회귀에서 시그모이드 함수와 결정 경계에 대해 알게 되었습니다. 이 지식을 활용하여 예측 함수를 작성할 수 있습니다.
로지스틱 회귀의 예측 함수는 관측값이 양성, 즉 Yes나 True일 확률을 반환합니다. 이를 class 1로 표시하며 P(class = 1)로 나타냅니다. 만약 확률이 1에 가까워진다면, 우리는 관측값이 class 1에 속한다는 모델에 대해 더욱 자신감을 가지게 됩니다.
그렇지 않다면, class 0에 속한다고 예측할 것입니다.
3. 로지스틱 회귀분석 가정
로지스틱 회귀분석 모델은 몇 가지 핵심 가정이 필요합니다. 이것들은 다음과 같습니다:
로지스틱 회귀분석 모델은 종속 변수가 바이너리, 다항식 또는 서열적인 성격을 가지도록 요구합니다.
관찰값은 서로 독립적이어야 합니다. 즉, 반복 측정으로부터 얻어진 것이 아니어야 합니다.
로지스틱 회귀분석 알고리즘은 독립 변수 사이에 다중공선성(multicollinearity)이 없거나 거의 없어야 합니다. 즉, 독립 변수들은 서로 높은 상관관계를 가지면 안됩니다.
로지스틱 회귀분석 모델은 독립 변수와 로그 오즈(log odds)의 선형성을 가정합니다.
로지스틱 회귀분석 모델의 성공은 표본 크기에 따라 달라집니다. 보통 높은 정확도를 달성하려면 큰 샘플 크기가 필요합니다.
4. 로지스틱 회귀의 유형
로지스틱 회귀 모델은 목표 변수의 범주에 따라 세 가지 그룹으로 분류됩니다. 이 세 가지 그룹은 다음과 같이 설명됩니다.
- 이항 로지스틱 회귀
이항 로지스틱 회귀에서 대상 변수는 두 가지 가능한 범주를 갖습니다. 일반적인 예로는 예 또는 아니오, 좋은 또는 나쁜, 참 또는 거짓, 스팸 또는 스팸 아님, 합격 또는 불합격 등이 있습니다.
- 다항 로지스틱 회귀
다항 로지스틱 회귀에서 대상 변수는 세 개 이상의 범주를 갖으며 특정한 순서가 없습니다. 따라서 세 개 이상의 명목 범주가 있습니다. 예를 들어 과일 범주는 사과, 망고, 오렌지 및 바나나 등이 있습니다.
- 순서형 로지스틱 회귀
순서형 로지스틱 회귀에서 대상 변수는 세 개 이상의 서열 범주를 갖습니다. 따라서 범주에 내재된 순서가 있습니다. 예를 들어 학생 성적은 나쁨, 보통, 좋음 및 우수 등으로 분류될 수 있습니다.
5. 라이브러리 가져오기
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# This Python 3 environment comes with many helpful analytics libraries installed
# It is defined by the kaggle/python docker image: https://github.com/kaggle/docker-python
# For example, here's several helpful packages to load in
import numpy as np # linear algebra
import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
import matplotlib.pyplot as plt # data visualization
import seaborn as sns # statistical data visualization
%matplotlib inline
# Input data files are available in the "../input/" directory.
# For example, running this (by clicking run or pressing Shift+Enter) will list all files under the input directory
import os
for dirname, _, filenames in os.walk('/kaggle/input'):
for filename in filenames:
print(os.path.join(dirname, filename))
# Any results you write to the current directory are saved as output.
/kaggle/input/weather-dataset-rattle-package/weatherAUS.csv
1
2
3
import warnings
warnings.filterwarnings('ignore')
6. 데이터 세트 가져오기
1
2
3
data = '/kaggle/input/weather-dataset-rattle-package/weatherAUS.csv'
df = pd.read_csv(data)
7. 탐색적 데이터 분석
1
2
3
# view dimensions of dataset
df.shape
(142193, 24)
데이터 집합에 142193개의 인스턴스와 24개의 변수가 있음을 알 수 있습니다.
1
2
3
# preview the dataset
df.head()
| Date | Location | MinTemp | MaxTemp | Rainfall | Evaporation | Sunshine | WindGustDir | WindGustSpeed | WindDir9am | ... | Humidity3pm | Pressure9am | Pressure3pm | Cloud9am | Cloud3pm | Temp9am | Temp3pm | RainToday | RISK_MM | RainTomorrow | |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 0 | 2008-12-01 | Albury | 13.4 | 22.9 | 0.6 | NaN | NaN | W | 44.0 | W | ... | 22.0 | 1007.7 | 1007.1 | 8.0 | NaN | 16.9 | 21.8 | No | 0.0 | No |
| 1 | 2008-12-02 | Albury | 7.4 | 25.1 | 0.0 | NaN | NaN | WNW | 44.0 | NNW | ... | 25.0 | 1010.6 | 1007.8 | NaN | NaN | 17.2 | 24.3 | No | 0.0 | No |
| 2 | 2008-12-03 | Albury | 12.9 | 25.7 | 0.0 | NaN | NaN | WSW | 46.0 | W | ... | 30.0 | 1007.6 | 1008.7 | NaN | 2.0 | 21.0 | 23.2 | No | 0.0 | No |
| 3 | 2008-12-04 | Albury | 9.2 | 28.0 | 0.0 | NaN | NaN | NE | 24.0 | SE | ... | 16.0 | 1017.6 | 1012.8 | NaN | NaN | 18.1 | 26.5 | No | 1.0 | No |
| 4 | 2008-12-05 | Albury | 17.5 | 32.3 | 1.0 | NaN | NaN | W | 41.0 | ENE | ... | 33.0 | 1010.8 | 1006.0 | 7.0 | 8.0 | 17.8 | 29.7 | No | 0.2 | No |
5 rows × 24 columns
1
2
3
col_names = df.columns
col_names
Index(['Date', 'Location', 'MinTemp', 'MaxTemp', 'Rainfall', 'Evaporation',
'Sunshine', 'WindGustDir', 'WindGustSpeed', 'WindDir9am', 'WindDir3pm',
'WindSpeed9am', 'WindSpeed3pm', 'Humidity9am', 'Humidity3pm',
'Pressure9am', 'Pressure3pm', 'Cloud9am', 'Cloud3pm', 'Temp9am',
'Temp3pm', 'RainToday', 'RISK_MM', 'RainTomorrow'],
dtype='object')
RISK_MM 변수 삭제
데이터 세트 설명에서 RISK_MM feature variable을 제거해야한다고 명시되어 있으므로, 다음과 같이 제거해야 합니다.
1
df.drop(['RISK_MM'], axis=1, inplace=True)
1
2
3
# view summary of dataset
df.info()
<class 'pandas.core.frame.DataFrame'> RangeIndex: 142193 entries, 0 to 142192 Data columns (total 23 columns): Date 142193 non-null object Location 142193 non-null object MinTemp 141556 non-null float64 MaxTemp 141871 non-null float64 Rainfall 140787 non-null float64 Evaporation 81350 non-null float64 Sunshine 74377 non-null float64 WindGustDir 132863 non-null object WindGustSpeed 132923 non-null float64 WindDir9am 132180 non-null object WindDir3pm 138415 non-null object WindSpeed9am 140845 non-null float64 WindSpeed3pm 139563 non-null float64 Humidity9am 140419 non-null float64 Humidity3pm 138583 non-null float64 Pressure9am 128179 non-null float64 Pressure3pm 128212 non-null float64 Cloud9am 88536 non-null float64 Cloud3pm 85099 non-null float64 Temp9am 141289 non-null float64 Temp3pm 139467 non-null float64 RainToday 140787 non-null object RainTomorrow 142193 non-null object dtypes: float64(16), object(7) memory usage: 25.0+ MB
변수 유형
이 섹션에서는 데이터 세트를 범주형 변수와 수치형 변수로 구분합니다.
데이터 세트에는 범주형 변수와 수치형 변수가 혼합되어 있습니다. 범주형 변수는 데이터 유형 개체를 가지며 수치형 변수는 데이터 유형 float64를 가집니다.
먼저 범주형 변수를 찾아보겠습니다.
1
2
3
4
5
6
7
# find categorical variables
categorical = [var for var in df.columns if df[var].dtype=='O']
print('There are {} categorical variables\n'.format(len(categorical)))
print('The categorical variables are :', categorical)
There are 7 categorical variables The categorical variables are : ['Date', 'Location', 'WindGustDir', 'WindDir9am', 'WindDir3pm', 'RainToday', 'RainTomorrow']
1
2
3
# view the categorical variables
df[categorical].head()
| Date | Location | WindGustDir | WindDir9am | WindDir3pm | RainToday | RainTomorrow | |
|---|---|---|---|---|---|---|---|
| 0 | 2008-12-01 | Albury | W | W | WNW | No | No |
| 1 | 2008-12-02 | Albury | WNW | NNW | WSW | No | No |
| 2 | 2008-12-03 | Albury | WSW | W | WSW | No | No |
| 3 | 2008-12-04 | Albury | NE | SE | E | No | No |
| 4 | 2008-12-05 | Albury | W | ENE | NW | No | No |
변수 요약
Date 변수가 있습니다.
Location, WindGustDir, WindDir9am, WindDir3pm, RainToday, RainTomorrow와 같이 6개의 범주형 변수가 있습니다.
RainToday와 RainTomorrow 변수는 이진 범주형 변수입니다.
RainTomorrow 변수는 타겟 변수입니다.
범주형 변수에서 결측값 탐색
먼저, 범주형 변수를 탐색해보겠습니다.
아래는 범주형 변수에서의 결측값 탐색입니다.
1
2
3
# check missing values in categorical variables
df[categorical].isnull().sum()
Date 0 Location 0 WindGustDir 9330 WindDir9am 10013 WindDir3pm 3778 RainToday 1406 RainTomorrow 0 dtype: int64
1
2
3
4
5
# print categorical variables containing missing values
cat1 = [var for var in categorical if df[var].isnull().sum()!=0]
print(df[cat1].isnull().sum())
WindGustDir 9330 WindDir9am 10013 WindDir3pm 3778 RainToday 1406 dtype: int64
데이터셋에서 결측값을 가진 범주형 변수 4개
-
WindGustDir
-
WindDir9am
-
WindDir3pm
-
RainToday
범주형 변수의 빈도 수
이제 범주형 변수의 빈도수를 확인해보겠습니다.
1
2
3
4
5
# view frequency of categorical variables
for var in categorical:
print(df[var].value_counts())
2014-04-15 49
2013-08-04 49
2014-03-18 49
2014-07-08 49
2014-02-27 49
..
2007-11-01 1
2007-12-30 1
2007-12-12 1
2008-01-20 1
2007-12-05 1
Name: Date, Length: 3436, dtype: int64
Canberra 3418
Sydney 3337
Perth 3193
Darwin 3192
Hobart 3188
Brisbane 3161
Adelaide 3090
Bendigo 3034
Townsville 3033
AliceSprings 3031
MountGambier 3030
Ballarat 3028
Launceston 3028
Albany 3016
Albury 3011
PerthAirport 3009
MelbourneAirport 3009
Mildura 3007
SydneyAirport 3005
Nuriootpa 3002
Sale 3000
Watsonia 2999
Tuggeranong 2998
Portland 2996
Woomera 2990
Cobar 2988
Cairns 2988
Wollongong 2983
GoldCoast 2980
WaggaWagga 2976
NorfolkIsland 2964
Penrith 2964
SalmonGums 2955
Newcastle 2955
CoffsHarbour 2953
Witchcliffe 2952
Richmond 2951
Dartmoor 2943
NorahHead 2929
BadgerysCreek 2928
MountGinini 2907
Moree 2854
Walpole 2819
PearceRAAF 2762
Williamtown 2553
Melbourne 2435
Nhil 1569
Katherine 1559
Uluru 1521
Name: Location, dtype: int64
W 9780
SE 9309
E 9071
N 9033
SSE 8993
S 8949
WSW 8901
SW 8797
SSW 8610
WNW 8066
NW 8003
ENE 7992
ESE 7305
NE 7060
NNW 6561
NNE 6433
Name: WindGustDir, dtype: int64
N 11393
SE 9162
E 9024
SSE 8966
NW 8552
S 8493
W 8260
SW 8237
NNE 7948
NNW 7840
ENE 7735
ESE 7558
NE 7527
SSW 7448
WNW 7194
WSW 6843
Name: WindDir9am, dtype: int64
SE 10663
W 9911
S 9598
WSW 9329
SW 9182
SSE 9142
N 8667
WNW 8656
NW 8468
ESE 8382
E 8342
NE 8164
SSW 8010
NNW 7733
ENE 7724
NNE 6444
Name: WindDir3pm, dtype: int64
No 109332
Yes 31455
Name: RainToday, dtype: int64
No 110316
Yes 31877
Name: RainTomorrow, dtype: int64
1
2
3
4
5
# view frequency distribution of categorical variables
for var in categorical:
print(df[var].value_counts()/np.float(len(df)))
2014-04-15 0.000345
2013-08-04 0.000345
2014-03-18 0.000345
2014-07-08 0.000345
2014-02-27 0.000345
...
2007-11-01 0.000007
2007-12-30 0.000007
2007-12-12 0.000007
2008-01-20 0.000007
2007-12-05 0.000007
Name: Date, Length: 3436, dtype: float64
Canberra 0.024038
Sydney 0.023468
Perth 0.022455
Darwin 0.022448
Hobart 0.022420
Brisbane 0.022230
Adelaide 0.021731
Bendigo 0.021337
Townsville 0.021330
AliceSprings 0.021316
MountGambier 0.021309
Ballarat 0.021295
Launceston 0.021295
Albany 0.021211
Albury 0.021175
PerthAirport 0.021161
MelbourneAirport 0.021161
Mildura 0.021147
SydneyAirport 0.021133
Nuriootpa 0.021112
Sale 0.021098
Watsonia 0.021091
Tuggeranong 0.021084
Portland 0.021070
Woomera 0.021028
Cobar 0.021014
Cairns 0.021014
Wollongong 0.020979
GoldCoast 0.020957
WaggaWagga 0.020929
NorfolkIsland 0.020845
Penrith 0.020845
SalmonGums 0.020782
Newcastle 0.020782
CoffsHarbour 0.020768
Witchcliffe 0.020761
Richmond 0.020753
Dartmoor 0.020697
NorahHead 0.020599
BadgerysCreek 0.020592
MountGinini 0.020444
Moree 0.020071
Walpole 0.019825
PearceRAAF 0.019424
Williamtown 0.017954
Melbourne 0.017125
Nhil 0.011034
Katherine 0.010964
Uluru 0.010697
Name: Location, dtype: float64
W 0.068780
SE 0.065467
E 0.063794
N 0.063526
SSE 0.063245
S 0.062936
WSW 0.062598
SW 0.061867
SSW 0.060552
WNW 0.056726
NW 0.056283
ENE 0.056205
ESE 0.051374
NE 0.049651
NNW 0.046142
NNE 0.045241
Name: WindGustDir, dtype: float64
N 0.080123
SE 0.064434
E 0.063463
SSE 0.063055
NW 0.060144
S 0.059729
W 0.058090
SW 0.057928
NNE 0.055896
NNW 0.055136
ENE 0.054398
ESE 0.053153
NE 0.052935
SSW 0.052380
WNW 0.050593
WSW 0.048125
Name: WindDir9am, dtype: float64
SE 0.074990
W 0.069701
S 0.067500
WSW 0.065608
SW 0.064574
SSE 0.064293
N 0.060952
WNW 0.060875
NW 0.059553
ESE 0.058948
E 0.058667
NE 0.057415
SSW 0.056332
NNW 0.054384
ENE 0.054321
NNE 0.045319
Name: WindDir3pm, dtype: float64
No 0.768899
Yes 0.221213
Name: RainToday, dtype: float64
No 0.775819
Yes 0.224181
Name: RainTomorrow, dtype: float64
레이블 수: 카디널리티
범주형 변수 내 라벨(label)의 수를 cardinality(카디널리티) 라고 합니다.
변수 내 라벨 수가 많을 경우, 이를 높은 카디널리티(high cardinality) 라고 합니다.
높은 카디널리티는 머신 러닝 모델에서 심각한 문제를 일으킬 수 있으므로, 높은 카디널리티를 확인해 보는 것이 좋습니다.
1
2
3
4
5
# check for cardinality in categorical variables
for var in categorical:
print(var, ' contains ', len(df[var].unique()), ' labels')
Date contains 3436 labels Location contains 49 labels WindGustDir contains 17 labels WindDir9am contains 17 labels WindDir3pm contains 17 labels RainToday contains 3 labels RainTomorrow contains 2 labels
Date 변수가 있는 것을 확인할 수 있습니다. 이 변수는 전처리가 필요합니다. 다른 변수들은 상대적으로 적은 수의 변수를 가지고 있습니다.
날짜 변수의 기능 엔지니어링
1
df['Date'].dtypes
dtype('O')
Date 변수의 데이터 타입이 object인 것을 확인할 수 있습니다. 따라서, object로 인코딩 된 날짜 데이터를 datetime 형식으로 변환할 것입니다.
1
2
3
# parse the dates, currently coded as strings, into datetime format
df['Date'] = pd.to_datetime(df['Date'])
1
2
3
4
5
# extract year from date
df['Year'] = df['Date'].dt.year
df['Year'].head()
0 2008 1 2008 2 2008 3 2008 4 2008 Name: Year, dtype: int64
1
2
3
4
5
# extract month from date
df['Month'] = df['Date'].dt.month
df['Month'].head()
0 12 1 12 2 12 3 12 4 12 Name: Month, dtype: int64
1
2
3
4
5
# extract day from date
df['Day'] = df['Date'].dt.day
df['Day'].head()
0 1 1 2 2 3 3 4 4 5 Name: Day, dtype: int64
1
2
3
# again view the summary of dataset
df.info()
<class 'pandas.core.frame.DataFrame'> RangeIndex: 142193 entries, 0 to 142192 Data columns (total 26 columns): Date 142193 non-null datetime64[ns] Location 142193 non-null object MinTemp 141556 non-null float64 MaxTemp 141871 non-null float64 Rainfall 140787 non-null float64 Evaporation 81350 non-null float64 Sunshine 74377 non-null float64 WindGustDir 132863 non-null object WindGustSpeed 132923 non-null float64 WindDir9am 132180 non-null object WindDir3pm 138415 non-null object WindSpeed9am 140845 non-null float64 WindSpeed3pm 139563 non-null float64 Humidity9am 140419 non-null float64 Humidity3pm 138583 non-null float64 Pressure9am 128179 non-null float64 Pressure3pm 128212 non-null float64 Cloud9am 88536 non-null float64 Cloud3pm 85099 non-null float64 Temp9am 141289 non-null float64 Temp3pm 139467 non-null float64 RainToday 140787 non-null object RainTomorrow 142193 non-null object Year 142193 non-null int64 Month 142193 non-null int64 Day 142193 non-null int64 dtypes: datetime64[ns](1), float64(16), int64(3), object(6) memory usage: 28.2+ MB
Date 변수에서 생성된 새로운 세 개의 열이 있음을 확인할 수 있습니다. 이제 원래의 Date 변수를 데이터셋에서 제거하겠습니다.
1
2
3
# drop the original Date variable
df.drop('Date', axis=1, inplace = True)
1
2
3
# preview the dataset again
df.head()
| Location | MinTemp | MaxTemp | Rainfall | Evaporation | Sunshine | WindGustDir | WindGustSpeed | WindDir9am | WindDir3pm | ... | Pressure3pm | Cloud9am | Cloud3pm | Temp9am | Temp3pm | RainToday | RainTomorrow | Year | Month | Day | |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 0 | Albury | 13.4 | 22.9 | 0.6 | NaN | NaN | W | 44.0 | W | WNW | ... | 1007.1 | 8.0 | NaN | 16.9 | 21.8 | No | No | 2008 | 12 | 1 |
| 1 | Albury | 7.4 | 25.1 | 0.0 | NaN | NaN | WNW | 44.0 | NNW | WSW | ... | 1007.8 | NaN | NaN | 17.2 | 24.3 | No | No | 2008 | 12 | 2 |
| 2 | Albury | 12.9 | 25.7 | 0.0 | NaN | NaN | WSW | 46.0 | W | WSW | ... | 1008.7 | NaN | 2.0 | 21.0 | 23.2 | No | No | 2008 | 12 | 3 |
| 3 | Albury | 9.2 | 28.0 | 0.0 | NaN | NaN | NE | 24.0 | SE | E | ... | 1012.8 | NaN | NaN | 18.1 | 26.5 | No | No | 2008 | 12 | 4 |
| 4 | Albury | 17.5 | 32.3 | 1.0 | NaN | NaN | W | 41.0 | ENE | NW | ... | 1006.0 | 7.0 | 8.0 | 17.8 | 29.7 | No | No | 2008 | 12 | 5 |
5 rows × 25 columns
이제 데이터셋에서 Date 변수가 제거된 것을 확인할 수 있습니다.
범주형 변수 탐색
이제 각각의 범주형 변수를 하나씩 살펴보겠습니다.
1
2
3
4
5
6
7
# find categorical variables
categorical = [var for var in df.columns if df[var].dtype=='O']
print('There are {} categorical variables\n'.format(len(categorical)))
print('The categorical variables are :', categorical)
There are 6 categorical variables The categorical variables are : ['Location', 'WindGustDir', 'WindDir9am', 'WindDir3pm', 'RainToday', 'RainTomorrow']
데이터셋에는 6개의 범주형 변수가 있습니다. Date 변수는 제거되었습니다. 먼저, 범주형 변수에서 결측치가 있는지 확인해 보겠습니다.
1
2
3
# check for missing values in categorical variables
df[categorical].isnull().sum()
Location 0 WindGustDir 9330 WindDir9am 10013 WindDir3pm 3778 RainToday 1406 RainTomorrow 0 dtype: int64
WindGustDir, WindDir9am, WindDir3pm, RainToday 변수에 결측치가 있음을 확인할 수 있습니다. 이 변수들을 하나씩 살펴보겠습니다.
Location 변수 살펴보기
1
2
3
# print number of labels in Location variable
print('Location contains', len(df.Location.unique()), 'labels')
Location contains 49 labels
1
2
3
# check labels in location variable
df.Location.unique()
array(['Albury', 'BadgerysCreek', 'Cobar', 'CoffsHarbour', 'Moree',
'Newcastle', 'NorahHead', 'NorfolkIsland', 'Penrith', 'Richmond',
'Sydney', 'SydneyAirport', 'WaggaWagga', 'Williamtown',
'Wollongong', 'Canberra', 'Tuggeranong', 'MountGinini', 'Ballarat',
'Bendigo', 'Sale', 'MelbourneAirport', 'Melbourne', 'Mildura',
'Nhil', 'Portland', 'Watsonia', 'Dartmoor', 'Brisbane', 'Cairns',
'GoldCoast', 'Townsville', 'Adelaide', 'MountGambier', 'Nuriootpa',
'Woomera', 'Albany', 'Witchcliffe', 'PearceRAAF', 'PerthAirport',
'Perth', 'SalmonGums', 'Walpole', 'Hobart', 'Launceston',
'AliceSprings', 'Darwin', 'Katherine', 'Uluru'], dtype=object)
1
2
3
# check frequency distribution of values in Location variable
df.Location.value_counts()
Canberra 3418 Sydney 3337 Perth 3193 Darwin 3192 Hobart 3188 Brisbane 3161 Adelaide 3090 Bendigo 3034 Townsville 3033 AliceSprings 3031 MountGambier 3030 Ballarat 3028 Launceston 3028 Albany 3016 Albury 3011 PerthAirport 3009 MelbourneAirport 3009 Mildura 3007 SydneyAirport 3005 Nuriootpa 3002 Sale 3000 Watsonia 2999 Tuggeranong 2998 Portland 2996 Woomera 2990 Cobar 2988 Cairns 2988 Wollongong 2983 GoldCoast 2980 WaggaWagga 2976 NorfolkIsland 2964 Penrith 2964 SalmonGums 2955 Newcastle 2955 CoffsHarbour 2953 Witchcliffe 2952 Richmond 2951 Dartmoor 2943 NorahHead 2929 BadgerysCreek 2928 MountGinini 2907 Moree 2854 Walpole 2819 PearceRAAF 2762 Williamtown 2553 Melbourne 2435 Nhil 1569 Katherine 1559 Uluru 1521 Name: Location, dtype: int64
1
2
3
4
5
# let's do One Hot Encoding of Location variable
# get k-1 dummy variables after One Hot Encoding
# preview the dataset with head() method
pd.get_dummies(df.Location, drop_first=True).head()
| Albany | Albury | AliceSprings | BadgerysCreek | Ballarat | Bendigo | Brisbane | Cairns | Canberra | Cobar | ... | Townsville | Tuggeranong | Uluru | WaggaWagga | Walpole | Watsonia | Williamtown | Witchcliffe | Wollongong | Woomera | |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 1 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 2 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 3 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 4 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
5 rows × 48 columns
WindGustDir 변수 살펴보기
1
2
3
# print number of labels in WindGustDir variable
print('WindGustDir contains', len(df['WindGustDir'].unique()), 'labels')
WindGustDir contains 17 labels
1
2
3
# check labels in WindGustDir variable
df['WindGustDir'].unique()
array(['W', 'WNW', 'WSW', 'NE', 'NNW', 'N', 'NNE', 'SW', 'ENE', 'SSE',
'S', 'NW', 'SE', 'ESE', nan, 'E', 'SSW'], dtype=object)
1
2
3
# check frequency distribution of values in WindGustDir variable
df.WindGustDir.value_counts()
W 9780 SE 9309 E 9071 N 9033 SSE 8993 S 8949 WSW 8901 SW 8797 SSW 8610 WNW 8066 NW 8003 ENE 7992 ESE 7305 NE 7060 NNW 6561 NNE 6433 Name: WindGustDir, dtype: int64
1
2
3
4
5
6
# let's do One Hot Encoding of WindGustDir variable
# get k-1 dummy variables after One Hot Encoding
# also add an additional dummy variable to indicate there was missing data
# preview the dataset with head() method
pd.get_dummies(df.WindGustDir, drop_first=True, dummy_na=True).head()
| ENE | ESE | N | NE | NNE | NNW | NW | S | SE | SSE | SSW | SW | W | WNW | WSW | NaN | |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 0 |
| 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 0 |
| 2 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 |
| 3 | 0 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 4 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 0 |
1
2
3
4
# sum the number of 1s per boolean variable over the rows of the dataset
# it will tell us how many observations we have for each category
pd.get_dummies(df.WindGustDir, drop_first=True, dummy_na=True).sum(axis=0)
ENE 7992 ESE 7305 N 9033 NE 7060 NNE 6433 NNW 6561 NW 8003 S 8949 SE 9309 SSE 8993 SSW 8610 SW 8797 W 9780 WNW 8066 WSW 8901 NaN 9330 dtype: int64
WindGustDir 변수에는 9330개의 결측치가 있음을 확인할 수 있습니다.
WindDir9am 변수 살펴보기
1
2
3
# print number of labels in WindDir9am variable
print('WindDir9am contains', len(df['WindDir9am'].unique()), 'labels')
WindDir9am contains 17 labels
1
2
3
# check labels in WindDir9am variable
df['WindDir9am'].unique()
array(['W', 'NNW', 'SE', 'ENE', 'SW', 'SSE', 'S', 'NE', nan, 'SSW', 'N',
'WSW', 'ESE', 'E', 'NW', 'WNW', 'NNE'], dtype=object)
1
2
3
# check frequency distribution of values in WindDir9am variable
df['WindDir9am'].value_counts()
N 11393 SE 9162 E 9024 SSE 8966 NW 8552 S 8493 W 8260 SW 8237 NNE 7948 NNW 7840 ENE 7735 ESE 7558 NE 7527 SSW 7448 WNW 7194 WSW 6843 Name: WindDir9am, dtype: int64
1
2
3
4
5
6
# let's do One Hot Encoding of WindDir9am variable
# get k-1 dummy variables after One Hot Encoding
# also add an additional dummy variable to indicate there was missing data
# preview the dataset with head() method
pd.get_dummies(df.WindDir9am, drop_first=True, dummy_na=True).head()
| ENE | ESE | N | NE | NNE | NNW | NW | S | SE | SSE | SSW | SW | W | WNW | WSW | NaN | |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 0 |
| 1 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 2 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 0 |
| 3 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 4 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
1
2
3
4
# sum the number of 1s per boolean variable over the rows of the dataset
# it will tell us how many observations we have for each category
pd.get_dummies(df.WindDir9am, drop_first=True, dummy_na=True).sum(axis=0)
ENE 7735 ESE 7558 N 11393 NE 7527 NNE 7948 NNW 7840 NW 8552 S 8493 SE 9162 SSE 8966 SSW 7448 SW 8237 W 8260 WNW 7194 WSW 6843 NaN 10013 dtype: int64
WindDir9am 변수에는 10013개의 결측치가 있음을 확인할 수 있습니다.
WindDir3pm 변수 살펴보기
1
2
3
# print number of labels in WindDir3pm variable
print('WindDir3pm contains', len(df['WindDir3pm'].unique()), 'labels')
WindDir3pm contains 17 labels
1
2
3
# check labels in WindDir3pm variable
df['WindDir3pm'].unique()
array(['WNW', 'WSW', 'E', 'NW', 'W', 'SSE', 'ESE', 'ENE', 'NNW', 'SSW',
'SW', 'SE', 'N', 'S', 'NNE', nan, 'NE'], dtype=object)
1
2
3
# check frequency distribution of values in WindDir3pm variable
df['WindDir3pm'].value_counts()
SE 10663 W 9911 S 9598 WSW 9329 SW 9182 SSE 9142 N 8667 WNW 8656 NW 8468 ESE 8382 E 8342 NE 8164 SSW 8010 NNW 7733 ENE 7724 NNE 6444 Name: WindDir3pm, dtype: int64
1
2
3
4
5
6
# let's do One Hot Encoding of WindDir3pm variable
# get k-1 dummy variables after One Hot Encoding
# also add an additional dummy variable to indicate there was missing data
# preview the dataset with head() method
pd.get_dummies(df.WindDir3pm, drop_first=True, dummy_na=True).head()
| ENE | ESE | N | NE | NNE | NNW | NW | S | SE | SSE | SSW | SW | W | WNW | WSW | NaN | |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 0 |
| 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 |
| 2 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 |
| 3 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 4 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
1
2
3
4
# sum the number of 1s per boolean variable over the rows of the dataset
# it will tell us how many observations we have for each category
pd.get_dummies(df.WindDir3pm, drop_first=True, dummy_na=True).sum(axis=0)
ENE 7724 ESE 8382 N 8667 NE 8164 NNE 6444 NNW 7733 NW 8468 S 9598 SE 10663 SSE 9142 SSW 8010 SW 9182 W 9911 WNW 8656 WSW 9329 NaN 3778 dtype: int64
WindDir3pm 변수에는 3778개의 결측치가 있음을 확인할 수 있습니다.
RainToday 변수 살펴보기
1
2
3
# print number of labels in RainToday variable
print('RainToday contains', len(df['RainToday'].unique()), 'labels')
RainToday contains 3 labels
1
2
3
# check labels in WindGustDir variable
df['RainToday'].unique()
array(['No', 'Yes', nan], dtype=object)
1
2
3
# check frequency distribution of values in WindGustDir variable
df.RainToday.value_counts()
No 109332 Yes 31455 Name: RainToday, dtype: int64
1
2
3
4
5
6
# let's do One Hot Encoding of RainToday variable
# get k-1 dummy variables after One Hot Encoding
# also add an additional dummy variable to indicate there was missing data
# preview the dataset with head() method
pd.get_dummies(df.RainToday, drop_first=True, dummy_na=True).head()
| Yes | NaN | |
|---|---|---|
| 0 | 0 | 0 |
| 1 | 0 | 0 |
| 2 | 0 | 0 |
| 3 | 0 | 0 |
| 4 | 0 | 0 |
1
2
3
4
# sum the number of 1s per boolean variable over the rows of the dataset
# it will tell us how many observations we have for each category
pd.get_dummies(df.RainToday, drop_first=True, dummy_na=True).sum(axis=0)
Yes 31455 NaN 1406 dtype: int64
RainToday 변수에 1406개의 누락된 값이 있습니다.
숫자 변수 탐색
1
2
3
4
5
6
7
# find numerical variables
numerical = [var for var in df.columns if df[var].dtype!='O']
print('There are {} numerical variables\n'.format(len(numerical)))
print('The numerical variables are :', numerical)
There are 19 numerical variables The numerical variables are : ['MinTemp', 'MaxTemp', 'Rainfall', 'Evaporation', 'Sunshine', 'WindGustSpeed', 'WindSpeed9am', 'WindSpeed3pm', 'Humidity9am', 'Humidity3pm', 'Pressure9am', 'Pressure3pm', 'Cloud9am', 'Cloud3pm', 'Temp9am', 'Temp3pm', 'Year', 'Month', 'Day']
1
2
3
# view the numerical variables
df[numerical].head()
| MinTemp | MaxTemp | Rainfall | Evaporation | Sunshine | WindGustSpeed | WindSpeed9am | WindSpeed3pm | Humidity9am | Humidity3pm | Pressure9am | Pressure3pm | Cloud9am | Cloud3pm | Temp9am | Temp3pm | Year | Month | Day | |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 0 | 13.4 | 22.9 | 0.6 | NaN | NaN | 44.0 | 20.0 | 24.0 | 71.0 | 22.0 | 1007.7 | 1007.1 | 8.0 | NaN | 16.9 | 21.8 | 2008 | 12 | 1 |
| 1 | 7.4 | 25.1 | 0.0 | NaN | NaN | 44.0 | 4.0 | 22.0 | 44.0 | 25.0 | 1010.6 | 1007.8 | NaN | NaN | 17.2 | 24.3 | 2008 | 12 | 2 |
| 2 | 12.9 | 25.7 | 0.0 | NaN | NaN | 46.0 | 19.0 | 26.0 | 38.0 | 30.0 | 1007.6 | 1008.7 | NaN | 2.0 | 21.0 | 23.2 | 2008 | 12 | 3 |
| 3 | 9.2 | 28.0 | 0.0 | NaN | NaN | 24.0 | 11.0 | 9.0 | 45.0 | 16.0 | 1017.6 | 1012.8 | NaN | NaN | 18.1 | 26.5 | 2008 | 12 | 4 |
| 4 | 17.5 | 32.3 | 1.0 | NaN | NaN | 41.0 | 7.0 | 20.0 | 82.0 | 33.0 | 1010.8 | 1006.0 | 7.0 | 8.0 | 17.8 | 29.7 | 2008 | 12 | 5 |
수치형 변수 요약
16개의 수치형 변수가 있습니다.
이들은 MinTemp, MaxTemp, Rainfall, Evaporation, Sunshine, WindGustSpeed, WindSpeed9am, WindSpeed3pm, Humidity9am, Humidity3pm, Pressure9am, Pressure3pm,Cloud9am, Cloud3pm, Temp9am, Temp3pm 입니다.
모든 수치형 변수는 연속형입니다.
수치형 변수 내 문제점 탐색
이제 수치형 변수를 살펴보겠습니다.
수치형 변수 내 결측치 처리하기
1
2
3
# check missing values in numerical variables
df[numerical].isnull().sum()
MinTemp 637 MaxTemp 322 Rainfall 1406 Evaporation 60843 Sunshine 67816 WindGustSpeed 9270 WindSpeed9am 1348 WindSpeed3pm 2630 Humidity9am 1774 Humidity3pm 3610 Pressure9am 14014 Pressure3pm 13981 Cloud9am 53657 Cloud3pm 57094 Temp9am 904 Temp3pm 2726 Year 0 Month 0 Day 0 dtype: int64
16개의 수치형 변수 모두 결측치를 포함하고 있음을 확인할 수 있습니다.
숫자 변수의 이상값
1
2
3
# view summary statistics in numerical variables
print(round(df[numerical].describe()),2)
MinTemp MaxTemp Rainfall Evaporation Sunshine WindGustSpeed \
count 141556.0 141871.0 140787.0 81350.0 74377.0 132923.0
mean 12.0 23.0 2.0 5.0 8.0 40.0
std 6.0 7.0 8.0 4.0 4.0 14.0
min -8.0 -5.0 0.0 0.0 0.0 6.0
25% 8.0 18.0 0.0 3.0 5.0 31.0
50% 12.0 23.0 0.0 5.0 8.0 39.0
75% 17.0 28.0 1.0 7.0 11.0 48.0
max 34.0 48.0 371.0 145.0 14.0 135.0
WindSpeed9am WindSpeed3pm Humidity9am Humidity3pm Pressure9am \
count 140845.0 139563.0 140419.0 138583.0 128179.0
mean 14.0 19.0 69.0 51.0 1018.0
std 9.0 9.0 19.0 21.0 7.0
min 0.0 0.0 0.0 0.0 980.0
25% 7.0 13.0 57.0 37.0 1013.0
50% 13.0 19.0 70.0 52.0 1018.0
75% 19.0 24.0 83.0 66.0 1022.0
max 130.0 87.0 100.0 100.0 1041.0
Pressure3pm Cloud9am Cloud3pm Temp9am Temp3pm Year \
count 128212.0 88536.0 85099.0 141289.0 139467.0 142193.0
mean 1015.0 4.0 5.0 17.0 22.0 2013.0
std 7.0 3.0 3.0 6.0 7.0 3.0
min 977.0 0.0 0.0 -7.0 -5.0 2007.0
25% 1010.0 1.0 2.0 12.0 17.0 2011.0
50% 1015.0 5.0 5.0 17.0 21.0 2013.0
75% 1020.0 7.0 7.0 22.0 26.0 2015.0
max 1040.0 9.0 9.0 40.0 47.0 2017.0
Month Day
count 142193.0 142193.0
mean 6.0 16.0
std 3.0 9.0
min 1.0 1.0
25% 3.0 8.0
50% 6.0 16.0
75% 9.0 23.0
max 12.0 31.0 2
자세히 살펴보면, Rainfall, Evaporation, WindSpeed9am, WindSpeed3pm 열에는 이상치가 포함될 수 있음을 확인할 수 있습니다.
상기 변수에서 이상치를 시각화하기 위해 상자 그림을 그리겠습니다.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
# draw boxplots to visualize outliers
plt.figure(figsize=(15,10))
plt.subplot(2, 2, 1)
fig = df.boxplot(column='Rainfall')
fig.set_title('')
fig.set_ylabel('Rainfall')
plt.subplot(2, 2, 2)
fig = df.boxplot(column='Evaporation')
fig.set_title('')
fig.set_ylabel('Evaporation')
plt.subplot(2, 2, 3)
fig = df.boxplot(column='WindSpeed9am')
fig.set_title('')
fig.set_ylabel('WindSpeed9am')
plt.subplot(2, 2, 4)
fig = df.boxplot(column='WindSpeed3pm')
fig.set_title('')
fig.set_ylabel('WindSpeed3pm')
Text(0, 0.5, 'WindSpeed3pm')
상기 상자 그림은 이 변수들에 많은 이상치가 있다는 것을 확인합니다.
변수 분포 확인하기
이제 변수 분포를 확인하기 위해 히스토그램을 그려보겠습니다. 정규 분포를 따르는 경우, 극값 분석 (Extreme Value Analysis)을 수행하고, 왜곡된 경우 IQR(Interquantile range)을 찾아보겠습니다.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
# plot histogram to check distribution
plt.figure(figsize=(15,10))
plt.subplot(2, 2, 1)
fig = df.Rainfall.hist(bins=10)
fig.set_xlabel('Rainfall')
fig.set_ylabel('RainTomorrow')
plt.subplot(2, 2, 2)
fig = df.Evaporation.hist(bins=10)
fig.set_xlabel('Evaporation')
fig.set_ylabel('RainTomorrow')
plt.subplot(2, 2, 3)
fig = df.WindSpeed9am.hist(bins=10)
fig.set_xlabel('WindSpeed9am')
fig.set_ylabel('RainTomorrow')
plt.subplot(2, 2, 4)
fig = df.WindSpeed3pm.hist(bins=10)
fig.set_xlabel('WindSpeed3pm')
fig.set_ylabel('RainTomorrow')
Text(0, 0.5, 'RainTomorrow')
상기 네 변수 모두 왜곡되어 있습니다. 따라서, 이상치를 찾기 위해 IQR(Interquantile range)를 사용하겠습니다.
1
2
3
4
5
6
# find outliers for Rainfall variable
IQR = df.Rainfall.quantile(0.75) - df.Rainfall.quantile(0.25)
Lower_fence = df.Rainfall.quantile(0.25) - (IQR * 3)
Upper_fence = df.Rainfall.quantile(0.75) + (IQR * 3)
print('Rainfall outliers are values < {lowerboundary} or > {upperboundary}'.format(lowerboundary=Lower_fence, upperboundary=Upper_fence))
Rainfall outliers are values < -2.4000000000000004 or > 3.2
Rainfall 변수에서 최소값과 최대값은 각각 0.0과 371.0입니다. 따라서, 이상치는 값이 3.2보다 큰 값들입니다.
1
2
3
4
5
6
# find outliers for Evaporation variable
IQR = df.Evaporation.quantile(0.75) - df.Evaporation.quantile(0.25)
Lower_fence = df.Evaporation.quantile(0.25) - (IQR * 3)
Upper_fence = df.Evaporation.quantile(0.75) + (IQR * 3)
print('Evaporation outliers are values < {lowerboundary} or > {upperboundary}'.format(lowerboundary=Lower_fence, upperboundary=Upper_fence))
Evaporation outliers are values < -11.800000000000002 or > 21.800000000000004
Evaporation 변수에서 최소값과 최대값은 각각 0.0과 145.0입니다. 따라서, 이상치는 값이 21.8보다 큰 값들입니다.
1
2
3
4
5
6
# find outliers for WindSpeed9am variable
IQR = df.WindSpeed9am.quantile(0.75) - df.WindSpeed9am.quantile(0.25)
Lower_fence = df.WindSpeed9am.quantile(0.25) - (IQR * 3)
Upper_fence = df.WindSpeed9am.quantile(0.75) + (IQR * 3)
print('WindSpeed9am outliers are values < {lowerboundary} or > {upperboundary}'.format(lowerboundary=Lower_fence, upperboundary=Upper_fence))
WindSpeed9am outliers are values < -29.0 or > 55.0
WindSpeed9am 변수에서 최소값과 최대값은 각각 0.0과 130.0입니다. 따라서, 이상치는 값이 55.0보다 큰 값들입니다.
1
2
3
4
5
6
# find outliers for WindSpeed3pm variable
IQR = df.WindSpeed3pm.quantile(0.75) - df.WindSpeed3pm.quantile(0.25)
Lower_fence = df.WindSpeed3pm.quantile(0.25) - (IQR * 3)
Upper_fence = df.WindSpeed3pm.quantile(0.75) + (IQR * 3)
print('WindSpeed3pm outliers are values < {lowerboundary} or > {upperboundary}'.format(lowerboundary=Lower_fence, upperboundary=Upper_fence))
WindSpeed3pm outliers are values < -20.0 or > 57.0
WindSpeed3pm 변수에서 최소값과 최대값은 각각 0.0과 87.0입니다. 따라서, 이상치는 값이 57.0보다 큰 값들입니다.
8. 특징 벡터 및 대상 변수 선언
1
2
3
X = df.drop(['RainTomorrow'], axis=1)
y = df['RainTomorrow']
9. 데이터를 별도의 학습 및 테스트 집합으로 분할
1
2
3
4
5
# split X and y into training and testing sets
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, random_state = 0)
1
2
3
# check the shape of X_train and X_test
X_train.shape, X_test.shape
((113754, 24), (28439, 24))
10. 기능 엔지니어링
특성 공학(Feature Engineering)은 원시 데이터를 유용한 특성으로 변환하여 모델을 더 잘 이해하고 예측 능력을 향상시키는 과정입니다. 각각의 변수 유형에 대해 특성 공학을 수행할 것입니다.
먼저 범주형 변수와 수치형 변수를 각각 따로 다시 표시하겠습니다.
1
2
3
# check data types in X_train
X_train.dtypes
Location object MinTemp float64 MaxTemp float64 Rainfall float64 Evaporation float64 Sunshine float64 WindGustDir object WindGustSpeed float64 WindDir9am object WindDir3pm object WindSpeed9am float64 WindSpeed3pm float64 Humidity9am float64 Humidity3pm float64 Pressure9am float64 Pressure3pm float64 Cloud9am float64 Cloud3pm float64 Temp9am float64 Temp3pm float64 RainToday object Year int64 Month int64 Day int64 dtype: object
1
2
3
4
5
# display categorical variables
categorical = [col for col in X_train.columns if X_train[col].dtypes == 'O']
categorical
['Location', 'WindGustDir', 'WindDir9am', 'WindDir3pm', 'RainToday']
1
2
3
4
5
# display numerical variables
numerical = [col for col in X_train.columns if X_train[col].dtypes != 'O']
numerical
['MinTemp', 'MaxTemp', 'Rainfall', 'Evaporation', 'Sunshine', 'WindGustSpeed', 'WindSpeed9am', 'WindSpeed3pm', 'Humidity9am', 'Humidity3pm', 'Pressure9am', 'Pressure3pm', 'Cloud9am', 'Cloud3pm', 'Temp9am', 'Temp3pm', 'Year', 'Month', 'Day']
숫자 변수의 엔지니어링 결측치
1
2
3
# check missing values in numerical variables in X_train
X_train[numerical].isnull().sum()
MinTemp 495 MaxTemp 264 Rainfall 1139 Evaporation 48718 Sunshine 54314 WindGustSpeed 7367 WindSpeed9am 1086 WindSpeed3pm 2094 Humidity9am 1449 Humidity3pm 2890 Pressure9am 11212 Pressure3pm 11186 Cloud9am 43137 Cloud3pm 45768 Temp9am 740 Temp3pm 2171 Year 0 Month 0 Day 0 dtype: int64
1
2
3
# check missing values in numerical variables in X_test
X_test[numerical].isnull().sum()
MinTemp 142 MaxTemp 58 Rainfall 267 Evaporation 12125 Sunshine 13502 WindGustSpeed 1903 WindSpeed9am 262 WindSpeed3pm 536 Humidity9am 325 Humidity3pm 720 Pressure9am 2802 Pressure3pm 2795 Cloud9am 10520 Cloud3pm 11326 Temp9am 164 Temp3pm 555 Year 0 Month 0 Day 0 dtype: int64
1
2
3
4
5
# print percentage of missing values in the numerical variables in training set
for col in numerical:
if X_train[col].isnull().mean()>0:
print(col, round(X_train[col].isnull().mean(),4))
MinTemp 0.0044 MaxTemp 0.0023 Rainfall 0.01 Evaporation 0.4283 Sunshine 0.4775 WindGustSpeed 0.0648 WindSpeed9am 0.0095 WindSpeed3pm 0.0184 Humidity9am 0.0127 Humidity3pm 0.0254 Pressure9am 0.0986 Pressure3pm 0.0983 Cloud9am 0.3792 Cloud3pm 0.4023 Temp9am 0.0065 Temp3pm 0.0191
가정
전체 데이터가 완전 무작위 결측(MCAR)인 것으로 가정합니다. 결측치를 보완하는 데에는 평균 또는 중앙값 보완 방법 및 무작위 표본 보완 방법이 있습니다. 데이터셋에 이상치가 있을 때는 중앙값 보완 방법을 사용해야 합니다. 따라서 중앙값 보완 방법을 사용할 것입니다. 중앙값 보완은 이상치에 강건하기 때문입니다.
데이터의 통계적 측정값(중앙값)을 이용하여 결측값을 보완할 것입니다. 보완은 학습용 데이터셋을 기준으로 수행하고, 보완한 결과는 테스트용 데이터셋에도 적용해야 합니다. 즉, 학습용 데이터셋을 기준으로 결측값을 보완할 때 사용되는 통계 측정값은 학습용 데이터셋에서 추출되어야 합니다. 이렇게 함으로써 과적합을 방지할 수 있습니다.
1
2
3
4
5
6
7
# impute missing values in X_train and X_test with respective column median in X_train
for df1 in [X_train, X_test]:
for col in numerical:
col_median=X_train[col].median()
df1[col].fillna(col_median, inplace=True)
1
2
3
# check again missing values in numerical variables in X_train
X_train[numerical].isnull().sum()
MinTemp 0 MaxTemp 0 Rainfall 0 Evaporation 0 Sunshine 0 WindGustSpeed 0 WindSpeed9am 0 WindSpeed3pm 0 Humidity9am 0 Humidity3pm 0 Pressure9am 0 Pressure3pm 0 Cloud9am 0 Cloud3pm 0 Temp9am 0 Temp3pm 0 Year 0 Month 0 Day 0 dtype: int64
1
2
3
# check missing values in numerical variables in X_test
X_test[numerical].isnull().sum()
MinTemp 0 MaxTemp 0 Rainfall 0 Evaporation 0 Sunshine 0 WindGustSpeed 0 WindSpeed9am 0 WindSpeed3pm 0 Humidity9am 0 Humidity3pm 0 Pressure9am 0 Pressure3pm 0 Cloud9am 0 Cloud3pm 0 Temp9am 0 Temp3pm 0 Year 0 Month 0 Day 0 dtype: int64
이제 학습 데이터와 테스트 데이터의 숫자 열에는 누락된 값이 없습니다. 중앙값 대치를 통해 이전에 누락된 값을 채웠기 때문입니다. 이제 모든 숫자 변수에서 동일한 크기의 데이터를 가지고 있으므로 모델링에 진행할 수 있습니다.
범주형 변수의 엔지니어링 결측치 설계
1
2
3
# print percentage of missing values in the categorical variables in training set
X_train[categorical].isnull().mean()
Location 0.000000 WindGustDir 0.065114 WindDir9am 0.070134 WindDir3pm 0.026443 RainToday 0.010013 dtype: float64
1
2
3
4
5
# print categorical variables with missing data
for col in categorical:
if X_train[col].isnull().mean()>0:
print(col, (X_train[col].isnull().mean()))
WindGustDir 0.06511419378659213 WindDir9am 0.07013379749283542 WindDir3pm 0.026443026179299188 RainToday 0.01001283471350458
1
2
3
4
5
6
7
# impute missing categorical variables with most frequent value
for df2 in [X_train, X_test]:
df2['WindGustDir'].fillna(X_train['WindGustDir'].mode()[0], inplace=True)
df2['WindDir9am'].fillna(X_train['WindDir9am'].mode()[0], inplace=True)
df2['WindDir3pm'].fillna(X_train['WindDir3pm'].mode()[0], inplace=True)
df2['RainToday'].fillna(X_train['RainToday'].mode()[0], inplace=True)
1
2
3
# check missing values in categorical variables in X_train
X_train[categorical].isnull().sum()
Location 0 WindGustDir 0 WindDir9am 0 WindDir3pm 0 RainToday 0 dtype: int64
1
2
3
# check missing values in categorical variables in X_test
X_test[categorical].isnull().sum()
Location 0 WindGustDir 0 WindDir9am 0 WindDir3pm 0 RainToday 0 dtype: int64
최종 점검으로 X_train과 X_test에서 누락된 값이 있는지 확인합니다.
1
2
3
# check missing values in X_train
X_train.isnull().sum()
Location 0 MinTemp 0 MaxTemp 0 Rainfall 0 Evaporation 0 Sunshine 0 WindGustDir 0 WindGustSpeed 0 WindDir9am 0 WindDir3pm 0 WindSpeed9am 0 WindSpeed3pm 0 Humidity9am 0 Humidity3pm 0 Pressure9am 0 Pressure3pm 0 Cloud9am 0 Cloud3pm 0 Temp9am 0 Temp3pm 0 RainToday 0 Year 0 Month 0 Day 0 dtype: int64
1
2
3
# check missing values in X_test
X_test.isnull().sum()
Location 0 MinTemp 0 MaxTemp 0 Rainfall 0 Evaporation 0 Sunshine 0 WindGustDir 0 WindGustSpeed 0 WindDir9am 0 WindDir3pm 0 WindSpeed9am 0 WindSpeed3pm 0 Humidity9am 0 Humidity3pm 0 Pressure9am 0 Pressure3pm 0 Cloud9am 0 Cloud3pm 0 Temp9am 0 Temp3pm 0 RainToday 0 Year 0 Month 0 Day 0 dtype: int64
X_train과 X_test에 누락된 값이 없음을 알 수 있습니다.
숫자 변수의 엔지니어링 이상값
Rainfall, Evaporation, WindSpeed9am 및 WindSpeed3pm 열에 이상치가 있음을 확인했습니다. 이상치를 제거하고 최대값을 제한하기 위해 상위 코딩(top-coding) 방법을 사용할 것입니다.
1
2
3
4
5
6
7
8
def max_value(df3, variable, top):
return np.where(df3[variable]>top, top, df3[variable])
for df3 in [X_train, X_test]:
df3['Rainfall'] = max_value(df3, 'Rainfall', 3.2)
df3['Evaporation'] = max_value(df3, 'Evaporation', 21.8)
df3['WindSpeed9am'] = max_value(df3, 'WindSpeed9am', 55)
df3['WindSpeed3pm'] = max_value(df3, 'WindSpeed3pm', 57)
1
X_train.Rainfall.max(), X_test.Rainfall.max()
(3.2, 3.2)
1
X_train.Evaporation.max(), X_test.Evaporation.max()
(21.8, 21.8)
1
X_train.WindSpeed9am.max(), X_test.WindSpeed9am.max()
(55.0, 55.0)
1
X_train.WindSpeed3pm.max(), X_test.WindSpeed3pm.max()
(57.0, 57.0)
1
X_train[numerical].describe()
| MinTemp | MaxTemp | Rainfall | Evaporation | Sunshine | WindGustSpeed | WindSpeed9am | WindSpeed3pm | Humidity9am | Humidity3pm | Pressure9am | Pressure3pm | Cloud9am | Cloud3pm | Temp9am | Temp3pm | Year | Month | Day | |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| count | 113754.000000 | 113754.000000 | 113754.000000 | 113754.000000 | 113754.000000 | 113754.000000 | 113754.000000 | 113754.000000 | 113754.000000 | 113754.000000 | 113754.000000 | 113754.000000 | 113754.000000 | 113754.000000 | 113754.000000 | 113754.000000 | 113754.000000 | 113754.000000 | 113754.000000 |
| mean | 12.193497 | 23.237216 | 0.675080 | 5.151606 | 8.041154 | 39.884074 | 13.978155 | 18.614756 | 68.867486 | 51.509547 | 1017.640649 | 1015.241101 | 4.651801 | 4.703588 | 16.995062 | 21.688643 | 2012.759727 | 6.404021 | 15.710419 |
| std | 6.388279 | 7.094149 | 1.183837 | 2.823707 | 2.769480 | 13.116959 | 8.806558 | 8.685862 | 18.935587 | 20.530723 | 6.738680 | 6.675168 | 2.292726 | 2.117847 | 6.463772 | 6.855649 | 2.540419 | 3.427798 | 8.796821 |
| min | -8.200000 | -4.800000 | 0.000000 | 0.000000 | 0.000000 | 6.000000 | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 980.500000 | 977.100000 | 0.000000 | 0.000000 | -7.200000 | -5.400000 | 2007.000000 | 1.000000 | 1.000000 |
| 25% | 7.600000 | 18.000000 | 0.000000 | 4.000000 | 8.200000 | 31.000000 | 7.000000 | 13.000000 | 57.000000 | 37.000000 | 1013.500000 | 1011.000000 | 3.000000 | 4.000000 | 12.300000 | 16.700000 | 2011.000000 | 3.000000 | 8.000000 |
| 50% | 12.000000 | 22.600000 | 0.000000 | 4.800000 | 8.500000 | 39.000000 | 13.000000 | 19.000000 | 70.000000 | 52.000000 | 1017.600000 | 1015.200000 | 5.000000 | 5.000000 | 16.700000 | 21.100000 | 2013.000000 | 6.000000 | 16.000000 |
| 75% | 16.800000 | 28.200000 | 0.600000 | 5.400000 | 8.700000 | 46.000000 | 19.000000 | 24.000000 | 83.000000 | 65.000000 | 1021.800000 | 1019.400000 | 6.000000 | 6.000000 | 21.500000 | 26.300000 | 2015.000000 | 9.000000 | 23.000000 |
| max | 33.900000 | 48.100000 | 3.200000 | 21.800000 | 14.500000 | 135.000000 | 55.000000 | 57.000000 | 100.000000 | 100.000000 | 1041.000000 | 1039.600000 | 9.000000 | 8.000000 | 40.200000 | 46.700000 | 2017.000000 | 12.000000 | 31.000000 |
이제 Rainfall, Evaporation, WindSpeed9am 및 WindSpeed3pm 열에서 이상치가 잘린 것을 볼 수 있습니다.
범주형 변수 인코딩
1
categorical
['Location', 'WindGustDir', 'WindDir9am', 'WindDir3pm', 'RainToday']
1
X_train[categorical].head()
| Location | WindGustDir | WindDir9am | WindDir3pm | RainToday | |
|---|---|---|---|---|---|
| 110803 | Witchcliffe | S | SSE | S | No |
| 87289 | Cairns | ENE | SSE | SE | Yes |
| 134949 | AliceSprings | E | NE | N | No |
| 85553 | Cairns | ESE | SSE | E | No |
| 16110 | Newcastle | W | N | SE | No |
1
2
3
4
5
6
7
8
9
# encode RainToday variable
import category_encoders as ce
encoder = ce.BinaryEncoder(cols=['RainToday'])
X_train = encoder.fit_transform(X_train)
X_test = encoder.transform(X_test)
1
X_train.head()
| Location | MinTemp | MaxTemp | Rainfall | Evaporation | Sunshine | WindGustDir | WindGustSpeed | WindDir9am | WindDir3pm | ... | Pressure3pm | Cloud9am | Cloud3pm | Temp9am | Temp3pm | RainToday_0 | RainToday_1 | Year | Month | Day | |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 110803 | Witchcliffe | 13.9 | 22.6 | 0.2 | 4.8 | 8.5 | S | 41.0 | SSE | S | ... | 1013.4 | 5.0 | 5.0 | 18.8 | 20.4 | 0 | 1 | 2014 | 4 | 25 |
| 87289 | Cairns | 22.4 | 29.4 | 2.0 | 6.0 | 6.3 | ENE | 33.0 | SSE | SE | ... | 1013.1 | 7.0 | 5.0 | 26.4 | 27.5 | 1 | 0 | 2015 | 11 | 2 |
| 134949 | AliceSprings | 9.7 | 36.2 | 0.0 | 11.4 | 12.3 | E | 31.0 | NE | N | ... | 1013.6 | 1.0 | 1.0 | 28.5 | 35.0 | 0 | 1 | 2014 | 10 | 19 |
| 85553 | Cairns | 20.5 | 30.1 | 0.0 | 8.8 | 11.1 | ESE | 37.0 | SSE | E | ... | 1010.8 | 2.0 | 3.0 | 27.3 | 29.4 | 0 | 1 | 2010 | 10 | 30 |
| 16110 | Newcastle | 16.8 | 29.2 | 0.0 | 4.8 | 8.5 | W | 39.0 | N | SE | ... | 1015.2 | 5.0 | 8.0 | 22.2 | 27.0 | 0 | 1 | 2012 | 11 | 8 |
5 rows × 25 columns
RainToday 변수에서 RainToday_0과 RainToday_1 두 가지 추가 변수가 생성된 것을 볼 수 있습니다.
이제 X_train 훈련 세트를 생성하겠습니다.
1
2
3
4
5
X_train = pd.concat([X_train[numerical], X_train[['RainToday_0', 'RainToday_1']],
pd.get_dummies(X_train.Location),
pd.get_dummies(X_train.WindGustDir),
pd.get_dummies(X_train.WindDir9am),
pd.get_dummies(X_train.WindDir3pm)], axis=1)
1
X_train.head()
| MinTemp | MaxTemp | Rainfall | Evaporation | Sunshine | WindGustSpeed | WindSpeed9am | WindSpeed3pm | Humidity9am | Humidity3pm | ... | NNW | NW | S | SE | SSE | SSW | SW | W | WNW | WSW | |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 110803 | 13.9 | 22.6 | 0.2 | 4.8 | 8.5 | 41.0 | 20.0 | 28.0 | 65.0 | 55.0 | ... | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 87289 | 22.4 | 29.4 | 2.0 | 6.0 | 6.3 | 33.0 | 7.0 | 19.0 | 71.0 | 59.0 | ... | 0 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 |
| 134949 | 9.7 | 36.2 | 0.0 | 11.4 | 12.3 | 31.0 | 15.0 | 11.0 | 6.0 | 2.0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 85553 | 20.5 | 30.1 | 0.0 | 8.8 | 11.1 | 37.0 | 22.0 | 19.0 | 59.0 | 53.0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 16110 | 16.8 | 29.2 | 0.0 | 4.8 | 8.5 | 39.0 | 0.0 | 7.0 | 72.0 | 53.0 | ... | 0 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 |
5 rows × 118 columns
X_test는 RainToday 변수에서 파생된 두 가지 변수 RainToday_0과 RainToday_1을 포함한 테스트 세트입니다. 나머지 변수들은 트레이닝 세트와 마찬가지로 데이터 전처리 후에 원래의 변수 그대로 유지됩니다.
1
2
3
4
5
X_test = pd.concat([X_test[numerical], X_test[['RainToday_0', 'RainToday_1']],
pd.get_dummies(X_test.Location),
pd.get_dummies(X_test.WindGustDir),
pd.get_dummies(X_test.WindDir9am),
pd.get_dummies(X_test.WindDir3pm)], axis=1)
1
X_test.head()
| MinTemp | MaxTemp | Rainfall | Evaporation | Sunshine | WindGustSpeed | WindSpeed9am | WindSpeed3pm | Humidity9am | Humidity3pm | ... | NNW | NW | S | SE | SSE | SSW | SW | W | WNW | WSW | |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 86232 | 17.4 | 29.0 | 0.0 | 3.6 | 11.1 | 33.0 | 11.0 | 19.0 | 63.0 | 61.0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 57576 | 6.8 | 14.4 | 0.8 | 0.8 | 8.5 | 46.0 | 17.0 | 22.0 | 80.0 | 55.0 | ... | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 124071 | 10.1 | 15.4 | 3.2 | 4.8 | 8.5 | 31.0 | 13.0 | 9.0 | 70.0 | 61.0 | ... | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 |
| 117955 | 14.4 | 33.4 | 0.0 | 8.0 | 11.6 | 41.0 | 9.0 | 17.0 | 40.0 | 23.0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 0 |
| 133468 | 6.8 | 14.3 | 3.2 | 0.2 | 7.3 | 28.0 | 15.0 | 13.0 | 92.0 | 47.0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
5 rows × 118 columns
모델 구축을 위해 특성 변수들을 동일한 척도로 매핑하는 것이 중요합니다. 이것을 feature scaling이라고 합니다. 이를 수행하기 위해 다음과 같이 진행하겠습니다.
11. 기능 확장
1
X_train.describe()
| MinTemp | MaxTemp | Rainfall | Evaporation | Sunshine | WindGustSpeed | WindSpeed9am | WindSpeed3pm | Humidity9am | Humidity3pm | ... | NNW | NW | S | SE | SSE | SSW | SW | W | WNW | WSW | |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| count | 113754.000000 | 113754.000000 | 113754.000000 | 113754.000000 | 113754.000000 | 113754.000000 | 113754.000000 | 113754.000000 | 113754.000000 | 113754.000000 | ... | 113754.000000 | 113754.000000 | 113754.000000 | 113754.000000 | 113754.000000 | 113754.000000 | 113754.000000 | 113754.000000 | 113754.000000 | 113754.000000 |
| mean | 12.193497 | 23.237216 | 0.675080 | 5.151606 | 8.041154 | 39.884074 | 13.978155 | 18.614756 | 68.867486 | 51.509547 | ... | 0.054530 | 0.060288 | 0.067259 | 0.101605 | 0.064059 | 0.056402 | 0.064464 | 0.069334 | 0.060798 | 0.065483 |
| std | 6.388279 | 7.094149 | 1.183837 | 2.823707 | 2.769480 | 13.116959 | 8.806558 | 8.685862 | 18.935587 | 20.530723 | ... | 0.227061 | 0.238021 | 0.250471 | 0.302130 | 0.244860 | 0.230698 | 0.245578 | 0.254022 | 0.238960 | 0.247378 |
| min | -8.200000 | -4.800000 | 0.000000 | 0.000000 | 0.000000 | 6.000000 | 0.000000 | 0.000000 | 0.000000 | 0.000000 | ... | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.000000 |
| 25% | 7.600000 | 18.000000 | 0.000000 | 4.000000 | 8.200000 | 31.000000 | 7.000000 | 13.000000 | 57.000000 | 37.000000 | ... | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.000000 |
| 50% | 12.000000 | 22.600000 | 0.000000 | 4.800000 | 8.500000 | 39.000000 | 13.000000 | 19.000000 | 70.000000 | 52.000000 | ... | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.000000 |
| 75% | 16.800000 | 28.200000 | 0.600000 | 5.400000 | 8.700000 | 46.000000 | 19.000000 | 24.000000 | 83.000000 | 65.000000 | ... | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.000000 |
| max | 33.900000 | 48.100000 | 3.200000 | 21.800000 | 14.500000 | 135.000000 | 55.000000 | 57.000000 | 100.000000 | 100.000000 | ... | 1.000000 | 1.000000 | 1.000000 | 1.000000 | 1.000000 | 1.000000 | 1.000000 | 1.000000 | 1.000000 | 1.000000 |
8 rows × 118 columns
1
cols = X_train.columns
1
2
3
4
5
6
7
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)
1
X_train = pd.DataFrame(X_train, columns=[cols])
1
X_test = pd.DataFrame(X_test, columns=[cols])
1
X_train.describe()
| MinTemp | MaxTemp | Rainfall | Evaporation | Sunshine | WindGustSpeed | WindSpeed9am | WindSpeed3pm | Humidity9am | Humidity3pm | ... | NNW | NW | S | SE | SSE | SSW | SW | W | WNW | WSW | |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| count | 113754.000000 | 113754.000000 | 113754.000000 | 113754.000000 | 113754.000000 | 113754.000000 | 113754.000000 | 113754.000000 | 113754.000000 | 113754.000000 | ... | 113754.000000 | 113754.000000 | 113754.000000 | 113754.000000 | 113754.000000 | 113754.000000 | 113754.000000 | 113754.000000 | 113754.000000 | 113754.000000 |
| mean | 0.484406 | 0.530004 | 0.210962 | 0.236312 | 0.554562 | 0.262667 | 0.254148 | 0.326575 | 0.688675 | 0.515095 | ... | 0.054530 | 0.060288 | 0.067259 | 0.101605 | 0.064059 | 0.056402 | 0.064464 | 0.069334 | 0.060798 | 0.065483 |
| std | 0.151741 | 0.134105 | 0.369949 | 0.129528 | 0.190999 | 0.101682 | 0.160119 | 0.152384 | 0.189356 | 0.205307 | ... | 0.227061 | 0.238021 | 0.250471 | 0.302130 | 0.244860 | 0.230698 | 0.245578 | 0.254022 | 0.238960 | 0.247378 |
| min | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.000000 | ... | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.000000 |
| 25% | 0.375297 | 0.431002 | 0.000000 | 0.183486 | 0.565517 | 0.193798 | 0.127273 | 0.228070 | 0.570000 | 0.370000 | ... | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.000000 |
| 50% | 0.479810 | 0.517958 | 0.000000 | 0.220183 | 0.586207 | 0.255814 | 0.236364 | 0.333333 | 0.700000 | 0.520000 | ... | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.000000 |
| 75% | 0.593824 | 0.623819 | 0.187500 | 0.247706 | 0.600000 | 0.310078 | 0.345455 | 0.421053 | 0.830000 | 0.650000 | ... | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.000000 |
| max | 1.000000 | 1.000000 | 1.000000 | 1.000000 | 1.000000 | 1.000000 | 1.000000 | 1.000000 | 1.000000 | 1.000000 | ... | 1.000000 | 1.000000 | 1.000000 | 1.000000 | 1.000000 | 1.000000 | 1.000000 | 1.000000 | 1.000000 | 1.000000 |
8 rows × 118 columns
아래와 같이 로지스틱 회귀 분류기에 X_train 데이터셋을 입력합니다.
12. 모델 훈련
1
2
3
4
5
6
7
8
9
10
# train a logistic regression model on the training set
from sklearn.linear_model import LogisticRegression
# instantiate the model
logreg = LogisticRegression(solver='liblinear', random_state=0)
# fit the model
logreg.fit(X_train, y_train)
LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=True,
intercept_scaling=1, l1_ratio=None, max_iter=100,
multi_class='warn', n_jobs=None, penalty='l2',
random_state=0, solver='liblinear', tol=0.0001, verbose=0,
warm_start=False)
13. 결과 예측
1
2
3
y_pred_test = logreg.predict(X_test)
y_pred_test
array(['No', 'No', 'No', ..., 'No', 'No', 'Yes'], dtype=object)
predict_proba method
predict_proba 메서드는 배열 형태로 대상 변수(이 경우 0과 1)의 확률을 제공합니다.
0은 비가 오지 않을 확률을 나타내고, 1은 비가 올 확률을 나타냅니다.
1
2
3
# probability of getting output as 0 - no rain
logreg.predict_proba(X_test)[:,0]
array([0.91382428, 0.83565645, 0.82033915, ..., 0.97674285, 0.79855098,
0.30734161])
1
2
3
# probability of getting output as 1 - rain
logreg.predict_proba(X_test)[:,1]
array([0.08617572, 0.16434355, 0.17966085, ..., 0.02325715, 0.20144902,
0.69265839])
14. 정확도 점수 확인
1
2
3
from sklearn.metrics import accuracy_score
print('Model accuracy score: {0:0.4f}'. format(accuracy_score(y_test, y_pred_test)))
Model accuracy score: 0.8502
여기서 y_test는 테스트 세트에서의 실제 클래스 레이블이고, y_pred_test는 예측된 클래스 레이블입니다.
훈련 세트와 테스트 세트의 정확도 비교
이제 과적합을 확인하기 위해 학습 집합과 테스트 집합의 정확도를 비교해보겠습니다.
1
2
3
y_pred_train = logreg.predict(X_train)
y_pred_train
array(['No', 'No', 'No', ..., 'No', 'No', 'No'], dtype=object)
1
print('Training-set accuracy score: {0:0.4f}'. format(accuracy_score(y_train, y_pred_train)))
Training-set accuracy score: 0.8476
과적합 및 과소적합 여부 확인
1
2
3
4
5
# print the scores on training and test set
print('Training set score: {:.4f}'.format(logreg.score(X_train, y_train)))
print('Test set score: {:.4f}'.format(logreg.score(X_test, y_test)))
Training set score: 0.8476 Test set score: 0.8502
학습 데이터셋의 정확도 점수는 0.8476이고, 테스트 데이터셋의 정확도는 0.8501입니다. 두 값은 꽤 비슷합니다. 따라서 과적합 문제는 없습니다.
로지스틱 회귀에서는 C의 기본값으로 1을 사용합니다. 이는 꽤 좋은 성능을 제공하며 교육 및 테스트 세트 모두에서 약 85%의 정확도를 제공합니다. 그러나 교육 세트와 테스트 세트 모두에서 모델 성능이 매우 비교 가능합니다. 이는 과소 적합일 가능성이 높습니다.
따라서 C 값을 높여 더 유연한 모델을 적합시킬 것입니다.
1
2
3
4
5
6
7
8
# fit the Logsitic Regression model with C=100
# instantiate the model
logreg100 = LogisticRegression(C=100, solver='liblinear', random_state=0)
# fit the model
logreg100.fit(X_train, y_train)
LogisticRegression(C=100, class_weight=None, dual=False, fit_intercept=True,
intercept_scaling=1, l1_ratio=None, max_iter=100,
multi_class='warn', n_jobs=None, penalty='l2',
random_state=0, solver='liblinear', tol=0.0001, verbose=0,
warm_start=False)
1
2
3
4
5
# print the scores on training and test set
print('Training set score: {:.4f}'.format(logreg100.score(X_train, y_train)))
print('Test set score: {:.4f}'.format(logreg100.score(X_test, y_test)))
Training set score: 0.8478 Test set score: 0.8505
C=100를 사용한 경우, 더 높은 테스트 세트 정확도와 약간 상승한 훈련 세트 정확도가 나타납니다. 따라서 더 복잡한 모델이 더 나은 성능을 발휘할 것으로 결론지을 수 있습니다.
이번에는 C=1의 기본값보다 더 규제가 있는 모델을 사용해 보기 위해 C=0.01로 설정하여 조사해 보겠습니다.
1
2
3
4
5
6
7
8
# fit the Logsitic Regression model with C=001
# instantiate the model
logreg001 = LogisticRegression(C=0.01, solver='liblinear', random_state=0)
# fit the model
logreg001.fit(X_train, y_train)
LogisticRegression(C=0.01, class_weight=None, dual=False, fit_intercept=True,
intercept_scaling=1, l1_ratio=None, max_iter=100,
multi_class='warn', n_jobs=None, penalty='l2',
random_state=0, solver='liblinear', tol=0.0001, verbose=0,
warm_start=False)
1
2
3
4
5
# print the scores on training and test set
print('Training set score: {:.4f}'.format(logreg001.score(X_train, y_train)))
print('Test set score: {:.4f}'.format(logreg001.score(X_test, y_test)))
Training set score: 0.8409 Test set score: 0.8448
C=0.01로 더 규제화된 모델을 사용할 경우, 기본 매개변수에 비해 학습 및 테스트 세트의 정확도가 모두 감소합니다.
모델 정확도와 Null 정확도 비교
그러면, 모델 정확도는 0.8501입니다. 하지만 위의 정확도만으로는 모델이 얼마나 좋은지를 판단할 수 없습니다. 이를 위해, null accuracy(무작위 예측 정확도) 와 비교해야 합니다. Null accuracy란 가장 빈번한 클래스를 항상 예측함으로써 얻을 수 있는 정확도입니다.
따라서, 먼저 테스트 세트의 클래스 분포를 확인해야 합니다.
1
2
3
# check class distribution in test set
y_test.value_counts()
No 22067 Yes 6372 Name: RainTomorrow, dtype: int64
우리는 가장 빈번한 클래스의 발생 횟수가 22067임을 확인할 수 있습니다. 따라서 총 발생 횟수로 나누어 22067을 계산하여 널 정확도(null accuracy)를 계산할 수 있습니다.
1
2
3
4
5
# check null accuracy score
null_accuracy = (22067/(22067+6372))
print('Null accuracy score: {0:0.4f}'. format(null_accuracy))
Null accuracy score: 0.7759
우리는 우리의 모델 정확도 점수가 0.8501이지만 널 정확도 점수는 0.7759임을 알 수 있습니다. 따라서, 우리는 우리의 로지스틱 회귀 모델이 클래스 레이블을 예측하는 데 매우 잘 수행하고 있다고 결론을 내릴 수 있습니다.
위 분석을 기반으로, 우리는 분류 모델의 정확도가 매우 좋다는 결론을 내릴 수 있습니다. 우리 모델은 클래스 레이블을 예측하는 데 아주 잘하고 있습니다.
하지만, 이는 값의 분포를 제공하지 않으며, 분류기가 만드는 오류 유형에 대해 아무것도 알려주지 않습니다.
이 때, 우리를 구할 수 있는 도구인 오차 행렬(Confusion matrix)이 있습니다.
15. 혼동 행렬
혼동 행렬(confusion matrix)은 분류 알고리즘의 성능을 요약하는 도구입니다. 혼동 행렬을 통해 분류 모델의 성능과 모델이 생성한 오류의 유형을 명확하게 파악할 수 있습니다. 혼동 행렬은 각 범주별로 올바르게 예측된 경우와 잘못 예측된 경우를 요약하여 표로 나타낸 요약 정보를 제공합니다.
분류 모델의 성능 평가 중 발생 가능한 결과는 아래와 같습니다.
True Positives (TP) – True Positives는 관측치가 특정 클래스에 속한다고 예측하고 관측치가 실제로 해당 클래스에 속하는 경우입니다.
True Negatives (TN) – True Negatives는 관측치가 특정 클래스에 속하지 않는다고 예측하고 관측치가 실제로 해당 클래스에 속하지 않는 경우입니다.
False Positives (FP) – False Positives는 관측치가 특정 클래스에 속한다고 예측했지만, 실제로는 해당 클래스에 속하지 않는 경우입니다. 이러한 유형의 오류는 Type I error라고 합니다.
False Negatives (FN) – False Negatives는 관측치가 특정 클래스에 속하지 않는다고 예측했지만, 실제로는 해당 클래스에 속하는 경우입니다. 이는 매우 심각한 오류로 Type II error라고 합니다.
이러한 네 가지 결과는 아래의 혼동 행렬에 요약됩니다.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# Print the Confusion Matrix and slice it into four pieces
from sklearn.metrics import confusion_matrix
cm = confusion_matrix(y_test, y_pred_test)
print('Confusion matrix\n\n', cm)
print('\nTrue Positives(TP) = ', cm[0,0])
print('\nTrue Negatives(TN) = ', cm[1,1])
print('\nFalse Positives(FP) = ', cm[0,1])
print('\nFalse Negatives(FN) = ', cm[1,0])
Confusion matrix [[20892 1175] [ 3086 3286]] True Positives(TP) = 20892 True Negatives(TN) = 3286 False Positives(FP) = 1175 False Negatives(FN) = 3086
혼동 행렬(confusion matrix)은 분류 알고리즘의 성능을 요약하는 도구입니다. 이것은 분류 모델의 성능과 모델이 만드는 오류의 유형을 분명하게 보여줍니다. 이는 각 범주별로 올바른 및 잘못된 예측을 요약하여 보여줍니다. 이 요약은 표 형태로 나타냅니다.
분류 모델의 성능을 평가하는 동안 4가지 결과가 가능합니다. 이 네 가지 결과는 다음과 같습니다.
True Positives (TP) - True Positives는 우리가 관찰이 특정 클래스에 속한다고 예측하고, 실제로 그 클래스에 속한 경우입니다.
True Negatives (TN) - True Negatives는 우리가 관찰이 특정 클래스에 속하지 않는다고 예측하고, 실제로 그 클래스에 속하지 않는 경우입니다.
False Positives (FP) - False Positives는 관찰이 특정 클래스에 속한다고 예측하지만, 실제로는 그 클래스에 속하지 않은 경우입니다. 이러한 유형의 오류를 1형 오류(Type I error)라고합니다.
False Negatives (FN) - False Negatives는 우리가 관찰이 특정 클래스에 속하지 않는다고 예측하지만, 실제로는 그 클래스에 속한 경우입니다. 이는 매우 심각한 오류이며 2형 오류(Type II error)라고합니다.
이 네 가지 결과는 아래의 혼동 행렬에서 요약됩니다.
1
2
3
4
5
6
# visualize confusion matrix with seaborn heatmap
cm_matrix = pd.DataFrame(data=cm, columns=['Actual Positive:1', 'Actual Negative:0'],
index=['Predict Positive:1', 'Predict Negative:0'])
sns.heatmap(cm_matrix, annot=True, fmt='d', cmap='YlGnBu')
<matplotlib.axes._subplots.AxesSubplot at 0x7f28b1306208>
16. 분류 행렬
분류 보고서
분류 보고서(Classification report)는 분류 모델의 성능을 평가하는 또 다른 방법입니다. 이 보고서는 모델의 정밀도(precision), 재현율(recall), F1점수(f1 score) 및 지원(support) 점수를 표시합니다. 이에 대한 설명은 이후에 제공됩니다.
분류 보고서를 다음과 같이 출력할 수 있습니다.
1
2
3
from sklearn.metrics import classification_report
print(classification_report(y_test, y_pred_test))
precision recall f1-score support
No 0.87 0.95 0.91 22067
Yes 0.74 0.52 0.61 6372
accuracy 0.85 28439
macro avg 0.80 0.73 0.76 28439
weighted avg 0.84 0.85 0.84 28439
분류 정확도
1
2
3
4
TP = cm[0,0]
TN = cm[1,1]
FP = cm[0,1]
FN = cm[1,0]
1
2
3
4
5
# print classification accuracy
classification_accuracy = (TP + TN) / float(TP + TN + FP + FN)
print('Classification accuracy : {0:0.4f}'.format(classification_accuracy))
Classification accuracy : 0.8502
분류 오류
1
2
3
4
5
# print classification error
classification_error = (FP + FN) / float(TP + TN + FP + FN)
print('Classification error : {0:0.4f}'.format(classification_error))
Classification error : 0.1498
정밀도
정밀도(Precision)는 모델이 예측한 양성 클래스 중 실제로 양성인 비율을 의미합니다. 즉, TP/(TP+FP)의 비율로 계산됩니다. 정밀도는 모델이 양성 클래스에 대해서 얼마나 잘 예측했는지에 관심이 있습니다.
1
2
3
4
5
6
# print precision score
precision = TP / float(TP + FP)
print('Precision : {0:0.4f}'.format(precision))
Precision : 0.9468
민감도
Recall는 실제 양성 클래스 중에서 정확하게 예측한 비율을 말합니다. Recall은 민감도(Sensitivity) 라고도 부릅니다. Recall은 양성 클래스에 더 관심을 두는 지표입니다.
수학적으로 Recall은 TP / (TP + FN) 으로 정의됩니다.
1
2
3
recall = TP / float(TP + FN)
print('Recall or Sensitivity : {0:0.4f}'.format(recall))
Recall or Sensitivity : 0.8713
진짜 양성 비율
True Positive Rate(진짜 양성 비율)은 Recall(재현율)과 동의어입니다.
1
2
3
4
true_positive_rate = TP / float(TP + FN)
print('True Positive Rate : {0:0.4f}'.format(true_positive_rate))
True Positive Rate : 0.8713
거짓 양성 비율
1
2
3
4
false_positive_rate = FP / float(FP + TN)
print('False Positive Rate : {0:0.4f}'.format(false_positive_rate))
False Positive Rate : 0.2634
특이성
1
2
3
specificity = TN / (TN + FP)
print('Specificity : {0:0.4f}'.format(specificity))
Specificity : 0.7366
f1-score
f1-score는 정밀도(precision)와 재현율(recall)의 가중치 조화 평균(weighted harmonic mean)입니다. 최적의 f1-score는 1.0이며, 최악의 경우에는 0.0입니다. f1-score는 정밀도와 재현율의 가중치 조화 평균으로, 따라서 정확도 측정값보다 항상 작습니다. 분류 모델을 비교하기 위해 가중 평균된 f1-score를 사용해야 하며, 전역적인 정확도보다는 분류 모델의 성능을 평가할 때 더욱 유용합니다.
지지도
Support(지지도)란 데이터셋에서 해당 클래스가 실제로 등장한 횟수를 의미합니다.
17. 임계값 수준 조정하기
1
2
3
4
5
# print the first 10 predicted probabilities of two classes- 0 and 1
y_pred_prob = logreg.predict_proba(X_test)[0:10]
y_pred_prob
array([[0.91382428, 0.08617572],
[0.83565645, 0.16434355],
[0.82033915, 0.17966085],
[0.99025322, 0.00974678],
[0.95726711, 0.04273289],
[0.97993908, 0.02006092],
[0.17833011, 0.82166989],
[0.23480918, 0.76519082],
[0.90048436, 0.09951564],
[0.85485267, 0.14514733]])
관찰 결과
-
각 행은 모두 1의 값을 가진다.
-
2개의 열은 2개의 클래스(0과 1)에 해당한다.
-
클래스 0 - 내일 비가 오지 않을 확률을 예측
-
클래스 1 - 내일 비가 올 확률을 예측
-
-
예측된 확률의 중요성
- 예측된 확률에 따라 관측치를 순위별로 나열할 수 있다.
-
predict_proba 과정
-
확률을 예측한다.
-
가장 높은 확률을 가진 클래스를 선택한다.
-
-
분류 임계값
-
0.5의 분류 임계값이 있다.
-
확률 > 0.5이면 클래스 1 - 비가 올 확률이 예측된다.
-
확률 < 0.5이면 클래스 0 - 비가 오지 않을 확률이 예측된
-
1
2
3
4
5
# store the probabilities in dataframe
y_pred_prob_df = pd.DataFrame(data=y_pred_prob, columns=['Prob of - No rain tomorrow (0)', 'Prob of - Rain tomorrow (1)'])
y_pred_prob_df
| Prob of - No rain tomorrow (0) | Prob of - Rain tomorrow (1) | |
|---|---|---|
| 0 | 0.913824 | 0.086176 |
| 1 | 0.835656 | 0.164344 |
| 2 | 0.820339 | 0.179661 |
| 3 | 0.990253 | 0.009747 |
| 4 | 0.957267 | 0.042733 |
| 5 | 0.979939 | 0.020061 |
| 6 | 0.178330 | 0.821670 |
| 7 | 0.234809 | 0.765191 |
| 8 | 0.900484 | 0.099516 |
| 9 | 0.854853 | 0.145147 |
1
2
3
# print the first 10 predicted probabilities for class 1 - Probability of rain
logreg.predict_proba(X_test)[0:10, 1]
array([0.08617572, 0.16434355, 0.17966085, 0.00974678, 0.04273289,
0.02006092, 0.82166989, 0.76519082, 0.09951564, 0.14514733])
1
2
3
# store the predicted probabilities for class 1 - Probability of rain
y_pred1 = logreg.predict_proba(X_test)[:, 1]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# plot histogram of predicted probabilities
# adjust the font size
plt.rcParams['font.size'] = 12
# plot histogram with 10 bins
plt.hist(y_pred1, bins = 10)
# set the title of predicted probabilities
plt.title('Histogram of predicted probabilities of rain')
# set the x-axis limit
plt.xlim(0,1)
# set the title
plt.xlabel('Predicted probabilities of rain')
plt.ylabel('Frequency')
Text(0, 0.5, 'Frequency')
관찰결과
-
위의 히스토그램은 매우 긍정적으로 치우친 것을 볼 수 있습니다.
-
첫번째 열은 0.0과 0.1 사이의 확률을 가진 약 15000개의 관측치가 있다는 것을 알려줍니다.
-
확률이 0.5보다 큰 작은 수의 관측치가 있습니다.
-
따라서 이러한 소수의 관측치는 내일 비가 올 것으로 예측합니다.
-
대부분의 관측치는 내일 비가 오지 않을 것으로 예측합니다
임계값 낮추기
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
from sklearn.preprocessing import binarize
for i in range(1,5):
cm1=0
y_pred1 = logreg.predict_proba(X_test)[:,1]
y_pred1 = y_pred1.reshape(-1,1)
y_pred2 = binarize(y_pred1, i/10)
y_pred2 = np.where(y_pred2 == 1, 'Yes', 'No')
cm1 = confusion_matrix(y_test, y_pred2)
print ('With',i/10,'threshold the Confusion Matrix is ','\n\n',cm1,'\n\n',
'with',cm1[0,0]+cm1[1,1],'correct predictions, ', '\n\n',
cm1[0,1],'Type I errors( False Positives), ','\n\n',
cm1[1,0],'Type II errors( False Negatives), ','\n\n',
'Accuracy score: ', (accuracy_score(y_test, y_pred2)), '\n\n',
'Sensitivity: ',cm1[1,1]/(float(cm1[1,1]+cm1[1,0])), '\n\n',
'Specificity: ',cm1[0,0]/(float(cm1[0,0]+cm1[0,1])),'\n\n',
'====================================================', '\n\n')
With 0.1 threshold the Confusion Matrix is [[12726 9341] [ 547 5825]] with 18551 correct predictions, 9341 Type I errors( False Positives), 547 Type II errors( False Negatives), Accuracy score: 0.6523084496641935 Sensitivity: 0.9141556811048337 Specificity: 0.5766982371867494 ==================================================== With 0.2 threshold the Confusion Matrix is [[17066 5001] [ 1234 5138]] with 22204 correct predictions, 5001 Type I errors( False Positives), 1234 Type II errors( False Negatives), Accuracy score: 0.7807588171173389 Sensitivity: 0.8063402385436284 Specificity: 0.7733720034440568 ==================================================== With 0.3 threshold the Confusion Matrix is [[19080 2987] [ 1872 4500]] with 23580 correct predictions, 2987 Type I errors( False Positives), 1872 Type II errors( False Negatives), Accuracy score: 0.8291430781673055 Sensitivity: 0.7062146892655368 Specificity: 0.8646395069560883 ==================================================== With 0.4 threshold the Confusion Matrix is [[20191 1876] [ 2517 3855]] with 24046 correct predictions, 1876 Type I errors( False Positives), 2517 Type II errors( False Negatives), Accuracy score: 0.845529027040332 Sensitivity: 0.6049905838041432 Specificity: 0.9149861784565188 ====================================================
Comments
-
이진 분류 문제에서는, 기본적으로 0.5의 임계값을 사용하여 예측된 확률을 클래스 예측으로 변환합니다.
-
임계값은 민감도 또는 특이도를 높이기 위해 조정될 수 있습니다.
-
민감도와 특이도는 서로 반대 관계를 가지고 있습니다. 한쪽을 높이면 항상 다른 쪽이 낮아지고 그 반대도 마찬가지입니다.
-
임계값을 높이면 정확도가 높아짐을 볼 수 있습니다.
-
임계값 조정은 모델 구축 과정에서 마지막 단계 중 하나여야합니다.
18. ROC - AUC
ROC Curve는 분류 모델의 성능을 시각적으로 측정하는 또 다른 도구입니다. ROC Curve는 Receiver Operating Characteristic Curve의 약자입니다. ROC Curve는 분류 모델이 다양한 분류 임계값에서 어떻게 수행되는지를 보여주는 그래프입니다.
ROC Curve는 다양한 임계값에서의 True Positive Rate (TPR)와 False Positive Rate (FPR)를 나타냅니다.
True Positive Rate (TPR)은 Recall이라고도 불립니다. TPR은 TP를 (TP + FN)으로 나눈 비율로 정의됩니다.
False Positive Rate (FPR)은 FP를 (FP + TN)으로 나눈 비율로 정의됩니다.
ROC Curve에서는 단일 지점의 TPR (True Positive Rate)과 FPR (False Positive Rate)에 집중합니다. 이것은 다양한 분류 임계값에서 TPR과 FPR을 포함하는 ROC Curve의 일반적인 성능을 제공합니다. 따라서 ROC Curve는 다양한 분류 임계값에서 TPR과 FPR을 나타내며, 임계값을 낮추면 더 많은 항목이 positive로 분류될 수 있습니다. 이것은 TP와 FP 모두를 증가시킬 것입니다.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# plot ROC Curve
from sklearn.metrics import roc_curve
fpr, tpr, thresholds = roc_curve(y_test, y_pred1, pos_label = 'Yes')
plt.figure(figsize=(6,4))
plt.plot(fpr, tpr, linewidth=2)
plt.plot([0,1], [0,1], 'k--' )
plt.rcParams['font.size'] = 12
plt.title('ROC curve for RainTomorrow classifier')
plt.xlabel('False Positive Rate (1 - Specificity)')
plt.ylabel('True Positive Rate (Sensitivity)')
plt.show()
ROC 곡선은 특정 상황에서 민감도와 특이도를 균형있게 조절할 수 있는 임계값을 선택하는 데 도움을 줍니다.
ROC - AUC
ROC AUC는 Receiver Operating Characteristic - Area Under Curve의 약자로, 분류기의 성능을 비교하는 기술 중 하나입니다. 이 기술에서는 ROC 곡선 아래의 면적을 측정합니다. 완벽한 분류기는 ROC AUC가 1이며, 완전한 무작위 분류기는 ROC AUC가 0.5입니다.
따라서, ROC AUC는 ROC 곡선 아래 면적의 백분율입니다.
1
2
3
4
5
6
7
# compute ROC AUC
from sklearn.metrics import roc_auc_score
ROC_AUC = roc_auc_score(y_test, y_pred1)
print('ROC AUC : {:.4f}'.format(ROC_AUC))
ROC AUC : 0.8729
Comments
-
ROC AUC는 분류기 성능의 단일 숫자 요약입니다. 값이 높을수록 분류기가 더 좋습니다.
-
모델의 ROC AUC는 1에 가까워지므로, 우리는 우리의 분류기가 내일 비가 올지 아닌지 예측하는 데 잘 작동한다는 결론을 내릴 수 있습니다.
1
2
3
4
5
6
7
# calculate cross-validated ROC AUC
from sklearn.model_selection import cross_val_score
Cross_validated_ROC_AUC = cross_val_score(logreg, X_train, y_train, cv=5, scoring='roc_auc').mean()
print('Cross validated ROC AUC : {:.4f}'.format(Cross_validated_ROC_AUC))
Cross validated ROC AUC : 0.8695
19. k-폴드 교차 검증
1
2
3
4
5
6
7
# Applying 5-Fold Cross Validation
from sklearn.model_selection import cross_val_score
scores = cross_val_score(logreg, X_train, y_train, cv = 5, scoring='accuracy')
print('Cross-validation scores:{}'.format(scores))
Cross-validation scores:[0.84686387 0.84624852 0.84633642 0.84963298 0.84773626]
교차 검증 정확도는 각 폴드에서 얻은 정확도를 평균내어 요약할 수 있습니다.
1
2
3
# compute Average cross-validation score
print('Average cross-validation score: {:.4f}'.format(scores.mean()))
Average cross-validation score: 0.8474
우리의 원래 모델 점수는 0.8476입니다. 평균 교차 검증 점수는 0.8474입니다. 따라서 교차 검증은 성능 향상을 가져오지 않는 것으로 결론을 내릴 수 있습니다.
20. GridSearch CV를 사용한 하이퍼파라미터 최적화
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
from sklearn.model_selection import GridSearchCV
parameters = [{'penalty':['l1','l2']},
{'C':[1, 10, 100, 1000]}]
grid_search = GridSearchCV(estimator = logreg,
param_grid = parameters,
scoring = 'accuracy',
cv = 5,
verbose=0)
grid_search.fit(X_train, y_train)
GridSearchCV(cv=5, error_score='raise-deprecating',
estimator=LogisticRegression(C=1.0, class_weight=None, dual=False,
fit_intercept=True,
intercept_scaling=1, l1_ratio=None,
max_iter=100, multi_class='warn',
n_jobs=None, penalty='l2',
random_state=0, solver='liblinear',
tol=0.0001, verbose=0,
warm_start=False),
iid='warn', n_jobs=None,
param_grid=[{'penalty': ['l1', 'l2']}, {'C': [1, 10, 100, 1000]}],
pre_dispatch='2*n_jobs', refit=True, return_train_score=False,
scoring='accuracy', verbose=0)
1
2
3
4
5
6
7
8
9
10
# examine the best model
# best score achieved during the GridSearchCV
print('GridSearch CV best score : {:.4f}\n\n'.format(grid_search.best_score_))
# print parameters that give the best results
print('Parameters that give the best results :','\n\n', (grid_search.best_params_))
# print estimator that was chosen by the GridSearch
print('\n\nEstimator that was chosen by the search :','\n\n', (grid_search.best_estimator_))
GridSearch CV best score : 0.8474
Parameters that give the best results :
{'penalty': 'l1'}
Estimator that was chosen by the search :
LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=True,
intercept_scaling=1, l1_ratio=None, max_iter=100,
multi_class='warn', n_jobs=None, penalty='l1',
random_state=0, solver='liblinear', tol=0.0001, verbose=0,
warm_start=False)
1
2
3
# calculate GridSearch CV score on test set
print('GridSearch CV score on test set: {0:0.4f}'.format(grid_search.score(X_test, y_test)))
GridSearch CV score on test set: 0.8507
Comments
-
우리의 원래 모델 테스트 정확도는 0.8501이고 GridSearch CV 정확도는 0.8507입니다.
-
우리는 이 특정 모델에서 GridSearch CV가 성능을 향상시켰다는 것을 알 수 있습니다.
21. 결과 및 결론
-
로지스틱 회귀 모델의 정확도 점수는 0.8501입니다. 따라서 이 모델은 오늘 오스트레일리아에서 비가 올 확률을 예측하는 데 아주 좋은 성과를 보입니다.
-
소수의 관측치만 내일 비가 올 것으로 예측하고, 대부분의 관측치는 내일 비가 오지 않을 것으로 예측합니다.
-
모델은 과적합의 징후가 없습니다.
-
C 값을 증가시키면 테스트 세트 정확도가 높아지며, 약간의 증가된 훈련 세트 정확도도 나타납니다. 따라서 더 복잡한 모델이 더 나은 성능을 발휘할 것으로 결론지을 수 있습니다.
-
임계값을 높이면 정확도가 높아집니다.
-
모델의 ROC AUC는 1에 가까워지므로, 이 분류기는 내일 비가 올 확률을 예측하는 데 아주 좋은 성과를 보인다고 결론지을 수 있습니다.
-
원래 모델의 정확도 점수는 0.8501이며, RFECV 후 정확도 점수는 0.8500입니다. 따라서 기능을 줄이면 거의 동일한 정확도를 얻을 수 있습니다.
-
원래 모델에서 FP = 1175이고 FP1 = 1174입니다. 따라서 거짓 양성의 수가 거의 동일합니다. 또한, FN = 3087이고 FN1 = 3091입니다. 따라서 약간 더 높은 거짓 음성을 얻을 수 있습니다.
-
원래 모델의 점수는 0.8476입니다. 평균 교차 검증 점수는 0.8474입니다. 따라서 교차 검증은 성능 향상을 가져오지 않는다고 결론짓을 수 있습니다.
-
원래 모델의 테스트 정확도는 0.8501이고, GridSearch CV 정확도는 0.8507입니다. 이를 통해 GridSearch CV가 이 모델에 대해 성능을 개선시켰음을 알 수 있습니다.
22. 참조
이 프로젝트에서 수행한 작업은 다음 책과 웹 사이트에서 영감을 얻었습니다.
-
Hands on Machine Learning with Scikit-Learn and Tensorflow by Aurélién Géron
-
Introduction to Machine Learning with Python by Andreas C. Müller and Sarah Guido
-
Udemy course – Machine Learning – A Z by Kirill Eremenko and Hadelin de Ponteves
-
Udemy course – Feature Engineering for Machine Learning by Soledad Galli
-
Udemy course – Feature Selection for Machine Learning by Soledad Galli
-
https://en.wikipedia.org/wiki/Logistic_regression
-
https://ml-cheatsheet.readthedocs.io/en/latest/logistic_regression.html
-
https://en.wikipedia.org/wiki/Sigmoid_function
-
https://www.statisticssolutions.com/assumptions-of-logistic-regression/
-
https://www.kaggle.com/mnassrib/titanic-logistic-regression-with-python
-
https://www.kaggle.com/neisha/heart-disease-prediction-using-logistic-regression
-
https://www.ritchieng.com/machine-learning-evaluate-classification-model/
댓글남기기