Post

[혼자 공부하는 ML + DL] 6. 비지도 학습

Posted Updated
Preview Image
By Sun
18 min read

아래 내용은 “혼자 공부하는 머신러닝+딥러닝” 책을 공부하며 정리한 내용입니다.

Chapter 05. 비지도 학습

1. 군집 알고리즘

과일 사진들이 주어졌을 때, 머신러닝 모델은 자동으로 같은 과일의 이미지들끼리 분류할 수 있을까?

비지도 학습

타깃이 없는 문제에 대해 특성 데이터만을 가지고 학습시킬 수 있는 방법을 말한다.

과일 사진 데이터 준비

아래 메소드로 과일 사진 데이터를 불러온다.

1
2

# !로 시작하면 쉘 명령어 실행
!wget https://bit.ly/fruits_300_data -O fruits_300.npy

불러온 데이터는 넘파이 배열로 변환해서 학습에 사용할 수 있다.

1
2
3
4
5
6
7
8
9
10
11

import numpy as np
import matplotlib.pyplot as plt

# 넘파이 배열로 변환
fruits = np.load('fruits_300.npy')

# 100 * 100 크기의 샘플 300개
print(fruits.shape)

# 결과
(300, 100, 100)

그렇다면 간단하게 첫 번째 샘플의 첫 번째 행 바이트를 출력해 확인해보자.

낮은 값일 수록 검정색에, 높은 값일 수록 하얀색에 가까워진다.

1
2
3
4
5
6
7
8

print(fruits[0, 0, :])
# 결과
[  1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   2   1
   2   2   2   2   2   2   1   1   1   1   1   1   1   1   2   3   2   1
   2   1   1   1   1   2   1   3   2   1   3   1   4   1   2   5   5   5
  19 148 192 117  28   1   1   2   1   4   1   1   3   1   1   1   1   1
   2   2   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1   1
   1   1   1   1   1   1   1   1   1   1]

plt 모듈을 이용해 이미지를 직접 확인할 수 있다.

1
2

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

과일 이미지과일 이미지

1
2

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

과일 이미지과일 이미지

1
2
3
4

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

과일 이미지과일 이미지

픽셀 값 분석

값을 분석하기 위해서는 샘플 데이터의 차원을 3차원에서 2차원으로 변경해줘야 한다.

1
2
3
4
5
6
7
8
9

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][100][100] -> [100][100 * 100]
print(apple.shape)

# 결과
(100, 10000)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

print(apple.mean(axis=1))
# 결과
[ 88.3346  97.9249  87.3709  98.3703  92.8705  82.6439  94.4244  95.5999
  90.681   81.6226  87.0578  95.0745  93.8416  87.017   97.5078  87.2019
  88.9827 100.9158  92.7823 100.9184 104.9854  88.674   99.5643  97.2495
  94.1179  92.1935  95.1671  93.3322 102.8967  94.6695  90.5285  89.0744
  97.7641  97.2938 100.7564  90.5236 100.2542  85.8452  96.4615  97.1492
  90.711  102.3193  87.1629  89.8751  86.7327  86.3991  95.2865  89.1709
  96.8163  91.6604  96.1065  99.6829  94.9718  87.4812  89.2596  89.5268
  93.799   97.3983  87.151   97.825  103.22    94.4239  83.6657  83.5159
 102.8453  87.0379  91.2742 100.4848  93.8388  90.8568  97.4616  97.5022
  82.446   87.1789  96.9206  90.3135  90.565   97.6538  98.0919  93.6252
  87.3867  84.7073  89.1135  86.7646  88.7301  86.643   96.7323  97.2604
  81.9424  87.1687  97.2066  83.4712  95.9781  91.8096  98.4086 100.7823
 101.556  100.7027  91.6098  88.8976]

이번에는 hist 메소드로 샘플 데이터 값의 히스토그램을 그려보자.

1
2
3
4
5
6
7

# hist 메소드로 히스토그램을 그려보자.
# axis = 1 설정 시, 열을 기준으로 평균 값 계산
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()

히스토그램히스토그램

1
2
3
4
5
6
7

# axis = 0 설정 시, 10000개의 픽셀에 대한 평균 값 계산
# 1번째 행에 대해 3개의 그래프를 그림
flt, 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()

히스토그램히스토그램

다시 3차원 배열로 데이터를 재변환한 다음에 데이터의 평균값을 이미지로 확인해보도록 하자.

1
2
3
4
5
6
7
8
9
10
11
12

# 3차원 배열로 재변환 (100*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()

평균 이미지평균 이미지

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

