🤍

러닝스푼즈 수업 정리 

< 이전 글 > 

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로 저장하여 언제든 꺼내볼 수 있다. 

러닝스푼즈 수업 정리 

< 이전 글 > 

https://silvercoding.tistory.com/59

 API 신청하기 

1. 회원가입, 로그인 하기 

http://data.seoul.go.kr

2. 원하는 데이터의 인증키 신청 클릭 

본 포스팅에서는 서울 열린데이터 광장의 공공자전거 실시간 대여정보 API 를 사용한다.

다음의 링크에서 API를 신청할 수 있다. 

http://data.seoul.go.kr/dataList/OA-15493/A/1/datasetView.do

인증키 신청을 클릭한다. 

3. 가입 신청서 작성 

활용할 목적에 맞게 신청서를 작성해 준다. 현재 데이터분석 학습에 사용할 것이기 때문에 사용 url이 없다. 이 처럼 사용url이 없을 경우에는 localhost를 작성해준다. 

4. 상단 [나의화면 - 인증키 관리] 

나의화면 - 인증키 관리에 들어간다. 

5. 인증키 복사 

인증키 복사를 한다. 이제 API신청이 완료되었고, 데이터를 불러와보자. 

 데이터셋 불러오기 

1. 라이브러리 import

import requests  # API를 이용해 자료를 받아오기 위해
import pandas as pd   # 자료 저장, 다루기 위해

2. 서울특별시 공공자전거 실시간 대여정보 데이터 살펴보기 

- 호출

한번에 최대 1000건을 호출할 수 없으므로 2번에 걸쳐 호출한 후, 데이터를 합치는 작업을 해야한다. 

- 예시

위의 샘플 URL을 사용하여 API를 호출할 수 있다. (인증키) 부터 값의 의미는 다음과 같다. 

인증키, 요청파일 타입, 서비스명, 요청시작위치, 요청종료위치를 의미한다. 요청시작위치와 요청종료위치를 조절하여 데이터를 호출하면 된다. 

- 출력값 

데이터프레임의 컬럼이 될 변수들이다. 거치대개수, 대여소이름, 자전거주차총건수, 거치율, 위도, 경도, 대여소ID 로 총 7개로 구성되어 있다. 

3. 데이터 불러오기 

- 인증키 입력 

apikey = ' '  # 받은 key 값 입력

본인의 api 값을 넣어준다. 

- API 요청하기 

startnum = 1
endnum = 1000
url1 = f'http://openapi.seoul.go.kr:8088/{apikey}/json/bikeList/{startnum}/{endnum}/'

requests.get(url1)
# requests.get(url1).text
# requests.get(url1).content

requests.get() 을 사용하면 응답이 온다. 이 외에도 text, content로 안의 내용을 실행해볼 수도 있다. 

- 자료 요청 

json1 = requests.get(url1).json()

json1

이렇게 json 형태로 된 데이터가 1000개 나오게 된다. 

- 필요한 정보(키) 선택 

json1['rentBikeStatus'].keys()

현재 데이터 분석을 위해 필요한 정보는 rentBikeStatus 안에 있는 row 키의 데이터이지만,  모든 키를 꺼내본다.

json1['rentBikeStatus']['list_total_count']  # 데이터의 개수

json1['rentBikeStatus']['RESULT']  # 오류 여부

json1['rentBikeStatus']['row']  # 자전거 정류장별 자전거 현황

- 데이터프레임으로 변경

raw1 = pd.DataFrame(json1['rentBikeStatus']['row'])
raw1.head()

- 1000 ~ 2000 & 2000 ~ 3000 데이터 가져오고 합병하기 

startnum = 1001
endnum = 2000
url2 = f'http://openapi.seoul.go.kr:8088/{apikey}/json/bikeList/{startnum}/{endnum}/'
json2 = requests.get(url2).json()

raw2 = pd.DataFrame(json2['rentBikeStatus']['row'])
raw2.tail()

data_mid = raw1.append(raw2)
data_mid

데이터가 2000개를 더 넘어가는 것 같으니 2000 ~ 3000 데이터도 호출한 후 추가해준다. 

startnum = 2001
endnum = 3000
url3 = f'http://openapi.seoul.go.kr:8088/{apikey}/json/bikeList/{startnum}/{endnum}/'
json3 = requests.get(url3).json()

raw3 = pd.DataFrame(json3['rentBikeStatus']['row'])
raw3.tail()

data = data_mid.append(raw3)
data

모든 데이터를 추가하였다. 총 2540개의 데이터를 가지고 있다. 그런데 인덱스가 조금 이상해서 인덱스를 초기화 해준 후, 데이터를 엑셀 파일로 저장해준다. 

- 최종 데이터 

data.reset_index(drop=True)

data.info()

