[혼공머신] 06. 비지도 학습 - 군집, 주성분 분석

고객 올린 사진을 어떤 과일인지 분류

---

타깃을 모르는 비지도 학습

타깃을 모르는 사진을 종류별로 분류

비지도 학습 : 타깃이 없을 때 사용하는 알고리즘 

                       사람이 가르쳐 주지 않아도 데이터에 있는 무언가를 학습

 

06-1.  군집 알고리즘

과일 사진 데이터 준비

이미지 데이터 넘파이 배열의 기본 저장 포맷인 npy 파일로 저장되어 있음

코랩에서 ! 문자로 시작하면 이후 명령을 파이썬 코드가 아니라 리눅스 셸 명령어로 인식

wget 원격 주소에서 데이터를 다운로드하여 저장

!wget https://bit.ly/fruits_300 -O fruits_300.npy

 

파일로드

넘파이에서 npy 파일을 로드 방법 : .load() 메서드에 파일 이름 전달

import numpy as np
import matplotlib.pyplot as plt

fruits = np.load('fruits_300.npy')

 

크기 확인

print(fruits.shape)

(300, 100, 100)

-> (샘플 개수, 이미지 높이, 이미지 너비)

이미지 크기는 100 x 100

 

첫 번째 이미지 첫 행 출력

3차원 배열이기 때문에 처음 2개의 인덱스를 0으로 지정

마지막 인덱스 지정하지 않거나 슬라이싱 연산자 -> 첫 번째 이미지의 첫 번째 행 출력

print(fruits[0,0,:])

첫 번째 행에 있는 픽셀 100개에 들어 있는 값 출력

이 넘파이 배열 흑백 사진 담고 있음 -> 0~ 255 정숫값 가짐

 

 

이미지 그리기

맷플롯립의 imshow() 넘파이 배열로 저장된 이미지 그리기

흑백이미지 -> cmap 매개변수 'gray'

plt.imshow(fruits[0], cmap='gray')
plt.show()

0에 가까울 수록 검게 나타나고 높은 값은 밝게 표시

이 흑백 이미지는 사진으로 찍은 이미지를 넘파이 배열로 변환할 때 반전시킨 것

사진의 흰 바탕(높은 값)은 검은색(낮은 값)으로 만들고 

실제 사과가 있어 짙은 부분은(낮은 값)은 밝은 색(높은 값)으로 바꿈

 

관심 대상이 바탕이 아닌 사과

픽셀값이 0이면 출력도 0이 되어 의미가 없음

픽셀값이 높으면 출력값도 커지기 때문에 의미 부여하기 좋음

관심 대상의 역역을 높은 값으로 바꾸었지만 맷플롯립으로 출력할 때 바탕이 검게 나옴

 

gray_r 다시 반전

cmap 매개변수를 'gray_r'로 지정하면 다시 반전하여 우리 눈에 보기 좋게 출력

plt.imshow(fruits[0],cmap='gray_r')
plt.show()

이 그림에서 밝은 부분이 0에 가깝고 짙은 부분이 255에 가까운 값!

 

파인애플, 바나나 이미지 출력

* subplots() : 여러 개의 그래프를 배열처럼 쌓을 수 있도록 도와줌

                      두 매개변수는 그래프를 쌓을 행과 열 지정

* axs : 서브 그래프를 담고 있는 배열

fig, axs = plt.subplots(1,2)
axs[0].imshow(fruits[100], cmap='gray_r')
axs[1].imshow(fruits[200], cmap='gray_r')
plt.show()

처음 100개 사과, 그 다음 100개 파인애플, 마지막 100개 바나나

 

 

픽셀값 분석하기

넘파이 배열을 나눌 때 100 x 100 이미지를 펼쳐서 길이가 10,000인 1차원 배열로 변경

-> 이미지를 출력하긴 어렵지만 배열을 계산할 때 편리

 

1차원 배열로 변경

* .reshape : 차원 합침 / 첫번째 차원 -1로 지정시 자동으로 남은 차원 할당

apple = fruits[0:100].reshape(-1, 100*100)
pineapple = fruits[100:200].reshape(-1, 100*100)
banana = fruits[200:300].reshape(-1, 100*100)