각각의 데이터 값과 평균 이미지와의 차이를 절대값으로 구하고, 절대값의 평균을 다시 셈한다.

1
2
3
4
5

# abs: 절댓값 계산
abs_diff = np.abs(fruits - apple_mean)
# 모든 축에 대해 평균 계산
abs_mean = np.mean(abs_diff, axis=(1, 2))
print(abs_mean.shape)

절대값이 작은 순으로 데이터를 재배열한 다음, 가장 절대값이 작은 100개의 데이터를 차례대로 출력한다.

이러한 군집 클러스터링 방식은 타깃(평균값)을 어느 정도 알아야 하기 때문에 완벽한 비지도 학습에 해당되지 않는다.

1
2
3
4
5
6
7
8
9
10

# argsort: 소팅 후 가장 작은 값의 인덱스 반환
# 군집 클러스터링 -> 타깃을 어느 정도 알아야 하기 때문에 완벽한 비지도 학습은 아님.
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()

100개 데이터100개 데이터

2. K-평균

그렇다면 타깃 데이터를 알지 못해도 머신러닝은 자동으로 같은 과일들을 분류할 수 있을까?

K-평균K-평균

  1. k개의 중심점을 무작위로 잡고 가장 가까운 이미지끼리 묶어 군집을 형성한다.
  2. 군집 내부의 평균을 다시 구해 중심점을 평균점으로 옮긴다.
  3. 옮긴 중심점을 기준으로 다시 가장 가까운 이미지끼리 묶어 군집을 형성한다.
  4. 위의 과정을 더이상 군집에 변경이 없을 때까지 반복한다.

KMeans 클래스

챕터 1과 동일하게 과일 사진 데이터를 준비해보자.

1
2
3
4
5

!wget https://bit.ly/fruits_300_data -O fruits_300.npy
import numpy as np

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

KMeans를 통해 K-평균 방식으로 이미지를 분류할 수 있다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

from sklearn.cluster import KMeans

# 중심점 = 센트로이드
km = KMeans(n_clusters=3, random_state=42)
km.fit(fruits_2d)

# 분류 결과 확인
print(km.labels_)
# 결과
[2 2 2 2 2 0 2 2 2 2 2 2 2 2 2 2 2 2 0 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
 2 2 2 2 2 0 2 0 2 2 2 2 2 2 2 0 2 2 2 2 2 2 2 2 2 0 0 2 2 2 2 2 2 2 2 0 2
 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 0 2 2 2 2 2 2 2 2 0 0 0 0 0 0 0 0 0 0 0
 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
 1 1 1 1 1 1 1 1 1 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
 1 1 1 1]

0, 1, 2로 분류된 데이터가 각각 몇 개인지 확인해보도록 하자. unique는 클래스가 중복되는 데이터를 제거하며 return_counts=True로 설정 시, 각 클래스의 데이터가 몇 개인지 함께 출력한다.

1
2
3
4

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

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

plt 모듈로 각 클래스에 분류된 이미지들을 확인해보도록 하자.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

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()

# 첫 번째 클러스터
draw_fruits(fruits[km.labels_ == 0])

첫 번째 클러스터첫 번째 클러스터

1
2

# 두 번째 클러스터
draw_fruits(fruits[km.labels_ == 1])

두 번째 클러스터두 번째 클러스터

1
2

# 세 번째 클러스터
draw_fruits(fruits[km.labels_ == 2])

세 번째 클러스터세 번째 클러스터

클러스터 중심

클러스터의 중심(평균 이미지)을 확인해보자.

1
2

# 센트로이드를 확인하는 방법
draw_fruits(km.cluster_centers_.reshape(-1, 100, 100), ratio=3)

클러스터 중심클러스터 중심

100번째 데이터와 각 센트로이드 사이의 거리를 출력하면 1번째 클래스와 가장 근접함(유사함)을 알 수 있다.

1
2
3
4
5

# 100번째 데이터와 각 센트로이드 사이의 거리
print(km.transform(fruits_2d[100:101]))

# 결과
[[3393.8136117  8837.37750892 5267.70439881]]

실제로 0번, 즉 1번째 클래스로 분류되었다.

1
2
3
4
5

# 가장 가까운 1번째 클래스에 속함
print(km.predict(fruits_2d[100:101]))

# 결과
[0]

실제 이미지를 출력했을 때 1번째 클래스인 파인애플이 맞다는 걸 확인할 수 있다.

1

draw_fruits(fruits[100:101])

파인애플파인애플

최적의 k 찾기

군집의 개수를 적절하게 설정해 과대 적합을 방지하고 최적의 값을 구할 수 있다.

