🤍

러닝스푼즈 수업 정리 

< 이전 글 > 

https://silvercoding.tistory.com/67

'결론이 무엇인지' 를 설명하는 것은 데이터사이언티스트로서의 중요한 업무이다. 

예측 결과만 보고는 모델이 어떤 패턴을 이용하여 예측을 실행하게 되었는지, 왜 그렇게 예측했는지 설명할 수 없다. 그렇게 되면 다른 분야의 협업자들은 신뢰를 잃게될 것이다. 

비즈니스의 관점에서 예를 들어본다. 머신러닝을 통하여 영화 흥행성적을 예측하는 프로젝트에서 흥행 실패라는 예측이 나왔다고 했을 때, 어떻게 흥행실패를 막을 것이냐고 질문이 들어올 수도 있다. 기존의 취약점을 보완하지 못한다면 비즈니스의 관점에서 의미가 없다. 

따라서 결과를 설명할 수 있는 것은 아주 중요하다. 이 때 변수중요도를 활용할 수 있다. 예측에 큰 영향을 미친 변수와, 특정 변수가 어떻게 영향을 미쳤는지 섬세하게 확인해볼 수 있다. 

변수중요도

- 모델에 활용한 input 변수 중에서 어떤 것이 target 값에 가장 큰 영향을 미쳤나? 
- 해당 중요도를 수치화시킨 것
- tree형 모델 (의사결정나무, 랜덤포레스트) 에서 계산 가능 

이전 글의 tree형 모델인 random forest와 xgboost에서 변수중요도 계산을 실행했었다.  

(참고)  배깅  부스팅

의사결정나무에서의 변수중요도

- 해당 input 변수가 의사결정나무의 구축에서 얼마나 많이 쓰이나 
- 해당 변수를 기준으로 분기를 했을 때 각 구간의 복잡도가 얼마나 줄어드는가? 

shapley 값 

: 각 변수가 예측 결과물에 주는 영향력의 크기

: 해당 변수가 어떤 영향을 주는가 

(예) 축구 선수 A , 속한 팀 B 

- 각 선수가 팀 성적에 주는 영향력 크키

- 해당 선수가 어떠한 영향을 주는가 