이제 배열 크기는 (100, 10000)으로 바뀜

 

 

샘플의 픽셀 평균값

* .mean() : 평균값

샘플마다 픽셀의 평균값 계산 -> 평균 계산할 축 지정

* axis = 0  첫번째 축인 행을 따라 / axis = 1 두번째 축인 열을 따라 계산

우리가 필요한 것의 샘플의 평균

샘플을 모두 가로로 값을 나열했으니, axis = 1로 지정하여 평균 계산

print(apple.mean(axis=1))

사과 샘플 100개에 대한 픽셀 평균값

 

 

히스토그램 그려 평균값 분포 확인

* hist() : 히스토그램 그리기

* alpha : 1보다 작게하면 투명도

* legend() : 히스토그램 범례

plt.hist(np.mean(apple, axis=1), alpha=0.8)
plt.hist(np.mean(pineapple, axis=1), alpha=0.8)
plt.hist(np.mean(banana, axis=1), alpha=0.8)
plt.legend(['apple', 'pineapple', 'banana'])
plt.show()

 

 

 

픽셀별 평균값 비교

샘플의 평균값이 아니라 픽셀별 평균값 비교

=> 전체 샘플에 대해 각 픽셀의 평균 계산

* bar() : 막대그래프

픽셀의 평균이므로 axis = 0

fig, axs = plt.subplots(1, 3, figsize=(20,5))
axs[0].bar(range(10000), np.mean(apple, axis=0))
axs[1].bar(range(10000), np.mean(pineapple, axis=0))
axs[2].bar(range(10000), np.mean(banana, axis=0))
plt.show()

과일마다 값이 높은 구간이 다름

 

픽셀 평균값 이미지 출력

픽셀 평균값을 100 x 100 크기로 바꿔서 이미처럼 출력하여 위 그래프와 비교

apple_mean = np.mean(apple, axis=0).reshape(100, 100)
pineapple_mean = np.mean(pineapple, axis=0).reshape(100, 100)
banana_mean = np.mean(banana, axis=0).reshape(100, 100)
fig, axs = plt.subplots(1, 3, figsize=(20, 5))
axs[0].imshow(apple_mean, cmap='gray_r')
axs[1].imshow(pineapple_mean, cmap='gray_r')
axs[2].imshow(banana_mean, cmap='gray_r')
plt.show()

 

픽셀 위치에 따라 값의 크기 차이남

 

 

평균값과 가까운 사진 고르기

사과 사진의 평균값인 apple_man과 가장 가까운 사진 고르기

=> 절대값 오차 : fruits 배열에 있는 모든 샘플에서 apple_mean 뺸 절대값의 평균 계산

*  abs() : 절댓값 계산 / 배열을 입력하면 모든 원소의 절댓값을 계산하여 입력과 동일한 크기의 배열 반환

abs_diff =np.abs(fruits - apple_mean)
abs_mean = np.mean(abs_diff, axis=(1,2))
print(abs_mean.shape)

 

오차 작은 순서대로 골라 그래프

* np.argsort() : 작은 것에서 큰 순서대로 나열

처음 100개를 선택해 10 x 10 격자로 이루어진 그래프 그리기

 

subplots() 함수로 10 x 10, 총 100개의 서브 그래프 만듦

그래프가 많기 때문에 전체 그래프의 크기 figsize=(10,10) 지정 (기본값 (8,6))

for 반복문 순회하며 10개의 행과 열에 이미지 출력

axis('off') 좌표축 그리지 않음

apple_index = np.argsort(abs_mean)[:100]
fig, axs = plt.subplots(10, 10, figsize=(10,10))
for i in range(10):
  for j in range(10):
    axs[i, j].imshow(fruits[apple_index[i*10 + j]], cmap='gray_r')
    axs[i, j].axis('off')
plt.show()

흑백 사진에 있는 픽셀값을 사용해 과일 사진 모으는 작업 완료

 

군집 : 비슷한 샘플끼리 그룹으로 모으는 작업

클러스터 : 군집 알고리즘에서 만든 그룹

 

---

06-2.  K-평균

진짜 비지도 학습에서는 사진에 어떤 과일 들어있는지 알지 못 함