총 2450개의 row가 존재하고, null 값이 없는 것을 볼 수 있다. 

- 엑셀파일로 저장 

data.to_excel('./data/bicycle.xlsx', index = False)

엑셀파일로 저장해준다. 다음시간에는 이러한 과정으로 불러온 자전거 데이터셋을 folium 라이브러리를 이용하여 서울시 따릉이 현황 지도를 생성해 볼 것이다. 

러닝스푼즈 수업 정리 

< 이전 글 > 

https://silvercoding.tistory.com/58

 데이터 불러오기 & 살펴보기 

import pandas as pd

raw = pd.read_excel('./data/subway_raw.xlsx')

2-1 포스팅에서 합병해 놓은 2019년 1월 - 6월 지하철 데이터를 불러온다. 

raw.info()

총 99342 개의 row가 존재하고 , null 값이 없는 것을 확인하였다. 

 어느 역에서 , 언제 지하철을 가장 많이 탈까 ? 

1. 승객이 가장 많이 타는 역

data_station = raw.pivot_table(index = '역명', values = '승차총승객수', aggfunc='sum')
data_station = data_station.sort_values(by = '승차총승객수', ascending = False)
data_station.head(10)  # 승차승객수가 가장 많은 역 상위 10개

역별로 승차총승객수를 내림차순 정렬한 피벗테이블이다. 상위 10개 역을 출력하였고 , 2019년 상반기 가장 많은 승객수가 있었던 역은 잠실역임을 알 수 있다. 

2. 시각화 : 노선 별 (1-9호선) 역별/요일별 승객수 비교해 보기

* 히트맵 

• sns.heatmap(data, annot = True, fmt = '.0f', cmap = "RdBu_r")
  • annot : True 일경우 값을 그래프에 표시
  • fmt : 값 표시 형태.
    • ex) 'f' : 실수로 표현(default 로 값이 있는 소수 자리까지 표시됨)
    • ex) '.0f' : 실수로 표현해달라 (소수 0번째 자리까지만 == 정수자리만 )
    • ex) '.1f' : 실수로 표현해달라 (소수 1번째 자리까지만)
    • ex) .1% 는 퍼센트(소수 첫번째 자리까지 표시)
  • cmap : 색상 차트. _r 으로 끝나는 차트는 색상 방향 반대로 되어있는 버전임(아래 컬러 리스트 참고)

* cmap 종류

Accent, Accent_r, Blues, Blues_r, BrBG, BrBG_r, BuGn, BuGn_r, BuPu, BuPu_r, CMRmap, CMRmap_r, Dark2, Dark2_r, GnBu, GnBu_r, Greens, Greens_r, Greys, Greys_r, OrRd, OrRd_r, Oranges, Oranges_r, PRGn, PRGn_r, Paired, Paired_r, Pastel1, Pastel1_r, Pastel2, Pastel2_r, PiYG, PiYG_r, PuBu, PuBuGn, PuBuGn_r, PuBu_r, PuOr, PuOr_r, PuRd, PuRd_r, Purples, Purples_r, RdBu, RdBu_r, RdGy, RdGy_r, RdPu, RdPu_r, RdYlBu, RdYlBu_r, RdYlGn, RdYlGn_r, Reds, Reds_r, Set1, Set1_r, Set2, Set2_r, Set3, Set3_r, Spectral, Spectral_r, Wistia, Wistia_r, YlGn, YlGnBu, YlGnBu_r, YlGn_r, YlOrBr, YlOrBr_r, YlOrRd, YlOrRd_r, afmhot, afmhot_r, autumn, autumn_r, binary, binary_r, bone, bone_r, brg, brg_r, bwr, bwr_r, cividis, cividis_r, cool, cool_r, coolwarm, coolwarm_r, copper, copper_r, cubehelix, cubehelix_r, flag, flag_r, gist_earth, gist_earth_r, gist_gray, gist_gray_r, gist_heat, gist_heat_r, gist_ncar, gist_ncar_r, gist_rainbow, gist_rainbow_r, gist_stern, gist_stern_r, gist_yarg, gist_yarg_r, gnuplot, gnuplot2, gnuplot2_r, gnuplot_r, gray, gray_r, hot, hot_r, hsv, hsv_r, icefire, icefire_r, inferno, inferno_r, jet, jet_r, magma, magma_r, mako, mako_r, nipy_spectral, nipy_spectral_r, ocean, ocean_r, pink, pink_r, plasma, plasma_r, prism, prism_r, rainbow, rainbow_r, rocket, rocket_r, seismic, seismic_r, spring, spring_r, summer, summer_r, tab10, tab10_r, tab20, tab20_r, tab20b, tab20b_r, tab20c, tab20c_r, terrain, terrain_r, twilight, twilight_r, twilight_shifted, twilight_shifted_r, viridis, viridis_r, vlag, vlag_r, winter, winter_r