- (선수 A가 있는 팀 B의 승률) - (선수 A가 없는 팀 B의 승률 = 7% 

 shap value 실습 

shap value 실습에 중점을 두기 위해  Xgboost 학습까지 전에 했던 그대로 실행해준다. 

데이터 불러오기

import os
import pandas as pd
import numpy as np

os.chdir('./data') # 본인 경로 
data = pd.read_csv("bank-additional-full.csv", sep = ";")

이전 글에서 사용하였던 예금 가입 여부 데이터셋이다. 

data = pd.get_dummies(data, columns = ['job','marital','education','default','housing','loan','contact','month','day_of_week','poutcome'])

범주형 변수를 get_dummies를 이용하여 원핫인코딩 해준다. 

data['y'].value_counts()

분류 모델이기 때문에 목표변수도 당연히 범주형 변수로 되어있다. 

data['y'] = np.where( data['y'] == 'no', 0, 1)

하지만 shap value 패키지는 목표변수가 수치형이어야 잘 작동하기 때문에 수치화 시켜준다. 

Xgboost 학습 

input_var = ['age', 'duration', 'campaign', 'pdays', 'previous', 'emp.var.rate',
       'cons.price.idx', 'cons.conf.idx', 'euribor3m', 'nr.employed',
       'job_admin.', 'job_blue-collar', 'job_entrepreneur', 'job_housemaid',
       'job_management', 'job_retired', 'job_self-employed', 'job_services',
       'job_student', 'job_technician', 'job_unemployed', 'job_unknown',
       'marital_divorced', 'marital_married', 'marital_single',
       'marital_unknown', 'education_basic.4y', 'education_basic.6y',
       'education_basic.9y', 'education_high.school', 'education_illiterate',
       'education_professional.course', 'education_university.degree',
       'education_unknown', 'default_no', 'default_unknown', 'default_yes',
       'housing_no', 'housing_unknown', 'housing_yes', 'loan_no',
       'loan_unknown', 'loan_yes', 'contact_cellular', 'contact_telephone',
       'month_apr', 'month_aug', 'month_dec', 'month_jul', 'month_jun',
       'month_mar', 'month_may', 'month_nov', 'month_oct', 'month_sep',
       'day_of_week_fri', 'day_of_week_mon', 'day_of_week_thu',
       'day_of_week_tue', 'day_of_week_wed', 'poutcome_failure',
       'poutcome_nonexistent', 'poutcome_success']

y 컬럼을 제외한 인풋변수를 리스트에 모두 담아준다. 

from xgboost import XGBRegressor

수치형으로 예측을 진행하기 위해 XBGRegressor 회귀모델을 임포트 해준다. 

xgb = XGBRegressor( n_estimators = 300, learning_rate=0.1 )

xgb.fit(data[input_var], data['y'])

Xgboost 학습을 진행한다. 

Shap Value 예제 

import shap

shap 라이브러리를 import 해준다. 

(1) 변수중요도

explainer = shap.TreeExplainer(xgb)
shap_values = explainer.shap_values( data[input_var] )

shap.TreeExplainer의 인자에 학습한 모델 xgb를 넣어 객체를 저장해준다. 그다음 explainer.shap_values의 인자에 데이터셋의 인풋값을 넣어준다. 

shap.summary_plot( shap_values , data[input_var] , plot_type="bar" )

shap.summary_plot을 사용하여 변수중요도 그래프를 그려준다. 가장 높은 변수는 duration이다. duration은 전화시간이다. 전화시간의 길이가 이 모델의 예측에 가장 영향을 많이 미친다는 의미이다. 

(2) dependence plot 

: 특정 input 변수와 target 변수와의 관계를 표현하는 것 

: 점은 각각의 row를 의미(데이터 한개), 타겟변수에 미친 영향 = y 

: 해당 변수가 어떻게 영향을 미쳤는지 섬세하게 볼 수 있다. 

shap.dependence_plot( 'duration' , shap_values , data[input_var] )

duration의 그래프를 보면 duration의 대부분이 3000 미만에 존재하고, 그 중에서는 duration이 50이상쯤 되면 좋은 영향력을 끼쳐 1일 가능성이 높아진다고 해석된다. (shpa value for duration이 0보다 큰 데이터가 많음) 

shap.dependence_plot( 'nr.employed' , shap_values , data[input_var] )

5020쯤 되는 지점에서 영향력이 음수가 된다. 그리고 5100이 넘어가고는 음수의 영향력밖에 없다. (-> 0일 가능성이 높음) 그 이전에는 영향력이 높으므로 좋은 영향력을 끼친다. (-> 1일 가능성이 높음) 

shap.dependence_plot( 'euribor3m' , shap_values , data[input_var] )

음수와 양수가 비슷하게 분포되어있는 것 같아 보인다. 이 중에서 음수가 얼마 없고 양수가 많은 구간을 찾아보면 1.3~1.4 - 2, 4-5 가 있다. 해당 구간일 때 1일 가능성이 높다고 해석할 수 있다. 

shap.dependence_plot( 'cons.conf.idx' , shap_values , data[input_var] )

전체적으로 음수를 이루고 있음을 알 수 있다. -45이하일 때는 1일 가능성이 높아진다고 해석할 수 있다. 

shap.dependence_plot( 'pdays' , shap_values , data[input_var] )

pdays가 0일때 대다수의 데이터가 1일 가능성이 높아질 것이라 예상할 수 있다. 

(3) force plot

: 특정 값이 어떻게 예측되었는지를 시각화 

prediction = xgb.predict(data[input_var])
data['pred'] = prediction

shap.initjs()
shap.force_plot( explainer.expected_value , shap_values[41187] , data[input_var].iloc[41187] )

411187번째 데이터는 0.09가 나왔는데, 떨어뜨리는 변수와 올리는 변수가 골고루 분포되어 있다. 

shap.force_plot( explainer.expected_value , shap_values[0] , data[input_var].iloc[41187] )

0에 거의 가깝게 예측된 0번째 데이터는 거의 모든 변수가 음수의 영향력을 끼친 것을 볼 수 있다. 

41183번째 데이터는 양의 영향력이 훨씬 높은 것을 볼 수 있다. 따라서 0.88의 결과가 나왔고, 정답은 1로, 근접하게 맞혔다. 

이렇게 shap 라이브러리를 사용하여 각 변수가 예측에 어떠한 영향을 미쳤는지 섬세하게 알아볼 수 있었다.  

러닝스푼즈 수업 정리 

< 이전 글 > 

https://silvercoding.tistory.com/66

부스팅 Boosting

각 모델의 다양성 확보 (부스팅 절차) 

• 이전 모델에서 오분류한 객체에 가중치를 높여 새로운 데이터(가중치가 부여된)로 모델 학습
• 각 데이터셋으로 모델 만듦
• 모델별로 학습하는 데이터셋의 다양성으로 인해 모델의 다양성 확보

최종 결과물 결합

• 각 모델로부터 나온 예측치를 가중평균

n_estimators 설정 

(n_estimators : 몇 개의 의사결정나무를 만들 것인지) 

• n_estimators 가 너무 높으면 노이즈에 민감한 오버피팅 우려 
• n_estimators가 너무 낮으면 언더피팅 우려 
• 적절한 n_estimators를 찾아내는 것이 관건 

데이터 불러오기 

import os
import pandas as pd

os.chdir('../data')   # 본인 파일이 존재하는 폴더 경로
data = pd.read_csv("bank-additional-full.csv", sep = ';')

data.head()

data.info()

전처리 - 범주형 변수 원핫인코딩

data = pd.get_dummies(data,columns=['job','marital','education','default','housing','loan','contact','month','day_of_week','poutcome'])

dtype이 object인 범주형 변수를 get_dummies를 사용하여 원핫인코딩 해준다. 

train & test 데이터셋 분리 

data['id']=range(len(data))

데이터를 구분하기 위하여 각 row에 id를 부여한다. 

train = data.sample(30000,replace=False,random_state=2020).reset_index().drop(['index'],axis=1)

test = data.loc[ ~data['id'].isin(train['id']) ].reset_index().drop(['index'],axis=1)

이전글과 동일하게 train, test 데이터셋을 분리해 준다.

인풋변수 저장 

data.columns

input_var = ['age', 'duration', 'campaign', 'pdays', 'previous', 'emp.var.rate',
       'cons.price.idx', 'cons.conf.idx', 'euribor3m', 'nr.employed',
       'job_admin.', 'job_blue-collar', 'job_entrepreneur', 'job_housemaid',
       'job_management', 'job_retired', 'job_self-employed', 'job_services',
       'job_student', 'job_technician', 'job_unemployed', 'job_unknown',
       'marital_divorced', 'marital_married', 'marital_single',
       'marital_unknown', 'education_basic.4y', 'education_basic.6y',
       'education_basic.9y', 'education_high.school', 'education_illiterate',
       'education_professional.course', 'education_university.degree',
       'education_unknown', 'default_no', 'default_unknown', 'default_yes',
       'housing_no', 'housing_unknown', 'housing_yes', 'loan_no',
       'loan_unknown', 'loan_yes', 'contact_cellular', 'contact_telephone',
       'month_apr', 'month_aug', 'month_dec', 'month_jul', 'month_jun',
       'month_mar', 'month_may', 'month_nov', 'month_oct', 'month_sep',
       'day_of_week_fri', 'day_of_week_mon', 'day_of_week_thu',
       'day_of_week_tue', 'day_of_week_wed', 'poutcome_failure',
       'poutcome_nonexistent', 'poutcome_success']

data의 컬럼에서 y를 제외한 컬럼을 input_var에 저장해 준다. 

XGBoost 모델학습 

XGBoost 

- 특징 

• 해석이 어려움 
• 대체적으로 랜덤포레스트에 비해 빠르고 성능이 좋음

- xgb = XGBClassifier( n_estimators = 300, learning_rate = 0.1 )

• n_estimators : 몇 개의 의사결정나무를 만들 것인지 
• learning_rate : 얼마나 빠르게 학습할 것인지 

-설치 

!pip install xgboost

우선 xgboost가 설치되어있지 않다면 설치해 준다. 

from xgboost import XGBClassifier

xgb = XGBClassifier( n_estimators = 300, learning_rate = 0.1 )
xgb.fit(train[input_var], train['y'])

객체 생성을 하고, train 데이터셋으로 학습까지 진행한다. 

predictions = xgb.predict(test[input_var])

test 데이터셋으로 예측을 수행한 후 predictions에 저장한다. 

(pd.Series(predictions)==test['y']).mean()

정확도가 약 91 % 가 나왔다. 현재 모델은 n_estimators를 300으로 지정하였다. 앞에서 학습하였듯이, 오버피팅과 언더피팅을 피하기 위해서는 부스팅에서 n_estimators를 적절하게 설정하는 것이 관건이라고 하였다. 따라서 최적의 n_estimators를 찾아보도록 한다. 

최적 의사결정나무 수 ( n_estimators ) 찾기 

for n in [100,200,300,400,500,600,700,800,900]:
    xgb = XGBClassifier( n_estimators = n, learning_rate = 0.05, eval_metric='logloss' )
    xgb.fit(train[input_var], train['y'])
    predictions = xgb.predict(test[input_var])
    print((pd.Series(predictions)==test['y']).mean())

결과 : 최적의 n_estimators 는 400이다. 

변수중요도 

feature_imp = xgb.feature_importances_

feature_importances_ 를 사용하여 변수중요도를 계산할 수 있다. 

imp_df = pd.DataFrame({'var':input_var,
                       'imp':feature_imp})

imp_df.sort_values(['imp'],ascending=False)

변수중요도를 내림차순으로 정렬해보니 nr.emplyed 컬럼이 가장 중요한 변수로 나온 것을 볼 수 있다. 

러닝스푼즈 수업 정리 

< 이전 글 > 

https://silvercoding.tistory.com/65

배깅 bagging 

- 배깅의 철학 

1. 많을수록 좋다. 

2. 다양할수록 좋다. 

(ex) 남성 1명 < 남성 10명 (수가 많음) < 남성 5명 , 여성 5명 (수가 많고 다양함) 

- 각 모델의 다양성 확보를 어떻게 하는가? (배깅 프로세스)  

1. 전체 데이터셋에서 랜덤 샘플링 ( 복원 추출 / 중복 데이터가 나올수도, 아예 뽑히지 않은 데이터가 있을수도. ) -> 여러 데이터셋 생성 

2. 각 데이터셋으로 모델 생성 

3. 모델별로 학습하는 데이터셋이 다르므로 모델의 다양성 확보 

- 최종 결과물의 결합? 

: 각 모델로부터 나온 예측치의 단순 평균을 구한다. 

- 랜덤포레스트 (본 포스팅에서 사용할 모델) 

: 배깅의 프로세스를 따르면서 의사결정나무를 사용하는 알고리즘 

 데이터 살펴보기 

사용할 데이터는 캐글의 Dataset 에서 받을 수 있다. 

< Bank Marketing dataset > 

https://www.kaggle.com/volodymyrgavrysh/bank-marketing-campaigns-dataset

import os
import pandas as pd

os.chdir('../data')  # 본인의 파일 폴더 경로 
data = pd.read_csv("bank-additional-full.csv", sep = ';')

데이터를 불러올 때 주의할 점은 sep=';' 을 설정해 주어야 한다는 것이다. 이 파일은 csv 파일이지만 콤마(,) 가 아닌 세미콜론(;) 으로 구분이 되어있기 때문이다. 

data.head()

나이, 직업, 결혼여부, 대출여부 등의 예측변수를 사용하여 해당 고객의 예금 가입여부를 맞히는 학습을 진행한다. 

data.info()

dtype이 object인 변수는 범주형 변수로 ,  원핫인코딩을 해주어야 한다. 

 랜덤포레스트 사용 

전처리 - 범주형 변수 원핫인코딩

- dtype이 object인 컬럼 추출 

obj_column = []
for column in data.columns[:-1]:
    if data[column].dtype == 'object':
        obj_column.append(column)
        
obj_column

data = pd.get_dummies(data,columns=obj_column)

get_dummies를 이용하여 원핫인코딩을 진행한다. 

data

컬럼수가 많이 늘어난 것을 볼 수 있다.

data['id']=range(len(data))

데이터 구분을 위하여 id값을 부여한다. 

- train & test 데이터셋 분리 

train = data.sample(30000,replace=False,random_state=2020).reset_index().drop(['index'],axis=1)

train 데이터셋을 비복원추출로 30000개를 구성한다. 

test = data.loc[ ~data['id'].isin(train['id']) ].reset_index().drop(['index'],axis=1)

test데이터셋은 train에 없는 id값으로 총 11188개의 데이터로 구성된다. 

랜덤포레스트 모델 학습 

랜덤포레스트

- 특징 

• 해석이 어려움
• 매우 느림
• 의사결정나무보다 더 객관적인 변수 중요도를 뽑아낼 수 있음 

- RandomForestClassifier(n_estimators=m, min_samples_split=n)

• n_estimators : 몇개의 의사결정 나무를 만드는가 
• max_depth : 각 의사결정나무의 최대 깊이 
• min_samples_split : 각 의사결정나무에서 각 노드의 최소 샘플 수 

from sklearn.ensemble import RandomForestClassifier

rf = RandomForestClassifier(n_estimators=500, min_samples_split=10)

랜덤포레스트 객체를 생성한다. 

data.columns

input_var = ['age', 'duration', 'campaign', 'pdays', 'previous', 'emp.var.rate',
       'cons.price.idx', 'cons.conf.idx', 'euribor3m', 'nr.employed',
       'job_admin.', 'job_blue-collar', 'job_entrepreneur', 'job_housemaid',
       'job_management', 'job_retired', 'job_self-employed', 'job_services',
       'job_student', 'job_technician', 'job_unemployed', 'job_unknown',
       'marital_divorced', 'marital_married', 'marital_single',
       'marital_unknown', 'education_basic.4y', 'education_basic.6y',
       'education_basic.9y', 'education_high.school', 'education_illiterate',
       'education_professional.course', 'education_university.degree',
       'education_unknown', 'default_no', 'default_unknown', 'default_yes',
       'housing_no', 'housing_unknown', 'housing_yes', 'loan_no',
       'loan_unknown', 'loan_yes', 'contact_cellular', 'contact_telephone',
       'month_apr', 'month_aug', 'month_dec', 'month_jul', 'month_jun',
       'month_mar', 'month_may', 'month_nov', 'month_oct', 'month_sep',
       'day_of_week_fri', 'day_of_week_mon', 'day_of_week_thu',
       'day_of_week_tue', 'day_of_week_wed', 'poutcome_failure',
       'poutcome_nonexistent', 'poutcome_success']

반환된 data의 컬럼에서 y를 뺀 컬럼들을 input_var 변수에 저장해 준다. 

rf.fit(train[input_var],train['y'])

train 데이터셋으로 랜덤포레스트분류기 모델 학습을 진행한다. 

predictions = rf.predict(test[input_var])

test데이터셋으로 예측을 진행하고, predictions 변수에 저장해 준다. 

(pd.Series(predictions)==test['y']).mean()

predictions와 정답값(y) 을 비교하여 평균을 내주면 정확도는 약 91% 가 나오게 된다. 

* 의사결정나무와의 비교 

from sklearn.tree import DecisionTreeClassifier

dt = DecisionTreeClassifier(min_samples_split=10)

의사결정나무 객체를 생성한다. 

dt.fit(train[input_var], train['y'])

predictions = dt.predict(test[input_var])

학습데이터를 사용한 학습과 테스트데이터를 사용한 예측을 진행한다. 

(pd.Series(predictions) == test['y']).mean()

정확도를 비교해보니 의사결정나무보다 랜덤포레스트 모델의 정확도가 조금 더 높은 것을 알 수 있다. 

변수중요도 

feature_imp = rf.feature_importances_
imp_df = pd.DataFrame({'var':input_var,
                       'imp':feature_imp})

imp_df.sort_values(['imp'],ascending=False)

feature_importances_ 를 사용하여 변수중요도를 알아볼 수 있다. 내림차순으로 정렬을 해 보았더니 duration이 가장 높고, default_yes 컬럼이 가장 낮은 것을 볼 수 있다.  (변수중요도에 대한 개념은 다다음시간에 자세히 알아본다.) 

러닝스푼즈 수업 정리 

< 이전 글 > 

https://silvercoding.tistory.com/64

 데이터 불러오기 

이전 글과 동일한 Iris Flower Dataset 을 이용하여 실습을 진행한다. 

< Iris Flower Dataset >

https://www.kaggle.com/arshid/iris-flower-dataset

import pandas as pd
import os

os.chdir('../data')  # 데이터셋이 있는 본인 폴더 경로

iris = pd.read_csv("IRIS.csv")

iris.head()

iris['species'].value_counts()

각 종류마다 50개의 데이터가 존재한다. 

의사결정나무 사용 

train & Test 데이터셋 분리 

iris['id'] = range(len(iris))

우선 데이터를 구분하기 위해 순서대로 값을 넣어준 id 컬럼을 생성한다. 

iris = iris[['id','sepal_length','sepal_width','petal_length','petal_width','species']]

id 컬럼이 가장 앞에 오도록 정렬해준다. 

train = iris.sample(100,replace=False,random_state=7).reset_index().drop(['index'],axis=1)

랜덤으로 100개의 샘플을 추출하여 train 에 저장해 준다. 

test = iris.loc[ ~iris['id'].isin(train['id']) ]
test = test.reset_index().drop(['index'],axis=1)

train의 id값이 존재하지 않는 iris 데이터들을 test에 넣어준다. 

의사결정나무 학습 

DecisionTreeClassifier(min_samples_split = n)

---> 특징 : 해석이 쉽고 빠르다. 

---> min_samples_split : 의사결정나무에서 최종 노드의 최소 샘플 수 

from sklearn.tree import DecisionTreeClassifier

dt = DecisionTreeClassifier(min_samples_split = 10)

min_samples_split 을 10으로 설정해주어 최종 노드의 샘플수가 10미만이 되지 않도록 조정한다. 

dt.fit(train[['sepal_length','sepal_width','petal_length','petal_width']],train['species'])

생성해 놓은 dt 객체로 학습을 시켜준다. 

predictions = dt.predict(test[['sepal_length','sepal_width','petal_length','petal_width']])

예측값을 prediction에 넣어준다. 

test['pred'] = predictions

예측값 prediction을 test의 pred 컬럼에 저장한다. 

test.head()

(pd.Series(predictions)==test['species']).mean()

예측값과 정답을 비교하여 정확도를 구해보니 0.98이 나왔다. 

위의 정확도 측정 방법을 사용하면 신뢰성이 하락할 수 있다. train, test 데이터를 어떻게 나누는지에 따라 결과가 크게 달라질 수도 있기 때문이다. 따라서 cross validation을 이용하여 정확도를 구해볼 수 있다. 

from sklearn.model_selection import cross_val_score
import numpy as np

dt = DecisionTreeClassifier(min_samples_split = 10)

scores = cross_val_score(dt, iris[['sepal_length','sepal_width','petal_length','petal_width']], iris['species'], cv=5, scoring="accuracy")
np.mean(scores)

이번 예시처럼 데이터 수가 적을 경우에는 위와 같이 전체 데이터로 cross validation을 수행하는 것이 신뢰성이 높다. 5 fold cross validation을 수행한 결과 , 정확도가 약 0.97이 나온 것을 볼 수 있다. 

의사결정나무 시각화

from sklearn import tree
import matplotlib.pyplot as plt

from matplotlib.pylab import rcParams
rcParams['figure.figsize'] = 16,10

a=tree.plot_tree(dt,feature_names = ['sepal_length','sepal_width','petal_length','petal_width'],impurity=False, max_depth=2, fontsize=10, proportion=True)
plt.show(a)

max_depth를 이용하여 깊이를 조절할 수 있다. 2개 이후로는 (...) 으로 생략된 것을 볼 수 있다. 위와 같이 의사결정 나무를 사용하고, 시각화 해보면 해석을 쉽고 간편하게 해낼 수 있다. 

러닝스푼즈 수업 정리 

< 이전 글 > 

https://silvercoding.tistory.com/63?category=967543 

KNN 개념 정리

* 1그룹 vs 2그룹 KNN 분류 과정

1. k 설정 : 가장 가까운 k개의 점을 선택 

2. k 개의 점 중 1그룹이 많은지 2그룹이 많은지 확인 

3. 더 많은 그룹의 범주로 분류한다.

* K를 찾아내는 과정

1. 학습데이터를 이용하여 각 K별로 KNN 모델 학습 

2. 만들어진 모델을 이용해 검증 데이터(테스트 데이터) 에서의 에러율 측정 

3. 에러율이 가장 작은 k 선택 

* 적절한 k를 찾아내어야 한다!

- k가 매우 작으면 노이즈에 민감한 과적합 우려 

- k가 매우 크면 지역적 구조를 파악할 수 있는 능력을 잃게 됨 

 데이터 살펴보기 

본 포스팅에서 사용할 데이터셋은 캐글의 다음링크에서 다운받을 수 있다. 

< Iris Flower Dataset >

https://www.kaggle.com/arshid/iris-flower-dataset

import pandas as pd
import os

os.chdir('../data')   # 본인 데이터셋이 존재하는 폴더 경로

iris = pd.read_csv("IRIS.csv")

iris.head()

(참고) sepal : 꽃받침 / petal : 꽃잎 

꽃받침의 크기와 꽃잎의 크기를 근거로 setosa, versicolor, virginica 총 3종류를 구분해 내는 분류모델을 만들 것이다. 

iris.info()

총 150개의 데이터가 들어 가 있고 , 결측값은 존재하지 않는다. 

iris['species'].value_counts()

value_counts() 함수를 이용하여 각 종류가 몇가지씩 있는지 확인해볼 수 있다. 각 종류마다 동일하게 50개씩 존재하는 것을 볼 수 있다. 

 KNN 실습 - 분류 

(ex) KNeighborsClassifier(n_neighbors=n)

---> 데이터가 많으면 느림 

---> n_neighbors=n : k의 개수 지정 (가장 가까운 K개를 볼것이라는 의미) 

iris['id'] = range(len(iris))

데이터를 식별하기 위하여 순서대로 값을 부여하여 id 컬럼에 넣어준다. 

iris = iris[['id','sepal_length','sepal_width','petal_length','petal_width','species']]

id 컬럼이 가장 첫번째에 오도록 정렬 해 준다. 

iris.head()

train & test data 분리 

train = iris.sample(100, replace=False, random_state=7).reset_index(drop=True)
train

학습 데이터셋에 랜덤으로 100개의 데이터를 추출한다. 비복원추출이고, 뒤죽박죽된 인덱스를 초기화 시켜준다. 

test = iris.loc[ ~iris['id'].isin(train['id']) ]
# test = test.reset_index().drop(['index'],axis=1)  # 밑과 같은 코드
test = test.reset_index(drop=True)

테스트 데이터셋에는 학습데이터셋에 없는 id값이 존재하는 row만 추출하여 구성한다. 마찬가지로 인덱스를 초기화 해준다. 

KNN 학습 (k=3 일 때 학습해보기) 

from sklearn.neighbors import KNeighborsClassifier

knn = KNeighborsClassifier(n_neighbors=3) # 모델 정의

k=3으로 설정한 KNN 분류기 객체를 생성한다. 

knn.fit( train[['sepal_length','sepal_width','petal_length','petal_width']] , train['species'] )

knn.fit(train_X, train_y) 와 같이 사용한다.  

predictions = knn.predict( test[['sepal_length','sepal_width','petal_length','petal_width']] )

knn.predict(test_X) 와 같이 사용한다.  test 데이터를 이용하여 예측을 하고, predictions에 저장해 준다. 

test['pred'] = predictions

test.head()

pred 컬럼에 예측 결과인 predictions를 추가해 주었다. 위의 5개를 보니 모두 정답을 맞춘 것을 볼 수 있다.  

(test['pred'] == test['species']).mean()

정답과 예측을 비교하여 정확도를 구해보니 0.94가 나왔다. 이제 여러 k값의 정확도를 구하여 최적의 k를 결정해 본다. 

최적 K 찾기 

- train & test 데이터 사용 

for k in range(1,30):
    knn = KNeighborsClassifier(n_neighbors=k)
    knn.fit( train[['sepal_length','sepal_width','petal_length','petal_width']] , train['species'] )
    predictions = knn.predict( test[['sepal_length','sepal_width','petal_length','petal_width']] )
    print((pd.Series(predictions) == test['species']).mean())

1부터 29까지의 k 의 학습을 진행하여 얻은 정확도이다. 높은 값 중에서 가장 첫번째를 고르면 k=5 (정확도 0.98) 이다. 

---> 최적의 K : 5

하지만 위의 방법을 사용하면 신뢰성이 하락할 수 있다. train, test 데이터를 어떻게 나누는지에 따라 결과가 크게 달라질 수도 있기 때문이다. 따라서 cross validation을 이용하여 정확도를 구해볼 수 있다. 

- cross validation 사용

from sklearn.model_selection import cross_val_score
import numpy as np

for k in range(1,30):
    knn = KNeighborsClassifier(n_neighbors=k)
    scores = cross_val_score(knn, iris[['sepal_length','sepal_width','petal_length','petal_width']], iris['species'], cv=5)
    print(f"{k} : " ,np.mean(scores))

5-fold-cross validation을 진행하였다. k=6 일때 가장 첫번째로 높은 정확도가 나온 것을 알 수 있다. 

---> 최적의 K : 6

 KNN 실습 - 회귀 

회귀문제에 KNN 을 사용할 수도 있다. 이러한 KNN 회귀문제를 실습을 해보기 위해 sepal_length, sepal_width, petal_length 를 이용하여 petal_width를 예측하는 모델을 생성한다. 

del train['species']
del test['species']

간단한 실습을 위하여 범주형 변수인 species 는 삭제해 준다. 그다음 분류문제와 똑같이 학습을 진행한다. 

from sklearn.neighbors import KNeighborsRegressor

knn = KNeighborsRegressor(n_neighbors=3)

knn.fit( train[['sepal_length','sepal_width','petal_length']] , train['petal_width'] )

predictions = knn.predict( test[['sepal_length','sepal_width','petal_length']] )

test['pred'] = predictions

test.head()

학습과 예측은 동일하게 진행한다.

* Mean absolute error ( MAE ) : 회귀문제에서 모델의 성능을 평가하는 방법 중 하나. 

MAE 는 다음과 같이 구할 수 있다. 

abs(test['petal_width'] - pd.Series(predictions)).mean()

정답에서 예측값을 빼고, 절댓값을 취해준 후 각각의 오류율의 평균을 구해주면 된다. 이 평가지표는 오류율이므로 작을 수록 잘 예측한 것이라 판단되어진다. 

for k in range(1,30):
    knn = KNeighborsRegressor(n_neighbors=k)
    knn.fit( train[['sepal_length','sepal_width','petal_length']] , train['petal_width'] )
    predictions = knn.predict( test[['sepal_length','sepal_width','petal_length']] )    
    print(str(k)+' :'+str(abs(test['petal_width'] - pd.Series(predictions)).mean()))

오류율이 가장 작은 k는 7임을 알 수 있다. 

---> 최적의 K : 7

러닝스푼즈 수업 정리 

< 이전 글 > 

https://silvercoding.tistory.com/62

 라이브러리 & 데이터 불러오기 

import pandas as pd 
import matplotlib.pyplot as plt
import seaborn as sns

data = pd.read_csv('./data/boston.csv')
data.head()

 군집화 Clustering 

del data['chas']

연속형 데이터만 다루기 위하여 범주형 데이터는 제거한다. 

medv = data['medv']
del data['medv']

타겟변수를 복사해 놓고, 타겟변수 컬럼을 지워준다. ( pca를 위하여 )

차원 축소 (PCA) : 12차원 -> 2차원 

from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA

차원 축소에 필요한 라이브러리를 import 해준다. 

- 정규화

scaler = StandardScaler()

정규화 객체를 생성한다. 

# 데이터 학습
scaler.fit(data)
# 변환
scaler_data = scaler.transform(data)

data 전체를 정규화하여 scaler_data에 저장해 준다. 

- PCA

pca = PCA(n_components = 2)

PCA 객체를 생성한다. 2차원 시각화를 위하여 변수는 2개로 설정한다. 

pca.fit(scaler_data)

pca로 scaler_data를 학습시킨다. 

data2 = pd.DataFrame(data = pca.transform(scaler_data), columns=['pc1', 'pc2'])

pca로 변환한 데이터를 데이터 프레임으로 data2에 저장한다. 

data2.head()

군집의 개수 정하기 - Elbow Point 지정 

from sklearn.cluster import KMeans

KMeans(n_cluster = k)

• k개의 군집화를 하겠다는 객체 생성

Kmeans.fit()

• 학습시키기

KMeans.inertia_

• 학습된 KMeans의 응집도를 확인
• 응집도란 각 데이터로부터 자신이 속한 군집의 중심까지의 거리를 의미
• 즉, 낮을수록 군집화가 더 잘되어있음.

KMeans.predict(data)

• 학습된 데이터를 바탕으로 데이터를 변환시켜줌

x = []   # k 가 몇개인지 
y = []   # 응집도가 몇인지 

for k in range(1, 30):
    kmeans = KMeans(n_clusters = k)
    kmeans.fit(data2)
    
    x.append(k)
    y.append(kmeans.inertia_)

1부터 30까지 군집화를 해보고, 가장 적절한 응집도의 군집개수를 정해주기 위하여 그래프를 그려본다. 

plt.plot(x, y)

군집의 개수 별 응집도 그래프를 그려보니 3~5개 정도가 적당할 것 같다. Elbow Point를 4로 지정하고 군집화를 해보도록 한다. 

군집화

kmeans = KMeans(n_clusters=4)

군집의 개수를 4로 설정하여 객체를 생성한다. 

kmeans.fit(data2)

위에서 생성해 놓은 data2를 학습한다. 

data2['labels'] = kmeans.predict(data2)

각각의 예측된 군집 종류를 labels 컬럼에 넣어준다. 

data2.head()

lebels가 1이라는 것은 해당 데이터가 1번 군집에 포함되었다는 의미이다. 

sns.scatterplot(x='pc1', y='pc2', hue='labels', data=data2)

위와 같이 군집이 형성되었음을 확인할 수 있다. 

결과 해석 

- 어떤 그룹의 집 값이 가장 높을까 ? : 평균으로 비교

data2['medv'] = medv

각 그룹의 집값 평균을 구하기 위해 처음에 저장해 주었던 medv 컬럼을 data2의 medv 컬럼으로 추가해 준다. 

data2.head()

data2[data2['labels']==0]['medv'].mean()

0번 군집의 집값의 평균은 다음과 같이 구한다. 이를 활용하여 모든 군집의 집값의 평균을 그래프로 그려보도록 한다. 

medv_list = []

for i in range(4):
    medv_avg = data2[data2['labels']==i]['medv'].mean()
    medv_list.append(medv_avg)

sns.barplot(x=['group_0', 'group_1', 'group_2', 'group_3'], y=medv_list)

집값의 평균 최상위 그룹 : group_2

집값의 평균 최하위 그룹 : group_0

---> 최상위 그룹과 최하위 그룹을 비교하여 집값의 평균이 높거나 낮은 이유에 대하여 확인해 본다. 

* 원본 데이터 사용하여 원인 분석해보기 

data['labels'] = data2['labels']

원본데이터에 그룹 labels를 추가해 준다. 

group = data[(data['labels']==0) | (data['labels']==2)]

그룹0, 그룹2 만 선택하여 group 변수에 저장한다. 

group = group.groupby('labels').mean().reset_index()

gropuby를 사용하여 labels 컬럼 별로 모든 컬럼의 평균값을 구하고, groupby로 인하여 인덱스가 되었던 labels를 reset_index()를 이용하여 다시 컬럼으로 변경해 준다. 

group

각 그룹별 평균이 구해진 것을 볼 수 있다. 이를 시각화 하여 비교해 보도록 한다. 

결과 해석 - 시각화 

column = group.columns
fig, ax = plt.subplots(2, 6, figsize=(30, 13))

for i in range(12):
    sns.barplot('labels', column[i+1], data=group, ax=ax[i//6, i%6])

두개의 막대가 그려져 있는 막대그래프로, 왼쪽이 높으면 집값이 낮은 이유의 근거가, 오른쪽이 높으면 집값이 높은 이유의 근거가 된다고 해석한다. 

결론

- (0,0) 위치의 그래프를 보면 crim( 범죄율 )이 0번 그룹에서 월등히 높다. 이는 범죄율이 높을수록 집값이 낮다고 해석할 수 있다. 

- (0, 1) 위치의 그래프에서는 zn( 25,000 평방비트를 초과하는 거주지역 비율 ) 이 높을수록 집값이 높다고 해석된다.

- 그다음으로 차이가 적어 보이는 것은 (1, 1) 위치의 그래프이다. rad( 방사형 고속도로까지의 거리 ) 가 높을수록 ( 방사형 고속도로까지의 거리가 멀수록 ) 집값이 낮다는 것을 알 수 있다.

이와 같이 여러 해석을 해볼 수 있다. 

러닝스푼즈 수업 정리 

 라이브러리 & 데이터 불러오기 

- 라이브러리 불러오기 

import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

- 데이터 불러오기 

data = pd.read_csv('./data/boston.csv')

data.head()

- 데이터 살펴보기 

data.info()

506개의 row가 존재하고, 결측값은 없는 것을 알 수 있다. 

data.columns

총 14개의 컬럼이 있다. 각 컬럼의 의미는 다음과 같다. 

• crim: 범죄율
• zn: 25,000 평방피트를 초과 거주지역 비율
• indus: 비소매상업지역 면적 비율
• chas: 찰스강의 경계에 위치한 경우는 1, 아니면 0
• nox: 일산화질소 농도
• rm: 주택당 방 수
• age: 1940년 이전에 건축된 주택의 비율
• dis: 직업센터의 거리
• rad: 방사형 고속도로까지의 거리
• tax: 재산세율
• ptratio: 학생/교사 비율
• b: 인구 중 흑인 비율
• lstat: 인구 중 하위 계층 비율
• medv : 보스턴 506개 타운의 1978년 주택 가격 중앙값 (단위 1,000 달러)

 Feature Selection : 상관계수와 공분산 

- 범주형 변수 제거 

del data['chas']

상관계수와 공분산은 연속형 자료를 분석하므로 범주형 변수를 제거한다. 실제 변수를 제거하는 것은 신중하게 행해야 하지만 , 학습을 위하여 제거한다.

가설 세우기 

1. 범죄율이 높은 곳의 집값은 낮을까? 

2. 방의 개수가 많은 곳의 집값은 높을까? 

3. 일산화질소 농도가 높을수록 집값은 낮을까? 

4. 재산세율이 높을수록 집값을 높을까?

1. 범죄율이 높은 곳의 집값은 낮을까? 

sns.jointplot(data=data, x='crim', y='medv', kind='reg')

극단적인 음의 관계는 아니지만 , 범죄율이 높아질 수록 집값이 낮아지는 추세를 볼 수 있다. 

- 공분산

data['crim'].cov(data['medv'])

음의 관계를 갖고 있음을 알 수 있다. 

- 상관계수 

data['crim'].corr(data['medv'])    # 피어슨상관계수 0.3 ~ 0.6 강한 상관계수

r이 -1.0과 -0.7 사이이면, 강한 음적 선형관계,

r이 -0.7과 -0.3 사이이면, 뚜렷한 음적 선형관계,

r이 -0.3과 -0.1 사이이면, 약한 음적 선형관계,

r이 -0.1과 +0.1 사이이면, 거의 무시될 수 있는 선형관계,

r이 +0.1과 +0.3 사이이면, 약한 양적 선형관계,

r이 +0.3과 +0.7 사이이면, 뚜렷한 양적 선형관계,

r이 +0.7과 +1.0 사이이면, 강한 양적 선형관계

출처 - https://ko.wikipedia.org/wiki/%EC%83%81%EA%B4%80_%EB%B6%84%EC%84%9D

위와 같은 피어슨 상관계수 해석을 보았을 때 범죄율과 집값은 뚜렷한 음적 선형관계라는 것을 알 수 있다. 

[ 가설1 : True ] 

2. 방의 개수가 많은 곳의 집값은 높을까? 

sns.jointplot(data=data, x='rm', y='medv', kind='reg')

그래프를 보면, 방의 개수가 많을수록 집값이 높아지는 경향이 있다는 것을 볼 수 있다. 

- 공분산

data['rm'].cov(data['medv'])

공분산을 보았을 때 양의 관계를 갖는 것을 알 수 있다. 

- 상관계수 

data['rm'].corr(data['medv'])

상관계수를 보니 강한 양적 선형관계에 가까운 뚜렷한 양적 선형관계라는 것을 알 수 있다. 여기서 공분산의 허점을 볼 수 있다. 가설2의 상관계수는 가설1에서 상관계수보다 더 뚜렷한 관계이지만, 공분산은 가설2가 더 높다. 

[ 가설2 : True ] 

3. 일산화질소 농도가 높을수록 집값은 낮을까?

sns.jointplot(data=data, x='nox', y='medv', kind='reg')

data['nox'].corr(data['medv'])

-0.4273207723732824

뚜렷한 음적 상관관계인 것을 알 수 있다. 일산화질소 농도가 높을 수록 집값은 낮아지는 경향을 보인다.

[ 가설3 : True ] 

4. 재산세율이 높을수록 집값을 높을까?

sns.jointplot(data=data, x='tax', y='medv', kind='reg')

data['tax'].corr(data['medv'])

-0.46853593356776696

뚜렷한 음적상관관계를 갖고 있고, 재산세율이 높을수록 집값이 낮아지는 것을 볼 수 있다. 

[ 가설4 : False ] 

- 모든데이터의 상관계수 알기 - heatmap 

plt.figure(figsize=(10, 7))
sns.heatmap(data.corr(), cmap='RdBu_r', annot=True, fmt='0.1f')

lstat와 rm 의 집값과의 상관계수가 가장 높은 것을 알 수 있다.  인구 중 하위 계층 비율(lstat)와는 음의 상관관계, 방의 개수(rm) 과는 양의 상관관계를 띈다. 반면 dis(직업센터의 거리), b(인구 중 흑인 비율) 와 집값은 낮은 상관관계를 보인다. 

 Feature Extraction 

- 상관관계 비교하여 몇개의 변수를 몇개로 줄일 것인지 결정 

corr_bar = []

for column in data.columns:
    print(f"{column}과 집값의 상관관계: {data[column].corr(data['medv'])}")
    corr_bar.append(abs(data[column].corr(data['medv'])))

각 컬럼별 집갑과의 상관계수를 출력해보고, corr_bar 리스트에는 절댓값을 취하여 추가해준다. 

corr_bar

sns.barplot(data.columns, corr_bar)

막대그래프를 그려보니 dis, b 가 다른 컬럼들보다 상관계수가 작은 것을 한눈에 볼 수 있다. 

x = data[['dis', 'b']]

data에서 두 변수를 선택하여 x에 저장한다. 

x.head()

PCA 사용 

from sklearn.decomposition import PCA

PCA(n_components)

• n_components : 몇가지의 변수를 만들지 개수를 정한다.
• 객체를 생성하는 개념

PCA.fit(x)

• x의 데이터를 학습시킴으로써 앞에서 생성한 객체가 데이터를 공부하는 개념

PCA.components_

• 앞서 학습한 내용을 바탕으로 만들어진 변수속에 담긴 이 전 변수의 분산이 담긴 정도

PCA.explained_variance_ratio_

• 새로운 변수가 설명하는 분산의 비율

PCA.transform

• 학습한 내용을 바탕으로 만들어진 학습기로 x의 데이터를 변환

- 2개의 변수 -> 1개의 변수 

pca = PCA(n_components=1)

n_components 에 생성할 변수를 작성해준다. 

pca.fit(x)

데이터를 학습킨다. 

pca.components_

새로운 변수에 담긴 각 변수의 분산을 확인해 본다. 그런데 오른쪽 (b) 의 분산이 너무 크다. 이는 오른쪽 변수의 정보만 많이 담겼다고 해석할 수 있다. ( -> 정규화가 필요한 이유 / 뒤에서 학습 ) 

pca.explained_variance_ratio_

새로운 변수가 설명하는 분산의 비율이다. 

data['pc1'] = pca.transform(x)

학습시킨 pca를 이용하여 x의 데이터를 변환한 데이터를 data의 pc1이라는 컬럼에 추가한다. 

data

추가 완료된 데이터프레임. 

sns.jointplot(data=data, x='pc1', y='medv', kind='reg')

data['pc1'].corr(data['medv'])

새로운 컬럼과 집값의 상관관계를 보면 전에 b변수의 상관계수와 별 차이가 없다. 정규화를 진행하여 다시 학습해 보자. 

정규화

from sklearn.preprocessing import StandardScaler

StandardScaler()

• 정규화 객체 생성

scaler.fit(x)

• 정규화 객체로 학습

scaler.transform(x)

• 학습된 학습기로 변수 x의 데이터를 변환

scaler = StandardScaler()

정규화 객체를 생성한다. 

scaler.fit(x)
scaler_x = scaler.transform(x)

x데이터를 학습시킨 후, 정규화 된 x로 데이터를 변환하여 scaler_x 에 저장해준다. 

scaler_x

- 정규화된 데이터로 pca 실행 

# 변수 1개로 설정 
pca = PCA(n_components=1)
# 데이터를 학습
pca.fit(scaler_x)
# 새로운 변수에 담긴 각 변수의 분산을 확인
# 위와 달라진 분산의 정도를 확인
pca.components_

정규화된 데이터로 pca를 진행하니 새로운 변수에 두가지의 변수의 분산이 동일하게 담긴 것을 볼 수 있다. 

pca.explained_variance_ratio_

새로운 변수가 설명하는 분산의 비율은 줄어들었지만 , 두가지 변수의 각 분산이 동일하게 담긴것이 더 중요하다. 

data['pc1'] = pca.transform(scaler_x)

data.head()

정규화된 데이터를 pca 변환하여 pc1 컬럼에 넣어주었다. 

- 상관계수 비교

sns.jointplot(data=data, x=data['pc1'], y=data['medv'], kind='reg')

data['pc1'].corr(data['medv'])

data['b'].corr(data['medv'])

이처럼 새로운 변수 pc1과 집값의 상관계수가 예전 두 변수의 상관계수보다 더 높아진 것을 확인할 수 있다. 

상관성이 없는 두 가지의 변수를 상관성이 더 높아지도록 하는 변수를 생성하는 pca를 학습하였다. 다음시간에는 오늘 학습한 pca를 사용하여 차원을 축소하고, 군집화, 시각화를 하는 실습을 한다. 

러닝스푼즈 수업 정리 

< 이전 글 > 

https://silvercoding.tistory.com/60?category=965020 

이번 포스팅에서는 이전 글에서 생성한 파일과 folium 라이브러리를 이용하여 서울시 따릉이 지도를 생성한다. 

<folium 라이브러리 관련 포스팅> 

https://silvercoding.tistory.com/53?category=965020 

데이터셋 불러오기 

import pandas as pd

data = pd.read_excel('./data/bicycle.xlsx')

data.head()

서울시 따릉이 지도 시각화 

import folium

- 지도 생성 

m = folium.Map(location = ['37.5536067','126.9674308'], zoom_start = 13)   # 서울역 중심
m

서울역의 위도, 경도를 이용하여 지도를 생성한다. zoom_start 인자를 이용하여 확대 정도를 설정할 수 있다. 

- 지도에 표시할 데이터 확인 

for i in range(len(data)):
    name = data.loc[i, 'stationName']
    available = data.loc[i, 'parkingBikeTotCnt']
    total = data.loc[i, 'rackTotCnt']
    lat = data.loc[i, 'stationLatitude']
    long = data.loc[i, 'stationLongitude']
    print(name, available, total, lat, long)

지도생성에 필요한 컬럼의 데이터만 추출하여 출력한 것이다.  이를 이용하여 다음과 같이 마커를 추가하여 지도를 생성한다. 

# 지도 생성하기
m = folium.Map(location = ['37.5536067','126.9674308'], zoom_start = 13)

# 마커 추가하기
for i in range(len(data)):
    lat = data.loc[i, 'stationLatitude']
    long = data.loc[i, 'stationLongitude']
    name = data.loc[i, 'stationName']
    available = int(data.loc[i, 'parkingBikeTotCnt'])
    total = int(data.loc[i, 'rackTotCnt'])
    
    # 자전거 수량에 대해 색상으로 표시
    ##  자전거 보유율이 50% 초과일 경우 --> 파란색
    ##  현재 자전거가 2대 보다 적을 경우 --> 빨간색
    ##  그 외의 경우(자전거 2대 이상 이면서, 자전거 보유율 50% 미만) --> 초록색
    if available/total > 0.5:
        color = 'blue'
    elif available < 2 :
        color = 'red'
    else:
        color = 'green'
    icon=folium.Icon(color=color, icon='info-sign')
    folium.Marker(location = [lat, long],
                 tooltip = f"{name} : {available}", 
                  icon = icon
             ).add_to(m)
m

현재 자전거 이용 현황을 더 직관적으로 보기 위해 색깔 설정을 해준다. 파란색은 대여 가능 자전거 50% 이상, 빨간색은 2개 미만일 때, 초록색은 그 이외의 중간 상태를 나타낸다. 또한, tooltip을 사용하여 마우스를 갖다대면 자전거 대여소 이름과 이용가능한 자전거 수를 보여준다. 

문제점 : 데이터가 너무 많아 지도를 보는 데 어려움이 있다. 

해결방안 : 클러스터를 사용하여 근접한 마커들끼리 서로 묶어준다. 

클러스터 & 미니맵 추가하여 지도 시각화 

from folium.plugins import MiniMap, MarkerCluster

# 지도 생성하기
m_ver2 = folium.Map(location = ['37.5536067','126.9674308'], zoom_start = 13)

# 미니맵 추가하기
minimap = MiniMap() 
m_ver2.add_child(minimap)

# 마커 클러스터 만들기
marker_cluster_ver2 = MarkerCluster().add_to(m_ver2)  # 클러스터 추가하기

# 마커 추가하기
for i in range(len(data)):
    lat = data.loc[i, 'stationLatitude']
    long = data.loc[i, 'stationLongitude']
    name = data.loc[i, 'stationName']
    available = int(data.loc[i, 'parkingBikeTotCnt'])
    total = int(data.loc[i, 'rackTotCnt'])
    
    # 자전거 수량에 대해 색상으로 표시
    ##  자전거 보유율이 50% 초과일 경우 --> 파란색
    ##  현재 자전거가 2대 보다 적을 경우 --> 빨간색
    ##  그 외의 경우(자전거 2대 이상 이면서, 자전거 보유율 50% 미만) --> 초록색
    if available/total > 0.5:
        color = 'blue'
    elif available < 2 :
        color = 'red'
    else:
        color = 'green'
    icon=folium.Icon(color=color, icon='info-sign')
#     print(name, available, total, lat, long)
    folium.Marker(location = [lat, long],
                 tooltip = f"{name} : {available}", 
                  icon = icon
             ).add_to(marker_cluster_ver2)
m_ver2

클러스터와 미니맵을 추가한 지도이다. 숫자를 클릭하면 해당 지역으로 확대되어 더 편리하고 직관적인 지도를 볼 수 있다. 

m_ver2.save('./map/bicycle_clustermap.html')

지도는 html로 저장하여 언제든 꺼내볼 수 있다.