=>  K-평균 군집 알고리즘이 평균값을 자동으로 찾아줌

이 평균값이 클러스터의 중심에 위치하기 때문에 클러스터 중심 또는 센트로이드라 부름

 

K-평균 알고리즘 작동방식

1. 무작위로 k개의 클러스터 중심을 정함

2. 각 샘플에서 가장 가까운 클러스터 중심을 찾아 해당 클러스터의 샘플로 지정

3. 클러스터에 속한 샘플의 평균값으로 클러스터 중심 변경

4. 클러스터 중심에 변화가 없을 때까지 2번으로 돌아가 반복

 

K-평균 알고리즘은 처음에는 랜덤하게 클러스터 중심을 선택하고 점차 가장 가까운 샘플의 중심으로 이동하는 알고리즘

 

KMeans 클래스

!wget https://bit.ly/fruits_300 -O fruits_300.npy

 

배열 준비

k-평균 모델을 훈련하기 위해 (샘플 개수, 너비, 높이) 크기의 3차원 배열을

(샘플 개수, 너비 x 높이) 크기를 가진 2차원 배열로 변경

import numpy as np
fruits = np.load('fruits_300.npy')
fruits_2d = fruits.reshape(-1, 100*100)

 

KMeans

k-평균 알고리즘은 sklearn.cluster 모듈 아래 KMeans 클래스

* n_clusters : 클러스터 개수 지정

비지도 학습이므로 fit() 메서드에서 타깃 데이터 사용 x

from sklearn.cluster import KMeans
km = KMeans(n_clusters=3, random_state=42)
km.fit(fruits_2d)

 

labels_

군집된 결과는 KMeans 클래스 객체의 labels_ 속성에 저장

labels_ 배열의 길이는 샘플 개수와 같음

n_clusters=3으로 지정했기 때문에 labels_ 배열의 값은 0,1,2 중 하나

print(km.labels_)

레이블값 0,1,2와 레이블 순서에는 어떤 의미도 없음

 

레이블 0,1,2로 모은 샘플의 개수 확인

print(np.unique(km.labels_, return_counts=True))

(array([0, 1, 2], dtype=int32), array([111, 98, 91]))

 

첫 번째 클러스터(레이블 0)이 91개 샘플

두 번째 클러스터(레이블 1)가 98개 샘플

세 번째 클러스터(레이블 2)가 111개 샘플 모음

 

각 클러스터 이미지 출력

각 클러스터가 어떤 이미지를 나타냈는지 출력하기 위해 유틸리티 함수 만들기

draw_fruits() 함수는 (샘플 개수, 너비, 높이)의 3차원 배열을 입력받아 가로로 10개씩 이미지를 출력fisize는 ratio 매개변수에 비례하여 커짐 (ratio 기본값 1)

 

import matplotlib.pyplot as plt
def draw_fruits(arr, ratio=1):
  n = len(arr)         # n은 샘플 개수
  
  # 한 줄에 10개씩 이미지를 그린다. 
  # 샘플 개수를 10으로 나누어 전체 행 개수를 계산한다.
  rows = int(np.ceil(n/10))

  # 행이 1개면 열의 개수는 샘플 개수이다. 그렇지 않으면 10개이다.
  cols = n if rows < 2 else 10
  fig, axs = plt.subplots(rows, cols, figsize=(cols*ratio,rows*ratio),
                          squeeze=False)
  for i in range(rows):
    for j in range(cols):
      if i*10 + j < n:  # n 개까지만 그린다.
        axs[i, j].imshow(arr[i*10 + j], cmap='gray_r')
      axs[i, j].axis('off')
  plt.show()

 

불리언 인덱싱

km.labels_==0 -> km.labels_ 배열에서 값이 0인 위치는 True, 그 외 모드 False

불리언 인덱싱 : 불리언 배열을 사용해 원소 선택

draw_fruits(fruits[km.labels_==0])

레이블 0으로 클러스터링된 91개 이미지 모두 출력

 

draw_fruits(fruits[km.labels_==1])

 

draw_fruits(fruits[km.labels_==2])

레이블 1인 클러스터는 바나나만