- 1호선만 시각화 해보기 

line = '1호선'
data_line = raw[raw['노선명'] == line]

# 피벗테이블: 노선의 역 순서에 맞춰 정리하기 위해 역ID도 인덱스에 포함
df_pivot = data_line.pivot_table(index = ['역ID', '역명'], columns = '요일', values = '승차총승객수',aggfunc = 'sum') 
df_pivot = df_pivot[['월','화','수','목','금','토','일']]   # 컬럼 순서를 요일에 맞게 정리
df_pivot = df_pivot / 10000  # 만명단위로 표현하기 위해 데이터프레임 전체를 1만으로 나누기
df_pivot

역별 요일별 승차총객수를 집계한 피벗테이블이다. 요일이 뒤죽박죽 나오기 때문에 다시 선택하여 순서대로 정리해 준다. 

import matplotlib.pyplot as plt
import seaborn as sns 
from matplotlib import font_manager, rc
import platform 

# 한글 폰트 사용
if platform.system() == 'Windows': 
    path = 'c:/Windows/Fonts/malgun.ttf'
    font_name = font_manager.FontProperties(fname=path).get_name()
    rc('font', family=font_name)
elif platform.system() == 'Darwin':
    rc('font', family='AppleGothic')

fig, ax = plt.subplots( figsize=(6,5) )   # 그래프 사이즈 지정
plt.title(f"{line} 역별/요일별 승객수", fontsize = 20) # for title
sns.heatmap(df_pivot, cmap = "Reds", 
           annot = True, fmt = '.0f')

1호선의 역별 요일별 승객수 히트맵니다. 서울역과 종각역의 승객수가 가장 많아보이고, 그중에서도 서울역의 금요일에 승객수가 가장 많은 것을 볼 수 있다. 

동일한 방법으로 모든 노선을 시각화하여 비교 해 보자. 

- 1호선~9호선 시각화 하여 비교 해보기 

raw['노선명'].unique()

이렇게 많은 노선이 있는데 , 본 포스팅에서는 1호선 ~ 9호선 만을 시각화 한다. 

line_seoul_list = [ ]
for line in raw['노선명'].unique():
    if line[1:] == '호선':    # x호선 인 경우를 선택. 
        line_seoul_list.append(line)
line_seoul_list

for line in sorted(line_seoul_list):
    
    # 데이터 정리하기
    data_line = raw[raw['노선명'] == line]
    df_pivot = data_line.pivot_table(index = ['역ID', '역명'], columns = '요일', values = '승차총승객수',aggfunc = 'sum')
    df_pivot = df_pivot[['월','화','수','목','금','토','일']]
    df_pivot = df_pivot / 10000  # 만명단위로 수정
    
    
    # 그래프 그리기
    fig, ax = plt.subplots( figsize=(6,len(df_pivot)/3 ) )   # 그래프 사이즈를 조정하여, 역 수가 많은 경우는 세로를 길게 표현
    plt.title(f"{line} 역별/요일별 승객수", fontsize = 20) # for title
    sns.heatmap(df_pivot, cmap = "Reds", 
               annot = True, fmt = '.0f')

진한 빨간색일 수록 승객수가 많은 것을 의미한다. 승객수가 많은 역은 모든 요일이 대체적으로 색이 진한 것을 확인할 수 있다. 이전 포스팅에서 전체적으로 금요일에 승객수가 가장 많고 , 주말이 되면 승객수가 떨어지는 경향이 있었는데 , 역 별로 보니 주말이 더 많은 역도 발견할 수 있었다. (  ex, 이태원, 고속터미널, 홍대입구 )  

러닝스푼즈 수업 정리 

< 이전 글 > 

https://silvercoding.tistory.com/57

 데이터 불러오기 & 살펴보기 

import pandas as pd

raw = pd.read_excel('./data/subway_raw.xlsx')
raw.head()

이전 글에서 병합했던 파일을 불러와 준다. 

raw.info()

총 99342개의 row가 존재하고 ,  null값이 없는 것을 알 수 있다. 

 승객이 많아지는 날은 언제인가 ? 

- 일자 , 요일 별 승차총승객수 확인 해 보기 

data_date = pd.pivot_table(raw, index = ['사용일자', '요일'], values= '승차총승객수', aggfunc= 'sum')
data_date.head()

- 일자 , 요일 별 승차총승객 수 내림차순 정렬 

data_date_sort = data_date.sort_values(by = '승차총승객수', ascending= False)
data_date_sort

일자, 요일 별 승차승객수를 내림차순으로 정렬 해 보았다. 이 결과에 대한 데이터프레임을 확인해 보면 두가지 가정을 세울 수 있다. 