1
2
3
4
5
6
7
8
9
10
11

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

# 그래프가 꺾일 때 k 값이 최적의 값
plt.plot(range(2, 7), inertia)
plt.xlabel('k')
plt.ylabel('inertia')
plt.show()

K 그래프K 그래프

3. 주성분 분석

차원 축소

이미지 데이터는 크기가 너무 크기 때문에 디스크를 최적화하기 위해 결과에 영향을 미치지 않을 정도로 이미지의 차원을 축소해야 한다.

PCA 클래스

PCA 알고리즘이란?

데이터의 분포를 가장 잘 나타내는 주성분(선)을 이용하는 알고리즘

  • 주성분은 여러 개가 존재할 수도 있다. 차원 축소를 통해 주성분의 개수를 줄일 수 있다.
  • 주성분은 기존 주성분의 수직 방향으로 차례대로 찾는다.

데이터 준비

1
2
3
4
5

!wget https://bit.ly/fruits_300_data -O fruits_300.npy
import numpy as np

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

PCA 클래스를 이용해 먼저 50개의 주성분만 찾도록 한다.

1
2
3
4
5
6
7
8
9
10
11

from sklearn.decomposition import PCA

# 50개의 주성분만 찾도록 함
pca = PCA(n_components=50)
pca.fit(fruits_2d)

# 주성분이 가지는 속성은 10000개
print(pca.components_.shape)

# 결과
(50, 10000)

plt 모듈로 각 그림의 주성분을 이미지로 출력해보자.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

import matplotlib.pyplot as plt

def draw_fruits(arr, ratio=1):
  n = len(arr)
  rows = int(np.ceil(n/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:
        axs[i, j].imshow(arr[i*10 + j], cmap='gray_r')
      axs[i, j].axis('off')
  plt.show()


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

각 그림 주성분각 그림 주성분

1
2
3
4

print(fruits_2d.shape)

# 결과
(300, 10000)

이전에는 reshape 메소드를 사용했다면, PCA 클래스에서는 transform 메소드로 데이터 차원을 축소할 수도 있다.

1
2
3
4
5
6

# 데이터 차원 축소
fruits_pca = pca.transform(fruits_2d)

print(fruits_pca.shape)
# 결과
(300, 50)

원본 데이터 재구성

데이터를 이미지로 출력한 다음 확인하기 위해 색을 반전시켜주도록 하자.

1
2
3
4
5

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

# 결과
(300, 10000)

그리고 이미지 출력을 위해 1차원 데이터를 100 * 100의 2차원 데이터로 변환한다.

1
2
3
4
5
6

# 이미지로 출력하기 위해 100 * 100으로 변경
fruits_reconstruct = fruits_inverse.reshape(-1, 100, 100)

for start in [0, 100, 200]:
    draw_fruits(fruits_reconstruct[start:start+100])
    print("\n")

2차원 데이터 예시2차원 데이터 예시

설명된 분산

각 주성분이 갖고 있는 분산을 출력해보자.

1
2
3
4
5

# explained_variance_ratio_ : 각 주성분이 얼마만큼의 분산을 표현하는지.
print(np.sum(pca.explained_variance_ratio_))

# 결과
0.9215186216784217

분산 값을 그래프로 수치화해보도록 한다.

1

plt.plot(pca.explained_variance_ratio_)

분산 값 그래프분산 값 그래프

분류기와 함께 사용

1
2
3
4
5
6
7
8
9
10
11
12
13
14

from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import cross_validate

lr = LogisticRegression()

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

scores = cross_validate(lr, fruits_2d, target)
print(np.mean(scores['test_score']))
print(np.mean(scores['fit_time']))      # 분류하는데 걸린 시간

# 결과
0.9966666666666667
0.7837676525115966

PCA를 함께 사용했을 때 fit time이 훨씬 줄어들었다.

1
2
3
4
5
6
7

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

# 결과
1.0
0.034157514572143555

PCA 클래스의 주성분 개수는 2개가 적합하다.

1
2
3
4
5
6
7
8

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

# 2개의 주성분만 있으면 충분
print(pca.n_components_)

# 결과
2

군집과 함께 사용

1
2
3
4
5
6
7
8
9

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([110,  99,  91]))

시각화

이전에 사용한 주성분 2개를 2차원 그래프 위에 그려 시각화해볼 수 있다.

1
2
3
4
5

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()

주성분 시각화주성분 시각화

post, data analysis
python KHUDA 혼자 공부하는 ML + DL
This post is licensed under CC BY 4.0 by the author.