레이블 2인 클러스터는 파인애플에 사과 9개 바나나 2개가 섞였음

 

 

클러스터 중심

* cluster_centers_ : KMeans 클래스가 최종적으로 찾은 클러스터 중심 저장

이 배열은 fruits_2d 샘플의 클러스터 중심이기 때문에 이미지로 출력하려면 100 x 100 크기의 2차원으로 변경

draw_fruits(km.cluster_centers_.reshape(-1,100,100), ratio=3)

 

* transform() : 훈련 데이터 샘플에서 클러스터 중심까지 거리 변환

                        StandardScaler 클래스처럼 특성값을 변환하는 도구로 사용할 수 있다는 의미

 

.fruits_2d[100]처럼 쓰면 (10000,) 크기의 배열이 되므로 에러

슬라이싱 연산자 사용해서 (1, 10000) 크기의 배열 전달

print(km.transform(fruits_2d[100:101]))

[[5267.70439881 8837.37750892 3393.8136117 ]]

하나의 샘플을 전달했기 떄문에 반환된 배열은 크기가 (1, 클러스터 개수) 인 2차원 배열

 

예측

* predict() : 가장 가까운 클러스터 중심을 예측 클래스로 출력

print(km.predict(fruits_2d[100:101]))

[2]

-> 레이블 2로 예측 -> 파인애플

 

draw_fruits(fruits[100:101])

* n_iter_ : 알고리즘이 반복한 횟수 저장

print(km.n_iter_)

3

 

 

최적의 k 찾기

 k-평균 알고리즘 클러스터 개수 사전에 지정해야 함

실전에는 몇 개의 클러스터가 있는지 알 수 없음 ... 적절한 k 값 ?

 

k-평균 알고리즘은  클러스터 중심과 클러스터에 속한 샘플 사이의 거리를 잴 수 있다

이니셔 : 거리의 제곱 합 -> 클러스터에 속한 샘플이 얼마나 가깝게 모여 있는지를 나타내는 값

 

엘보우 : 클러스터 개수를 늘려가면서 이니셔의 변화를 관찰하여 최적의 클러스터 개수를 찾는 방법

 

클러스터 개수를 증사기키면서 이니셔를 그래프로 그리면 감소하는 속도가 꺾이는 지점이 있다

이 지점부터는 클러스터 개수를 늘려도 클러스터에 잘 밀집된 정도가 크게 개선되지 않음

즉, 이니셔가 크게 줄어들지 않는다.  -> 이 지점이 팔꿈치 모양 같아서 엘보우 방법이라 부름

 

 

최적의 k 값  -  inertia

* inertia_ : 자동으로 이너셔 계산해서 제공

클러스터 개수 k를 2~6까지 바꿔가며 KMeans 클래스를 5번 훈련

fit() 메서드로 모델을 훈련한 후 inertia_ 속성에 저장된 이니셔 값을 inertia 리스트에 추가

inertia 리스트에 저장된 값을 그래프로 출력

inertia = []
for k in range(2, 7):
  km = KMeans(n_clusters=k, random_state=42)
  km.fit(fruits_2d)
  inertia.append(km.inertia_)
plt.plot(range(2, 7), inertia)
plt.xlabel('k')
plt.ylabel('inertia')
plt.show()

k = 3에서 그래프의 기울기가 조금 바뀜

 

 

---

 

06-3.  주성분 분석

군집이나 분류에 영향을 끼치지 않으면서 업로드된 사진의 용량 줄이기

 

차원과 차원 축소

데이터가 가진 속성을 '특성'이라고 부름

과일 사진의 경우 10000개의 픽셀이 있기 때문에 10000개의 특성이 있는 셈

머신러닝에서는 이른 특성을 '차원'이라고 부름

10000개 특성 = 10000개 차원  -> 차원을 줄이면 저장공간 절약!

 

차원축소 : 데이터를 가장 잘 나타내는 일부 특성을 선택하여 데이터 크기를 줄이고

                 지도 학습 모델의 성능을 향상시킬 수 있는 방법

 

줄어든 차원에서 다시 원본 차원으로 손실을 최대한 줄이면서 복원할 수도 있음

 

주성분 분석(PCA) : 대표적인 차원 축소 알고리즘

 