1. 5월에 지하철 승객수가 가장 많다. 

2. 금요일에 지하철 승객수가 가장 많다. 

(1) 5월에 지하철 승객수가 가장 많다 

- '연월' 컬럼 , '월일' 컬럼 추가 

yearmonth_list = []
monthday_list = []
for date in raw['사용일자']:
    yearmonth = str(date)[:6]   # 왼쪽부터 6자리 문자 선택
    yearmonth_list.append(yearmonth)
    monthday = str(date)[4:]    # 왼쪽에서 5번째 문자부터 끝까지 선택
    monthday_list.append(monthday)
    
# 연월/ 월일 컬럼 추가하기
raw['연월'] = yearmonth_list
raw['월일'] = monthday_list
raw.head()

월 별 승객수를 보기 위해 사용일자를 연월, 월일로 나누어 새로운 컬럼을 추가하였다. 

data_month = pd.pivot_table(raw, index = '연월', values = '승차총승객수', aggfunc='sum')
data_month = data_month.sort_values(by = '승차총승객수', ascending= False)
data_month

월별 승차총객수 피벗데이블을 생성하고 , 승차종승객수를 기준으로 내림차순 정렬을 해보니 , 5월에 가장 승객수가 많은 것을 확인할 수 있다. 

결론 -> 5월에 지하철 승객수가 가장 많다 : True

(2) 금요일에 지하철 승객수가 가장 많다 

data_week = pd.pivot_table(raw, index = '요일', values = '승차총승객수', aggfunc='sum')
data_week = data_week.sort_values(by = '승차총승객수', ascending= False)
data_week

요일별 승차총객수 피벗테이블을 생성하고 , 승차총승객수를 기준으로 내림차순 정렬을 해보니 금요일에 승객수가 가장 많은 것을 확인할 수 있다. 

결론 -> 금요일에 지하철 승객수가 가장 많다 : True

* 월별 / 일자별 승객수 그래프 시각화 

- 2019년 1월 데이터로 테스트 해보기 

df_selected = raw[ raw['연월'] == '201901']
df_selected.head()

df_pivot = pd.pivot_table(df_selected, index = ['월일','요일'], values = '승차총승객수', aggfunc= 'sum')
df_pivot = df_pivot.reset_index()
df_pivot

2019년 1월 날짜별 승차총승객수를 집계하는 피벗테이블을 생성한다. 이를 pointplot을 사용하여 시각화 해보자. 

import matplotlib.pyplot as plt
import seaborn as sns 
from matplotlib import font_manager, rc
import platform 

# 한글 폰트 사용
if platform.system() == 'Windows': 
    path = 'c:/Windows/Fonts/malgun.ttf'
    font_name = font_manager.FontProperties(fname=path).get_name()
    rc('font', family=font_name)
elif platform.system() == 'Darwin':
    rc('font', family='AppleGothic')

fig, ax = plt.subplots( figsize=(20,6) )
# 그래프 그리기
sns.pointplot(data = df_pivot, x = '월일', y = '승차총승객수')

fig, ax = plt.subplots( figsize=(20,6) )
# 그래프 그리기
sns.pointplot(data = df_pivot, x = '요일', y = '승차총승객수')

1월 그래프만 그려보았더니 , 금요일에 가장 많은 승객수를 찍고, 그 이후로 줄어들어 일요일에는 승객수가 대폭 줄어드는 경향을 보인다. 매 달마다 편차가 있는지 확인하기 위해 1-6월의 날짜별 승객수 시각화를 해본다. 

- 상반기 날짜별 승객수 시각화 

raw['연월'].unique()

for yearmonth in raw['연월'].unique():
    df_selected = raw[ raw['연월'] == yearmonth]  # 해당 연월 데이터 선택하기
    df_pivot = pd.pivot_table(df_selected, index = ['월일','요일'], values = '승차총승객수', aggfunc= 'sum')# 일자별 승객수 계
    df_pivot = df_pivot.reset_index()
    
    fig, ax = plt.subplots( figsize=(20,6) )
    
    ax.set_title(f'일자별 지하철승객수({yearmonth})')  # 그래프 제목 추가하기
    sns.pointplot(data = df_pivot, x = '월일', y = '승차총승객수')

해석 :  전체적으로 형태가 비슷한 것을 볼 수 있다. 금요일 이후 주말에는 승객수가 떨어지고 , 일요일에 대폭 하락하는 경향을 보인다. 2월달을 보면 설연휴로 인해서 2월 초 주중에도 승객수의 수가 낮으며 , 6월 6일 현충일에도 승객수가 떨어지는 현상 또한 확인할 수 있다. 이를 통해 지하철 승객수는 공휴일의 영향을 받는다고 해석할 수 있다.