주성분 분석

주성분 분석(PCA)은 데이터에 있는 분산이 큰 방향을 찾는 것

분산 : 데이터가 널리 퍼져있는 정도

분산이 큰 방향이란 데이터를 잘 표현하는 어떤 벡터

 

주성분 벡터 : 원본 데이터에 있는 어떤 방향

                       주성분 벡터의 원소 개수는 원본 데이터셋에 있는 특성 개수와 같음

 

주성분은 원본 차원과 같고, 주성분으로 바꾼 데이터는 차원이 줄어듬!!

 

첫 번째 주성분을 찾은 다음 이 벡터에 수직이고 분산이 가장 큰 다음 방향을 찾음

이 벡터가 두 번째 주성분

주성분은 원본 특성의 개수만큼 찾을 수 있음

 

PCA 클래스

!wget https://bit.ly/fruits_300 -O fruits_300.npy
import numpy as np
fruits = np.load('fruits_300.npy')
fruits_2d = fruits.reshape(-1, 100*100)

 

사이킷런 skearn.decomposition 모듈 아래 pca클래스로 주성분 분석 알고리즘 제공

pca 클래스 만들 때 n_components 지정해야 함

* n_components :  주성분의 개수 지정

비지도 학습이기 때문에 fit() 메서드에 타깃값 제공 x

from sklearn.decomposition import PCA
pca = PCA(n_components=50)
pca.fit(fruits_2d)

 

* components_ : PCA 클래스가 찾은 주성분 저장

print(pca.components_.shape)

(50, 10000)

n_components = 50으로 지정했기 때문에 pca.components_ 배열의 첫 번째 차원이 500

즉, 50개의 주성분을 찾음

두번째 차원은 항상 원본 데이터의 특성 개수와 같은 10000

 

draw_fruits() 주성분 그림 그리기

draw_fruits(pca.components_.reshape(-1, 100, 100))

주성분은 원본 데이터에서 가장 분산이 큰 방향을 순서대로 나타낸 것

데이터 셋에 있는 어떤 특징을 잡아낸 것처럼 생각

 

주성분을 찾았으므로 원본 데이터를 주성분에 투영하여 특성 개수를 10,000개에서 50개로 줄일 수 있음

 

주성분으로 차원 줄이기

* transform() : 차원 줄이기

fruits_pca = pca.transform(fruits_2d)
print(fruits_pca.shape)

(300, 50)

 

fruits_2d는 (300, 10000)  이었는데 50개의 주성분을 찾은 pca 모델 이용 (300, 50) 크기 배열로 변환

fruits_pca는 50개 특성을 가진 데이터

 

원본 데이터 재구성

10000개 특성을 50개로 줄임 -> 어느 정도 손실 발생

최대한 분산이 큰 방향으로 데이터를 투영했기 때문에, 원본 데이터를 상당 부분 재구성할 수 잇음

 

* inverse_transform() : 원본 데이터 복원

fruits_inverse = pca.inverse_transform(fruits_pca)
print(fruits_inverse.shape)

(300, 10000)

 

복원한 데이터 그림출력

fruits_reconstruct = fruits_inverse.reshape(-1, 100, 100)
for start in [0, 100, 200]:
  draw_fruits(fruits_reconstruct[start:start+100])
  print("\n")

50개의 특성이 분산을 가장 잘 보존하도록 변환된 것이기 떄문에

거의 다 잘 복원 됨

 

만약 주성분을 최대로 사용했다면 완벽하게 원본 데이터 재구성 가능

 

 

설명된 분산

설명된 분산 : 주성분이 원본 데이터의 분산을 얼마나 잘 나타내는지 기록한 값

* explained_variance_ratio_ : 주성분의 설명된 분산 비율

첫 번째 주성분의 설명된 분산이 가장 큼

분산 비율을 모두 더하면 50개의 주성분으로 표현하고 있는 총 분산 비율을 얻을 수 있음

print(np.sum(pca.explained_variance_ratio_))

0.9215206118088856

 

92% 넘는 분산 유지

 

 

설명된 분산 그래프

설명된 분산의 비율을 그래프로 그려 보면 적절한 주성분 개수 찾는 데 도움

* plot() : 그래프 그리기

plt.plot(pca.explained_variance_ratio_)
plt.show()

처음 10개의 주성분이 대부분의 분산을 표현하고 있음

그 다음부터는 각 주성분이 설명하고 있는 분산 비교적 작음

 

다른 알고리즘과 함께 사용

3개의 과일 사진을 분류 -> 로지스틱 회귀 모델 LogisticRegression 

from sklearn.linear_model import LogisticRegression
lr = LogisticRegression()

 

지도 학습 모델 사용하려면 타깃값 있어야 함

여기서 사과 0, 파인애플 1, 바나나 2로 지정

파이썬 리스트와 정수를 곱하면 리스트 안의 원소를 정수만큼 반복

target = np.array([0]*100 + [1]*100 + [2]*100)

 

로지스틱 회귀 모델에서 성능 가늠위해

* cross_validate() 교차검증

from sklearn.model_selection import cross_validate
scores = cross_validate(lr, fruits_2d, target)
print(np.mean(scores['test_score']))
print(np.mean(scores['fit_time']))

0.9966666666666667

0.9233800888061523

 

교차 검증 점수 0.997 정도로 매우 높음

특성 10000개나 되기 때문에 300개 샘플에서는 금방 과대적합된 모델 만들기 쉬움

 

* fit_time : 각 교차 검증 폴드의 훈련시간

0.94초 정도 걸림

 

축소한 값과 비교

scores = cross_validate(lr, fruits_pca, target)
print(np.mean(scores['test_score']))
print(np.mean(scores['fit_time']))

1.0

0.02978053092956543

 

50개의 특성만 사용했는데도 정확도 100%

훈련시간 0.03초로 감소함

 

PCA로 훈련 데이터의 차원을 축소하면 저장 공간뿐만 아니라 머신러닝 모델의 훈련 속도도 높일 수 있음

 

설명된 분산 비율 입력

* n_components : 주성분 개수 지정

                 대신 원하는 설명된 분산의 비율 입력 가능, PCA 클래스 지정된 비율에 도달할 떄까지 자동으로 주성분 찾음

                 주성분 개수 대신 0~1 사이의 비율을 실수로 입력

pca = PCA(n_components=0.5)
pca.fit(fruits_2d)

 

몇 개의 주성분 찾았는지

print(pca.n_components_)

2

-> 단 2개의 특성만으로 원본 데이터에 있는 분산의 50%까지 표현할 수 있다

 

원본 데이터 변환

fruits_pca = pca.transform(fruits_2d)
print(fruits_pca.shape)

(300, 2)

주성분이 2개이므로 변환된 데이터 크기 (300, 2)

 

교차 검증 결과

scores = cross_validate(lr, fruits_pca, target)
print(np.mean(scores['test_score']))
print(np.mean(scores['fit_time']))

0.99

0.03771648406982422

2개의 특성을 사용했을 뿐인데 99% 정확도 달성

 

차원 축소된 데이터 사용 k-평균 알고리즘으로 클러스터 찾기

from sklearn.cluster import KMeans
km = KMeans(n_clusters=3, random_state=42)
km.fit(fruits_pca)
print(np.unique(km.labels_, return_counts=True))

(array([0, 1, 2], dtype=int32), array([ 91, 99, 110]))

찾은 클러스터는 각각 91, 99, 110개의 샘플 포함

 

KMeans 찾은 레이블 이미지 출력

for label in range(0,3):
  draw_fruits(fruits[km.labels_ == label])
  print("\n")

 

클러스터별 산점도

차원 줄이면 얻는 또 하나의 장점 : 시각화!

3개 이하로 차원을 줄이면 화면에 출력하기 비교적 쉬움

 

km.labels_ 사용 클러스터별로 나누어 산점도 그리기

for label in range(0, 3):
  data = fruits_pca[km.labels_ == label]
  plt.scatter(data[:,0], data[:,1])
plt.legend(['apple', 'banana', 'pineapple'])
plt.show()

각 클러스터의 산점도가 아주 잘 구분됨

 

 

 

---

참고도서 : 혼자공부하는 머신러닝 + 딥러닝, 박해선, 한빛미디어, 2020년