해야지11 님의 블로그

토익 벌크업 팩!!

해야지11 — Thu, 22 Jan 2026 15:24:30 +0900

안녕하세요! 이제 슬슬 취업을 준비해야 할 나이가 되니, 마음도 급박해지고 걱정이 앞서네요. ㅠㅠ 하지만 이럴 때일수록 조급해하지 않고, 차근차근 하나씩 준비하며 성장해 나가려고 굳게 다짐했습니다!
취준의 기본은 역시 어학 점수 확보인 것 같아서 일단 영어 공부부터 제대로 파보려고 하는데요. 마침 공부 자료를 찾다가 토익 벌크업팩을 무료로 배포한다는 꿀정보를 알게 되어 여러분께도 공유해 드립니다!

http://hackers.ac/contents/?m=landing&v=toeic/toeic_bulkuppack_free&_C_=689481&keywd=ac_toeic_bulkup_somun_250430&logger_kw=ac_toeic_bulkup_somun_250430&source=logger_kw&source=logger_kw

해커스어학원 :: 토익 벌크업팩 무료배포(점수상승8종세트)

토익 점수상승 8종세트 선착순 무료배포!

www.hackers.ac

혼자만 알고 있기엔 너무 유용한 자료라 가져왔어요. 자료 구성도 알차고 실전 감각 익히기에 딱 좋아 보입니다. 저도 이거 풀면서 열공 모드 들어가려고요! 우리 모두 이 자료로 영어 점수 확실하게 잡고, 스펙 업그레이드해서 꼭 원하는 곳에 취뽀 성공합시다! 저도 열심히 활동하며 좋은 결과 만들겠습니다. 다들 지치지 말고 파이팅하세요!!

[혼공머신] 5주차

해야지11 — Sun, 10 Aug 2025 19:29:53 +0900

06-1 (군집 알고리즘)

타깃이 없을 때 사용하는 머신러닝 알고리즘을 비지도 학습이라고 한다.

먼저 과일 사진 데이터를 준비했고 넘파이 배열을 통해 크기를 확인했다.

import numpy as np
import matplotlib.pyplot as plt

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

print(fruits.shape)

배열 크기 출력

그 다음엔 픽셀 100개에 들어있는 값을 출력했다. 이 넘파이 배열은 흑백 사진을 담고 있고 0~255까지의 정수값을 가진다.

matplotlib의 imshow() 함수를 사용하면 넘파이 배열로 저장된 이미지를 쉽게 그릴 수 있다. 흑백 이미지이므로 cmap 매개변수를 'gray'로 지정했다.

이 코드를 통해 첫 번째 이미지는 사과라고 알 수 있다. 또한 0에 가까울수록 검게 나타나고 높은 값은 밝게 표시된다.
우리의 관심을 바탕이 아니라 사과이기에 흑백이미지를 반전 시킬 것이다. 이는 cmap 매개변수를 'gray_r'로 지정하면 된다.

흑백이 반전된 사과 이미지

픽셀값을 분석하기 위해서 100 X 100 2차원 배열을 길이가 10,000인 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개에 대한 픽셀 평균값을 계산하고 이를 히스토그램으로 표현해 볼 것이다.

사과와 파인애플은 90~100 사이에 많이 모여있고 바나나 사진의 평균값은 40 아래에 집중되어 있다.

이번에는 각 픽셀의 평균을 구해볼 것이다. axis=0으로 지정하면 쉽게 계산할 수 있다.

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

각 픽셀의 평균을 막대그래프로 표현

순서대로 사과, 파인애플, 바나나 그래프이다. 각각 값이 높은 구간이 다르다. 사과는 사진 중앙에 상대적으로 값이 작은 영역이 보이고 파인애플 그래프는 비교적 고르면서 높다. 바나나는 확실히 중앙의 픽셀값이 높다.

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

apple_mean = apple.mean(axis=0).reshape(100,100)
pineapple_mean = pineapple.mean(axis=0).reshape(100,100)
banana_mean = banana.mean(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_mean으 뺀 절댓값을 평균을 계산하면 된다. 이때 넘파이 abs() 함수라는 절댓값을 계산하는 함수를 이용할 것이다. 이 함수는 np.absolute() 함수의 다른 이름이다.

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

여기서 abs_diff는 (300, 100, 100) 크기의 배열이다. 따라서 각 샘플에 대한 평균을 구하기 위해 axis 두 번째, 세 번째 차원을 모두 지정했다. 이렇게 계산한 abs_mean은 각 샘플의 오차 평균이므로 크기가 (300,)인 1차원 배열이다.
그러고나서 이 값이 가장 작은 순서대로 100개를 고른다. 이것은 apple_mean과 오차가 가장 작은 샘플 100개를 고르는 것이다. np.argsort() 함수는 작은 것에서 큰 순서대로 나열한 abs_mean 배열의 인덱스를 반환한다. 이 인덱스 중에서 처음 100개를 선택해 10 X 10 격자로 이루어진 그래프를 그렸다.

apple_index = np.argsort(abs_mean)[:100]
apple_index = apple_index.reshape(10,10)
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,j]],cmap='gray_r')
    axs[i,j].axis('off')
plt.show()

위 코드 출력

apple_mean과 가장 가까운 사진 100개를 골랐더니 모두 사과이다. 위 코드를 좀 더 설명하자면 subplots() 함수로 10 X 10, chd 100개의 서브 그래프를 만든다. 그래프가 많기에 figsize = (10, 10)으로 조금 크게 지정하고 2중 for문을 통해 10개의 행과 열에 이미지를 출력한다. i,j 두 첨자를 사용하여 서브 그래프 위치를 지정하였고 axis('off')를 사용하여 좌표축을 그리지 않았다.

흑백 사진에 있는 픽셀값을 사용해 과일 사진을 모으는 작업을 하는 것과 같이 비슷한 샘플끼리 그룹으로 모으는 작업을 군집이라 한다. 군집은 대표적인 비지도 학습 작업 중 하나이고 군집 알고리즘에서 만든 그룹을 클러스터라고 한다.

06-2 (k-평균)

1절에서는 사과, 파인애플, 바나나 사진임을 미리 알고 있었기에 각 과일을 평균을 구했다. 하지만 진짜 비지도 학습에서는 사진에 어던 과일이 들어있는지 알지 못한다. 이럴 경우에는 k-평균 군집 알고리즘이 평균값을 자동으로 찾아준다. 이 평균값이 클러스터의 중심에 위치하기 때문에 클러스터 중심 또는 센트로이드라고 부른다.

k-평균 알고리즘의 작동 방식은 다음과 같다.

무작위로 k개의 클러스터 중심을 정한다.
각 샘플에서 가장 가까운 클러스터 중심을 찾아 해당 클러스터의 샘플로 지정한다.
클러스터에 속한 샘플의 평균값으로 클러스터 중심을 변경한다.
클러스터 중심에 변화가 없을 때까지 2번으로 돌아가 반복한다.

사이킷런의 k-평균 알고리즘은 sklearn.cluster 모듈 아래 KMeans 클래스에 구현되어 있다.
클러스터 개수를 정정하는 매개변수는 n_clusrers이다. 비지도 학습이기에 fit() 메서드에서 타깃 데이터를 사용하지 않는다.

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

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

label_ 배열의 값은 0, 1, 2 중 하나이다.

각 샘플이 어떤 레이블에 해당되는지 확인

레이블값 0, 1, 2와 레이블 순서에는 어떤 의미도 없고, 실제 레이블 0, 1, 2가 어떤 과일 사진을 주로 모았는지 알아보려면 직접 이미지를 출력하는 것이 최선이다. 그 전에 레이블 0, 1, 2로 모은 샘플의 개수를 확인해봤다.

draw_fruits() 함수는 (샘플 개수, 너비, 높이)의 3차원 배열을 입력받아 가롤로 10개씩 이미지를 출력한다. 또한 아래 코드에서 불리언 인덱싱을 사용한다.

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(fruits[km.labels_==0])

레이블이 0일때의 출력

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

레이블이 1일 때의 출력

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

레이블이 2일 때 출력

위 출력들을 통해 레이블이 0은 대부분 파인애플, 1은 바나나, 2는 사과가 출력되었음을 알 수 있다. 샘플들을 완벽하게 구별하지는 못했어도 비슷한 샘플들을 잘 모았다.

KMeans 클래스가 최종적으로 찾은 클러스터 중심은 cluster_centers_ 속성에 저장되어 있다. 이 배열은 fruits_2d 샘플의 클러스터 중심이기 때문에 각 중심을 이미지로 출력하려면 100 X 100 크기의 2차원 배열로 바꿔야 한다.

KMeans 클래스는 훈련 데이터 샘플에서 클러스터 중심까지 거리로 변환해 주는 transform() 메서드를 가지고 있다. 이 메서는 마치 StandardScaler 클래스처럼 특성값을 변환하는 도구로 사용할 수 있다는 의미이다.
transform() 메서드를 적용할 때, fit() 메서드와 마찬가지로 2차원 배열을 기대한다. fruits_2d[100]처럼 쓰면 (10000,) 크기의 배열이 되므로 에러가 발생한다. 그러므로 슬라이싱 연산자를 사용해서 (1, 10000) 크기의 배열을 전달했다.

첫 번째 클러스터(레이블 0), 두 번째 클러스터(레이블 1), 세 번째 클러스터(레이블 2)가 각각 첫 번째 원소, 두 번째 원소, 세 번째 원소의 값이다. 이중 첫 번째 클러스터까지의 거리가 가장 작기에 이 샘플을 레이블 0에 속했다.

KMeans 클래스는 가장 가까운 클러스터 중심을 예측 클래스로 출력하는 predict() 메서드도 제공한다.

몇 번째 레이블과 가장 가까운지 출력

샘플 확인

transform()의 결과에서 짐작했듯이 이 샘플은 파인애플이 맞았다.

k-평균 알고리즘은 앞에서 설명햇들이 반복적으로 클러스터 중심을 옮기면서 최적의 클러스터를 찾는다. 알고리즘이 반복한 횟수는 KMeans 클래스의 n_iter_ 속성에 저장된다.

만약 우리가 n_cluster를 지정할 수 없을 때 최적의 클러스터를 어떻게 구해야할지 고민될 것이다. 적절한 k 값을 찾기 위한 완벽한 방법은 없다. 몇 가지 도구가 있지만 저마다의 장단점이 있다. 그 중 우린 대표적인 방법은 엘보우 방법에 대해서 알아볼 것이다.

k-평균 알고리즘은 클러스터 중심과 클러스터에 속한 샘플 사이의 거리를 잴 수 있다. 이 거리의 제곱 합을 이너셔라고 부르고 이너셔는 클러스터에 속한 샘플이 얼마나 가깝게 모여 있는지를 나타내는 값으로 생각할 수 있다. 일반적으로 클러스터 개수가 늘어나면 클러스터 개개의 크기는 줄어들기에 이너셔도 줄어든다. 엘보우 방법은 클러스터 개수를 늘려가면서 이너셔의 변화를 관찰하여 최적의 클러스터 개수를 찾는 방법이다.

클러스터 개수를 증가시키면서 이너셔를 그래프로 그리면 감소하는 속도가 꺾이는 지점이 있다. 이 지접부터는 클러스터 개수를 늘려도 클러스터에 잘 밀집된 정도가 크게 개선되지 않기에 이 지점을 k로 사용한다. 이 지점이 마치 팔꿈치 모양이어서 엘보우 방법이라 부른다.

하지만 위 그래프는 그래프의 기울기가 조금 바뀌었지만 지점이 명확하지 않다.

06-3 (주성분 분석)

너무 많은 사진이 등록되어 저장 공간이 부족해질 수가 있다. 이때 차원을 축소하면 된다. 이때 머신러닝에서의 차원은 예를 들어 과일 사진의 경우 10,000개의 픽셀이 있기 때문에 10,000개의 특성이 있는 셈이고 이러한 특성을 차원이라고 한다. 10,000개의 차원을 줄이기 위한 비지도 학습 작업 중 하나인 차원 축소 알고리즘을 다룰 것이다.

특성이 많으면 선형 모델의 성능이 높아지고 훈련 데이터에 과대적합된다. 차원 축소는 데이터를 가장 잘 나타내는 일부 특성을 선택하여 데이터 크기를 줄이고 지도 학습 모델의 성능을 향상시킬 수 있는 방법이다. 또한 줄어든 차원에서 다시 원본 차원으로 손실을 최대한 출이면서 복원할 수도 있다.

대표적인 차원 축소 알고리즘인 주성분 분석에 대해 배우 것이며 주성분 분석을 간단히 PCA라고도 부른다.

주성분 분석에 대해서 소개하자면 주성분 분석은 데이터에 있는 분산이 큰 방향을 찾는 것으로 이해할 수 있다. 분산은 데이터가 널리 퍼져있는 정도를 말하며 분산이 큰 방향은 데이터를 잘 표현하는 어떤 벡터라고 생각할 수 있다.

2차원 데이터를 생각해보면 데이터의 분포를 가장 잘 표현하는 길게 늘어진 대각선을 생각할 수 있고 이 대각선 방향이 분산이 가장 크다고 말할 수 있다. 화살표의 위치는 중요하지 않고 분산이 큰 방향을 찾는 것이 중요하다. 이 직선이 원점에서 출발한다면 두 원소로 이루어진 벡터를 쓸 수 있다. 이 벡터를 주성분이라고 부른다. 샘플 데이터를 주성분에 직각으로 투영하면 1차원 데이터를 만들 수 있다.

주성분이 가장 분산이 큰 방향이기에 주성분에 투영하여 바꾼 데이터는 원본이 가지고 있는 특성을 가장 잘 나타내고 있을 것이다.
첫 번째 주성분을 찾은 다음 이 벡터에 수직이고 분산이 가장 큰 다음 방향을 찾는다. 이 벡터가 두 번째 주성분이다. 여기서는 2차원이기 때문에 두 번째 주성분의 방향은 하나뿐이다.

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

사이킷런은 sklearn.decomposition 모듈 아래 PCA 클래스로 주성분 분석 알고리즘을 제공한다. PCA 클래스의 객체를 만들 때 n_components 매개변수에 주성분의 개수를 지정해야한다. k-평균과 마찬가지로 비지도 학습이기에 fit() 메서드에 타깃값을 제공하지 않는다.

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

위 사진과 같이 n_components를 50으로 지정했기에 첫 번째 차원은 50개, 즉 40개의 주성분을 찾았고 두 번째 차원은 항상 원본 데이터의 특성 개수와 같은 10,000이다.

또한 주성분을 그림으로 그려보았다.

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(pca.components_.reshape(-1, 100, 100))

주성분을 그림으로 출력

원본 데이터를 주성분에 투영하여 특성 개수를 10,000개에서 50개로 줄일 것이다. PCA의 transform() 메서드를 사용해서 원본 데이터의 차원을 50으로 줄였다.

print(fruits_2d.shape)

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

앞에서 특성을 50개로 줄였다. 어느 정도 손실이 발생할 수밖에 없지만 최대한 분산이 큰 방향으로 데이터를 투영했기에 원본 데이터를 상당 부분 재구성할 수 있다. PCA 클래스는 이를 위해 inverse_transform() 메서드를 제공한다.

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

주성분이 원본 데이터의 분산을 얼마나 잘 나타내는지 기록한 값을 설명된 분산이라고 한다. PCA 클래스의 explained_variance_ratio_에 각 주성분의 설명된 분산 비율이 기록되어있다. 당연히 첫 번째 주성분의 설명된 분산ㅇ ㅣ가장 크다.

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

print(np.sum(pca.explained_variance_ratio_))

또한 적절한 주성분의 개수를 찾기 위해 설명된 분산의 비율을 그래프로 그려보았다.

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

설명된 분산의 비율 그래프

그래프를 통해 처음 10개의 주성분이 대부분의 분산을 표현함을 을 수 있다.

원본 데이터와 축소한 데이터를 지도 학습에 적용해보고 어던 차이가 있는지 알아보기 위해 로지스틱 회귀 분석을 사용하였다.

from sklearn.linear_model import LogisticRegression
lr = LogisticRegression()

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

cross_validate()로 교차 검증을 수행하였다.

원본 데이터 및 PCA로 축소한 데이터를 통한 교차검증 수행

정확도가 동일하지만 훈련시간은 줄어들었다.

설명된 분산의 50%에 달하는 주성분을 찾도록 PCA 모델을 만들어보았다. 주성분 개수 대신 0~1 사이의 비율을 실수로 입력하면된다.

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

print(pca.n_components_)

이 결과 2개의 특성만으로 원본 데이터에 있는 분산의 50%를 표현할 수 있다.

이 모델로 원본 데이터를 변환하고 교차 검증을 확인해 보았다.

2개의 특성만으로도 정확도가 높은 것을 알 수 있다.

이번에는 차원 축소된 데이터를 사용해 k-평균 알고리즘으로 클러스터를 찾아볼 것이다.

원본 데이터와 거의 비슷한 결과이다.

훈련 데이터의 차원을 줄이면 얻을 수 있는 장점은 시각화이다. 3개 이하로 차원을 줄이면 화면에 출력하기 비교적 쉽다. fruits_pca 데이터는 2개의 특성이 있기 때문에 2차원으로 표현할 수 있다.

시각화 출력

숙제

k-평균 알고리즘의 작동 방식은 다음과 같다.

무작위로 k개의 클러스터 중심을 정한다.
각 샘플에서 가장 가까운 클러스터 중심을 찾아 해당 클러스터의 샘플로 지정한다.
클러스터에 속한 샘플의 평균값으로 클러스터 중심을 변경한다.
클러스터 중심에 변화가 없을 때까지 2번으로 돌아가 반복한다.

[혼공머신] 4주차

해야지11 — Sun, 27 Jul 2025 23:52:32 +0900

05-1 (결정 트리)

결정 트리 모델은 스무고개와 같기에 이유를 설명하기 쉽고 fit() 메서드를 호출해서 모델을 훌녈하고 score()메서드로 정확도를 평가한다.

from sklearn.tree import DecisionTreeClassifier
dt = DecisionTreeClassifier(random_state=42)
dt.fit(train_scaled, train_target)
print(dt.score(train_scaled, train_target))
print(dt.score(test_scaled, test_target))

훈련 세트에 대한 점수가 엄청 높고 테스트 세트의 성능은 그에 비해 조금 낮으므로 과적합된 모델이라 볼 수 있다.

이 모델을 그림으로 표현한다면 사이킷런의 plot_tree() 함수를 사용하면 된다.

import matplotlib.pyplot as plt
from sklearn.tree import plot_tree
plt.figure(figsize=(10,7))
plot_tree(dt)
plt.show()

모델을 그림으로 표현

max_depth 매개변수를 1로 주면 루트 노드를 제외하고 하나의 노드를 더 확장하여 그릴 수 있다.

filled 매개변수에서 클래스에 맞게 노드의 색을 칠할 수 있다.

feature_names 매개변수에는 특성의 이름을 전달할 수 있다.

plt.figure(figsize=(10,7))
plot_tree(dt, max_depth=1, filled=True,
          feature_names=['alcohol','sugar','pH'])
plt.show()

위 코드를 실행한 결과

노드 상자 안 gini는 지니 불순도를 의미한다. DecisionTreeClassifier 클래스의 criterion 매개변수의 기본값이 'gini'이다.

지니 불순도는 클래스의 비율을 제곱해서 더한 다음 1에서 빼면 된다.

지니 불순도 = 1 - {(음성 클래스 비율)² + (양성 클래스 비율)²}

결정 트리 모델은 부모 노드와 자식 노드의 불순도 차이가 가능한 크도록 트리를 성장시킨다. 부모 노드와 자식 노드의 불순도 차이를 계산하는 방법은 자식 노드의 불순도를 샘플 개수에 비례하여 모두 더한다. 그다음 부모 노드의 불순도에서 빼면 된다.

정보 이득 = 부모의 불순도 - (왼쪽 노드 샘플 수 / 부모의 샘플 수) × 왼쪽 노드 불순도

- (오른쪽 노드 샘플 수 / 부모의 샘플수) × 오른쪽 노드 불순도

criterion = 'entropy'를 지정하여 엔트로피 불순도를 사용할 수 있다. 엔트로피 불손도도 노드의 클래스 비율을 사용하지만 지니 불손도처럼 제곱이 아니라 밑이 2인 로그를 사용하여 곱한다.

결정 트리도 가지치기를 해야 무작정 끝까지 자라나는 트리가 만들어지지 않는다. 무작정 자라나면 훈련 세트에는 아주 잘 맞겠지만 테스트 세트에서 점수는 그에 못 치지기 때문이다. 그 중 가장 간단한 방법은 트리의 최대 깊이를 지정하는 것이다. DecisionTreeClassifier 클래스의 max_depth 매개변수를 3으로 지정하여 모델을 만들 것이다.

dt = DecisionTreeClassifier(max_depth=3, random_state=42)
dt.fit(train_scaled, train_target)
print(dt.score(train_scaled, train_target))
print(dt.score(test_scaled, test_target))

이를 실행하면 훈련 세트의 성능은 낮아졌지만 테스트 세트의 성능은 거의 그대로이다. plot_tree() 함수로 그려보면 아래와 같이 나온다.

plt.figure(figsize=(20,15))
plot_tree(dt,filled=True, feature_names=['alcohol','sugar','pH'])
plt.show()

위 코드 실행 결과

05-2 (교차 검증과 그리드 서치)

테스트 세트를 사용하지 않으면 모델이 과대적합인지 과소적합인지 판단하기 어렵다. 테스트 세트를 사용하지 않고 이를 측정하는 간단한 방법은 훈련 세트를 나는 것이다. 이 데이터를 검증 세트라고 한다. 아래 코드는 훈련 세트와 테스트 세트를 나눈 후 훈련 세트에서 훈련 세트와 검증 세트로 나누는 과정이다.

from sklearn.model_selection import train_test_split
train_input, test_input, train_target, test_target = train_test_split(
    data, target, test_size=0.2, random_state=42)
    
sub_input, val_input, sub_target, val_target = train_test_split(
    train_input, train_target, test_size=0.2, random_state=42
)

교차 검증을 이용하면 안정적인 검증 점수를 얻고 훈련에 더 많은 데이터를 사용할 수 있다. 교차 검증은 검증 세트를 떼어 내어 평가하는 과정을 여러 번 반복한다. 그다음 이 점수를 평균하여 최종 검증 점수를 얻는다.

k-폴드 교차 검증은 훈련 세트를 몇 부분으로 나누냐에 따라 다르게 부른다.

사이킷런에는 cross_validate()라는 교차 검증 함수가 있다. 사용법은 먼저 평가할 모델 객체를 첫 번째 매개변수로 전달하고 그다음 앞에서처럼 직접 검증 세트를 떼어 내지 않고 훈련 세트 전체를 cross_validate() 함수에 전달하는 것이다. 이 함수는 fit_time, score_time, test_score 키를 가진 딕셔너리를 반환한다.

from sklearn.tree import DecisionTreeClassifier
dt = DecisionTreeClassifier(random_state=42)
dt.fit(sub_input, sub_target)
print(dt.score(sub_input, sub_target))
print(dt.score(val_input, val_target))

from sklearn.model_selection import cross_validate
scores = cross_validate(dt, train_input, train_target)
print(scores)

교차 검증의 최종 점수는 test_score 키에 담긴 점수를 평균하여 얻을 수 있다. 이름은 test_score지만 검증 폴드의 점수이다.

import numpy as np
print(np.mean(scores['test_score']))

cross_validate() 함수는 기본적으로 회귀 모델일 경우 KFold 분할기를 사용하고 분류 모델일 경우 타깃 클래스를 골고루 나누기 위해 StratifiedKFold를 사용한다. 앞서 수행한 교차 검증은 다음 코드와 동일하다.

from sklearn.model_selection import StratifiedKFold
scores = cross_validate(dt, train_input, train_target, cv=StratifiedKFold())
print(np.mean(scores['test_score']))

만약 훈련 세트를 섞은 후 10-폴드 교차 검증을 수행하려면 다음과 같이 작성한다.

splitter = StratifiedKFold(n_splits=10, shuffle=True, random_state=42)
scores = cross_validate(dt, train_input, train_target, cv=splitter)
print(np.mean(scores['test_score']))

모델 파라미터는 머신러닝 모델이 학습하는 파라미터이고 모델이 학습할 수 없어서 사용자가 지정해야만 하는 파라미터를 하이퍼파라미터라고 한다.

결정 트리 모델에서 최적의 max_depth와 min_samples_split 매개변수를 동시에 바꿔가면 최적의 값을 찾아야 한다. 게다가 매개변수가 많아지면 더욱 복잡해지므로 사이킷런에서 제공하는 그리드 서치를 사용할 것이다.

from sklearn.model_selection import GridSearchCV
# 탐색할 매개변수와 탐색할 값의 리스트를 딕셔너리로 만든다.
params = {'min_impurity_decrease': [0.0001, 0.0002, 0.0003, 0.0004, 0.0005]} 

gs = GridSearchCV(DecisionTreeClassifier(random_state=42), params, n_jobs=-1)

gs.fit(train_input, train_target)

dt = gs.best_estimator_
print(dt.score(train_input, train_target))

# 0.0001이 가장 좋은 값으로 선택됨
print(gs.best_params_)

print(gs.cv_results_['mean_test_score'])

print(gs.cv_results_['params'][gs.best_index_])

# 교차 검증하기 위해 매개변수의 값을 다르게 지정 총 9 X 15 X 10 = 1,350번의 교차 검증이 일어난다.
params = {'min_impurity_decrease': np.arange(0.0001, 0.001, 0.0001),
          'max_depth': range(5, 20, 1),
          'min_samples_split': range(2,100,10)
          }
          
gs = GridSearchCV(DecisionTreeClassifier(random_state=42), params, n_jobs=-1)
gs.fit(train_input, train_target)

# 최상의 매개변수 조합을 확인
print(gs.best_params_)

print(np.max(gs.cv_results_['mean_test_score']))

랜덤 서치는 매개변수의 값이 수치일 때 값의 범위나 간격을 미리 정하기 어려울 때 또 너무 많은 매개변수 조건이 있어 그리드 서치 수행 시간이 오래 걸릴 때 사용한다.

from scipy.stats import uniform,randint

rgen = randint(0,10)
rgen.rvs(10)

# 1,000개를 샘플링 후 각 숫자의 개수를 셈
np.unique(rgen.rvs(1000), return_counts=True)

ugen = uniform(0,1)
ugen.rvs(10)

# 0.0001에서 0.001 사이의 실숫값을 샘플링, 20에서 50사이의 정수를 샘플링, 
# 2에서 25 사이의 정수, 1에서 25 사이의 정수를 샘플링한다.
params = {'min_impurity_decrease': uniform(0.0001, 0.001),
          'max_depth': randint(20,50),
          'min_samples_split': randint(2,25),
          'min_samples_leaf': randint(1,25),
          }

# n_iter = 100을 통해 100번을 샘플링하여 교차 검증을 수행
from sklearn.model_selection import RandomizedSearchCV
rs = RandomizedSearchCV(DecisionTreeClassifier(random_state=42), params,
                        n_iter=100, n_jobs=-1, random_state=42)
rs.fit(train_input, train_target)

print(rs.best_params_)

print(np.max(rs.cv_results_['mean_test_score']))

dt = rs.best_estimator_
print(dt.score(test_input, test_target))

05-3 (트리의 앙상블)

CSV, 데이터베이스, 엑셀과 같이 어떤 구조로 되어있는 데이터를 정형 데이터라 하고 이와 반대되는 데이터를 비정형 데이터라고 한다.

정형 데이터를 다루는 데 가장 뛰어난 성과를 내는 알고리즘이 앙상블 학습니다.

랜덤 포레스트는 앙상블 학습의 대표 주자로 안정적인 성능 덕분에 널리 사용되고 있다. 랜덤 포레스트는 부트스트랩 샘플을 사용한다. 예를 든다면 1,000개의 샘플이 들어있는 가방에서 100개의 샘플을 뽑는다면 먼저 1개를 뽁고, 뽑았던 1개를 다시 가방에 넣는 식으로 중복된 샘플을 뽑을 수 있는 복원 추출을 한다.

from sklearn.model_selection import cross_validate
from sklearn.ensemble import RandomForestClassifier
rf = RandomForestClassifier(n_jobs=-1, random_state=42)
scores = cross_validate(rf, train_input, train_target,
                        return_train_score=True, n_jobs=-1)
print(np.mean(scores['train_score']), np.mean(scores['test_score']))

# n_jobs 매개변수를 -1로 지정하여 모든 CPU 코어를 사용
# return_train_score 매개변수를 True로 지정하면 검증 점수뿐만 아니라
# 훈련 세트에 대한 점수도 반한됨 ( 기본값은 False)

rf.fit(train_input, train_target)
print(rf.feature_importances_)

부트스트랩 샘플에 포함되지 않고 남는 샘플이 있다. 이를 OOB(out of bag) 샘플이라 한다. 이 남는 샘ㅁ플을 사용하여 부트스트랩 샘플로 훈련한 결정 트리를 검증 세트의 역할로 평가할 수 있다.

rf = RandomForestClassifier(oob_score=True, n_jobs=-1, random_state=42)
rf.fit(train_input, train_target)
print(rf.oob_score_)

엑스트라 트리는 랜덤 포레스트와 매우 비슷하지만 부트스트랩 샘플을 사용하지 않는다. 즉각 결정 트리를 만들 때 전체 훈련 세트를 사용한다. 대신 노드를 분할할 때 가장 좋은 분할을 찾는 것이 아니라 무작위로 분할한다. 무작위로 분할 하면 성능이 낮아지겠지만 많은 트리를 앙상블 하기 때문에 과대적합을 막고 검증 세트의 점수를 높이는 효과가 있다.

from sklearn.ensemble import ExtraTreesClassifier
et = ExtraTreesClassifier(n_jobs=-1, random_state=42)
scores = cross_validate(et, train_input, train_target,
                        return_train_score=True, n_jobs=-1)
print(np.mean(scores['train_score']), np.mean(scores['test_score']))

et.fit(train_input, train_target)
print(et.feature_importances_)

그레이디언트 부스팅은 깊이가 얕은 결정 트리를 사용하여 이전 트리의 오차를 보완하는 방식으로 앙상블 하는 방법이다. 깊이가 얕은 결정 트리를 사용하기 때문에 과대적합이 강하고 일반적으로 높은 일반화 성능을 기대할 수 있다. 그레이디언트 부스팅은 경사 하강법을 사용하여 트리를 앙상블에 추가한 것이다.

from sklearn.ensemble import GradientBoostingClassifier
gb = GradientBoostingClassifier(random_state=42)
score = cross_validate(gb, train_input, train_target,
                       return_train_score=True, n_jobs=-1)
print(np.mean(scores['train_score']), np.mean(scores['test_score']))


gb = GradientBoostingClassifier(n_estimators=500, learning_rate=0.2,
                                random_state=42)
scores = cross_validate(gb, train_input, train_target,
                        return_train_score=True, n_jobs=-1)
print(np.mean(scores['train_score']), np.mean(scores['test_score']))


gb.fit(train_input, train_target)
print(gb.feature_importances_)

히스토그램 기반 그레이디언트 부스팅은 정형 데이터를 다루는 머신러닝 알고리즘 중에 가장 인기가 높은 알고리즘이다. 히스토그램 기반 그레이디언트 부스팅은 먼저 입력 특성을 256개의 구간으로 나누기에 노드를 분할할 때 최적의 분할을 매우 빠르게 찾을 수 있다. 256개의 구간 중에서 하나를 떼어 놓고 누락된 값을 위해서 사용한다. 그렇기에 입력에 누락된 특성이 있더라도 따로 전처리할 필요가 없다.

n_estimators 대신에 부스팅 반복 횟수를 지정하는 max_iter를 사용한다.

permutation_importance() 함수를 사용하여 특성 중요도를 계산한다.

from sklearn.ensemble import HistGradientBoostingClassifier
hgb = HistGradientBoostingClassifier(random_state=42)
scores = cross_validate(hgb, train_input, train_target,
                        return_train_score=True)
print(np.mean(scores['train_score']), np.mean(scores['test_score']))

from sklearn.inspection import permutation_importance
hgb.fit(train_input, train_target)
result = permutation_importance(hgb, train_input, train_target,
                               n_repeats=10, random_state=42, n_jobs=-1)
print(result.importances_mean)

result = permutation_importance(hgb, test_input, test_target,
                                n_repeats=10, random_state=42, n_jobs=-1)
print(result.importances_mean)

hgb.score(test_input, test_target)

# 중요도를 내림차순 정렬해서 보기 쉽게 출력
feature_names = data.columns
for i in result.importances_mean.argsort()[::-1]:
    print(f"{feature_names[i]:<10}: 중요도 평균 = {result.importances_mean[i]:.4f}, "
          f"표준편차 = {result.importances_std[i]:.4f}")

히스토그램 기반 그레이디언트 부스팅 말고도 그레이디언트 부스팅 알고리즘을 구현한 라이브러리가 있는데 가장 대표적인 라이브러리는 XGBoost이다. cross_validate() 함수와 함께 사용할 수 있다. tree_method 매개변수를 'hist'로 지정하면 히스토그램 기반 그레이디언트 부스팅을 사용할 수 있다.

from xgboost import XGBClassifier
xgb = XGBClassifier(tree_method='hist', random_state=42)
scores = cross_validate(xgb, train_input, train_target,
                        return_train_score=True, n_jobs=-1)
print(np.mean(scores['train_score']), np.mean(scores['test_score']))

널리 사용하는 또 다른 히스토그램 기반 그레이디언트 부스팅 라이브러리는 마이크로소프트에서 만든 LightGBM이 있다.

from lightgbm import LGBMClassifier
lgb = LGBMClassifier(random_state=42)
scores = cross_validate(lgb, train_input, train_target,
                        return_train_score=True, n_jobs=-1)
print(np.mean(scores['train_score']), np.mean(scores['test_score']))

숙제

교차 검증은 검증 세트를 떼어 내어 평가하는 과정을 여러 번 반복한다. 그다음 이 점수를 평균하여 최종 검증 점수를 얻는다.

3 - 폴드 교차 검증

3 - 폴드 교차 검증은 훈련 세트를 세 부분으로 나눠서 교차 검증을 수행하는 것이다. 3번의 교차 검증을 수행한다.

[혼공머신] 3주차

해야지11 — Sun, 20 Jul 2025 22:32:46 +0900

04-1 (로지스틱 회귀)

k-최근접 이웃 분류를 통해 어떤 생선으로 분류될지 파악하는 단원

데이터를 준비하고 pd.unique()함수를 통해 어떤 종류의 생선이 있는지 파악

import pandas as pd
fish = pd.read_csv('https://bit.ly/fish_csv_data')
print(fish.head())

print(pd.unique(fish['Species']))

Species 열을 제외한 나머지 5개의 열을 입력데이터로 사용하고 Species 열을 타깃 데이터로 사용

fish_input = fish[['Weight','Length','Diagonal','Height','Width']]
print(fish_input.head())

fish_target = fish['Species']

데이터를 훈련세트와 테스트 세트로 나누고 사이킷런의 StandardScaler 클래스를 사용하여 훈련 세트와 테스트 세트를 표준화 전처리

from sklearn.model_selection import train_test_split
train_input, test_input, train_target, test_target = train_test_split(
fish_input, fish_target, random_state=42)

from sklearn.preprocessing import StandardScaler
ss = StandardScaler()
ss.fit(train_input)
train_scaled = ss.transform(train_input)
test_scaled = ss.transform(test_input)

k-최근접 이웃 분류기의 확률 예측을 통해 점수 확인

from sklearn.neighbors import KNeighborsClassifier
kn = KNeighborsClassifier(n_neighbors=3)
kn.fit(train_scaled, train_target)
print(kn.score(train_scaled, train_target))
print(kn.score(test_scaled, test_target))

타깃값을 그대로 사이킷런 모델에 전달하면 순서가 자동으로 알파벳 순으로 매겨진다. 그렇기에 pd.unique(fish['Species'])로 출력했던 순서와 다르다.

print(pd.unique(fish['Species']))
print(kn.classes_)

테스트 세트에 있는 처음 5개 샘플의 타깃값을 예측

print(kn.predict(test_scaled[:5]))

사이킷런의 분류 모델은 predict_proba() 메서드로 클래스별 확률값을 반환한다. demicals 매개변수로유지할 소수점 아래 자릿수를 정할 수 있다.

import numpy as np
proba = kn.predict_proba(test_scaled[:5])
print(np.round(proba, decimals=4))

위 코드를 실행하면 열은 몇 번째 클래스에 대한 확률이고 행은 하나의 샘플이 각각의 클래스에 대한 확률이다.

predict_proba() 출력 결과

네 번째 샘플의 최근접 이웃의 클래스를 확인하면

distances, indexes = kn.kneighbors(test_scaled[3:4])
print(train_target.iloc[indexes[0]])

네 번째 샘플의 최근접 이웃 클래스 출력값

로지스틱 회귀

로지스틱 회귀는 이름은 회구이지만 분류 모델이다. 선형 회귀와 동일하게 선형 방정식을 학습하고 가중치 혹은 계수를 특성에 곱하여 사용된다. 시그모이드 함수 또는 로지스틱 함수를 사용한다.

넘파이를 사용하여 시그모이드 그래프를 출력

import numpy as np
import matplotlib.pyplot as plt
z = np.arange(-5, 5, 0.1)
phi = 1 / (1+np.exp(-z))
plt.plot(z,phi)
plt.xlabel('z')
plt.ylabel('phi')
plt.show()

시그모이드 그래프

넘파이 배열은 True, False 값을 전달하여 행을 선택할 수 있다. 이를 불리언 인덱싱이라고 부른다

불리언 인덱싱 예시

char_arr = np.array(['A', 'B', 'C', 'D', 'E'])
print(char_arr[[True, False, True, False, False]])

도미(Bream), 빙어(Smelt) 행만 불리언 인덱싱을 이용해서 골라내기

bream_smelt_indexes = (train_target == 'Bream') | (train_target == 'Smelt')
train_bream_smelt = train_scaled[bream_smelt_indexes]
target_bream_smelt = train_target[bream_smelt_indexes]

위에서 골라낸 데이터를 통해 로지스틱 회귀 모델을 훈련

from sklearn.linear_model import LogisticRegression
lr = LogisticRegression()
lr.fit(train_bream_smelt, target_bream_smelt)

# 처음 5개의 샘플 예측
print(lr.predict(train_bream_smelt[:5]))

# 처음 5개 샘플의 예측 확률 출력
print(lr.predict_proba(train_bream_smelt[:5]))

# classes_ 속성에서 확인
print(lr.classes_)

# 계수확인
print(lr.coef_, lr.intercept_)

# 처음 5개 샘플의 z 값을 출력
decisions = lr.decision_function(train_bream_smelt[:5])
print(decisions)

# 사이파이 라이브러리에 있는 시그모이드 함수를 통해 decisions 배열의 값을 확률로 변환
from scipy.special import expit
print(expit(decisions))

로지스틱 회귀로 다중 분류를 수행할 수도 있는데 릿지 회귀와 같이 계수의 제곱을 규제한다. LogisticRegression에서 규제를 제어하는 매개변수는 C이다. C는 릿지 회귀에서의 alpha 매겨변수와는 다르게 작을수록 규제가 커진다. C의 기본값은 1이지만 여기서는 규제를 조금 완화하기 위해 20을로 늘렸다.

lr = LogisticRegression(C=20, max_iter=1000)
lr.fit(train_scaled, train_target)
print(lr.score(train_scaled, train_target))
print(lr.score(test_scaled, test_target))

# 테스트 세트 처음 5개 샘플에 대한 예측
print(lr.predict(test_scaled[:5]))

# 테스트 세트의 처음 5개 샘플에 대한 예측 확률
proba = lr.predict_proba(test_scaled[:5])
print(np.round(proba, decimals=3))

# classes_ 속성에서 클래스 정보 확인
print(lr.classes_)

# 계수 출력
print(lr.coef_.shape, lr.intercept_.shape)

다중 분류는 시그모이드 함수가 아닌 소프트맥스 함수를 사용하여 7개의 z값을 확률로 변환한다.

시그모이드 함수는 하나의 선형 방정식의 출력값을 0~1 사이로 압축한다. 이와 달리 소프트맥스 함수는 여러 개의 선형 방정식의 출력값을 0~1 사이의 확률로 압축하고 전체 합이 1이 되도록 만든다.

decision_function() 메서드로 z1~z7까지의 값을 구한 다음 소프트맥스 함수를 사용하여 확률로 바꾸는 과정

# z1부터 z7의 값
decision = lr.decision_function(test_scaled[:5])
print(np.round(decision, decimals=2))

# 사이파이는 소프트맥스 함수도 제공
from scipy.special import softmax
proba = softmax(decision, axis=1)
print(np.round(proba, decimals=3))

04-2 (확률적 경사 하강법)

경사 하강법 알고리즘을 이해하는 단원

확률적 경사 하강법에서 훈련 세트를 한 번 모두 사용하는 과정을 에포크라고 부른다.

1개씩 샘플을 선택하는 확률적 경사 하강법, 여러 개씩 꺼내는 미니배치 경사 하강법, 몽땅 꺼내는 배치 경사 하강법이 있다.

손실함수는 어떤 문제에서 머신러닝 알고리즘이 얼마나 엉터리인지를 측정하는 기준이다. 그렇기에 작을수록 좋다.

로지스틱 손실 함수는 (예측)X(정답 혹은 타깃)인데 타깃이 1인 경우에는 곱한 후 음수로 변환해주면 되지만 0인 경우에는 예측에 1을 곱한 후 1에서 뺀 값을 음수로 바꿔주면 된다. 예측이 1에 가까울수록 예측과 타깃의 곱의 음수는 점점 작아진다. 여기에서 예측 확률에 로그 함수를 적용하면 더 좋은데 예측 확률의 범위가 0~1 사이인데 로그 함수는 이 사이에서 음수가 되므로 최종 손실 값은 양수가 된다. 손실이 양수가되면 이해하기 더 쉽고 로그 함수는 0에 가까울수록 아주 큰 음수가 되기 때문에 손실을 아주 크게 만들어 모델에 영향을 미칠 수 있다. 이 손실함수를 로지스틱 손실 함수 또는 이진 크로스엔트로피 손실 함수라고 부른다.

import pandas as pd
fish = pd.read_csv('https://bit.ly/fish_csv_data')

# Species 열을 제외한 나머지 5개는 입력 데이터로 사용
fish_input = fish[['Weight','Length','Diagonal','Height','Width']]
fish_target = fish['Species']

# 훈련 세트와 테스트 세트로 나누기
from sklearn.model_selection import train_test_split
train_input, test_input, train_target, test_target = train_test_split(
    fish_input, fish_target, random_state=42)
    
# 전처리
from sklearn.preprocessing import StandardScaler
ss = StandardScaler()
ss.fit(train_input)
train_scaled = ss.transform(train_input)
test_scaled = ss.transform(test_input)

# 사이킷런에서 확률적 경사 하강법을 제공하는 대표적인 분류용 클래스는 SGDClassifier이다.
from sklearn.linear_model import SGDClassifier

# SGDClassifier의 객체를 만들 때 2개의 매개변수 지정
# loss는 손실함수의 종류를 지정
# max_iter는 수행할 에포크 횟수 지정
sc = SGDClassifier(loss='log_loss', max_iter=10, random_state=42)
sc.fit(train_scaled, train_target)
print(sc.score(train_scaled, train_target))
print(sc.score(test_scaled, test_target))
# 출력된 훈련 세트와 테스트 세트 정확도가 낮다. 지정한 반복 횟쉬 10번이 부족한 것으로 보임

# partial_fit() 메서드는 1 에포크씩 이어서 훈련가능
sc.partial_fit(train_scaled, train_target)
print(sc.score(train_scaled, train_target))
print(sc.score(test_scaled, test_target))

# 에포크마다 훈련세트와 테스트 세트에 대한 점수를 기록하기 위해 2개의 리스트 준비
sc.partial_fit(train_scaled, train_target)
print(sc.score(train_scaled, train_target))
print(sc.score(test_scaled, test_target))

# 300번의 에포크 동안 훈련을 반복하여 진행
for _ in range(0,300):
  sc.partial_fit(train_scaled, train_target, classes=classes)
  train_score.append(sc.score(train_scaled, train_target))
  test_score.append(sc.score(test_scaled, test_target))
  
# 300번의 에포크 동안 기록한 훈련 세트와 테스트 세트의 점수를 그래프로 표현
import matplotlib.pyplot as plt
plt.plot(train_score)
plt.plot(test_score)
plt.xlabel('epoch')
plt.ylabel('accuracy')
plt.show()
# 약 100번 정도의 에포크가 적절한 반복 횟수로 보임
# 훈련 세트와 테스트 세트의 차이가 크지 않고 과소적합도 아니기에

# 반복 횟수를 100에 맞추고 모델을 훈련 시킨 후 최종적으로 훈련 세트와 테스트 세트에서 점수 출력
sc = SGDClassifier(loss='log_loss', max_iter=100, tol=None, random_state=42)
sc.fit(train_scaled, train_target)
print(sc.score(train_scaled, train_target))
print(sc.score(test_scaled, test_target))

300번의 에포크 동안 기록된 점수 그래프

숙제 (확인문제 2번 풀고 설명하기)

답은 1번이다. 로지스틱 회귀가 이진 분류에서 확률을 출력하기 위해서는 선형 방정식의 결과를 0과 1사이의 값으로 나타내기 위하여 시그모이드 함수를 사용한다.

[혼공머신] 2주차

해야지11 — Sun, 13 Jul 2025 07:20:33 +0900

03-1 (k-최근접 이웃 회귀)

분류에 이어 회귀에 대해서 알려주고 있다.
k-최근접 이웃 회귀란 가장 가까웃 이웃 샘플들을 찾고 그 샘플들의 평균하여 예측으로 삼는다.
결정계수는 대표적인 회귀 문제의 성능 측정 도구로 1에 가까울수록 좋고 0에 가까울수록 성능이 나쁜 모델이다.
과대적합은 모델의 훈련 세트 성능이 테스트 세트 성능보다 훨씬 높을 때 일어나고 과소적합은 과대적합과는 반대로 훈련 세트와 테스트 세트 성능이 모두 동일하게 낮거나 테스트 세트 성능이 오히려 더 높을 때 일어난다.

# 결정 계수 구하기
from sklearn.neighbors import KNeighborsRegressor
knr = KNeighborsRegressor()
knr.fit(train_input, train_target)
print(knr.score(test_input, test_target))

from sklearn.metrics import mean_absolute_error
# 테스트 세트에 대한 예측
test_prediction = knr.predict(test_input)
# 테스트 세트에 대한 평균 절댓값 오차를 계산
mae = mean_absolute_error(test_target, test_prediction)
print(mae)

# 과대적합 vs 과소적합
print(knr.score(train_input, train_target))

# k 조정 후 조정된 값으로 학습
knr.n_neighbors = 3
knr.fit(train_input, train_target)
print(knr.score(train_input, train_target))
print(knr.score(test_input, test_target))

# 확인 문제 4
knr = KNeighborsRegressor()
x = np.arange(5, 45).reshape(-1, 1)
for n in [1, 5, 10]:
  knr.n_neighbors = n
  knr.fit(train_input, train_target)
  prediction = knr.predict(x)

  plt.scatter(train_input, train_target)
  plt.plot(x, prediction)
  plt.title('n_neighbors = {}'.format(n))
  plt.xlabel('length')
  plt.ylabel('weight')
  plt.show()

확인문제 4 출력 그래프

03-2 (선형 회귀)

선형 회귀는 특성과 타깃 사이의 관계를 가장 잘 나타내는 선형 방정식을 찾는다.
특성이 하나면 직선 방정식이 된다.
모델 파라미터는 선형 회귀가 찾은 가중치처럼 머신러닝 모델이 특성에서 학습한 파라미터를 말한다.
다항 회귀는 다항식을 사용하여 특성과 타깃 사이의 관계를 나타낸다. 이 함수는 비선형일 수 있지만 여전히 선형 회귀로 표현할 수 있다.
선형 회귀의 선형은 입력과 타깃 사이의 관계가 아니라 가중치(계수)와 타깃 사이의 관계를 의미한다.

# 분류
from sklearn.model_selection import train_test_split
train_input, test_input, train_target, test_target = train_test_split(perch_length, perch_weight, random_state=42)
train_input = train_input.reshape(-1,1)
test_input = test_input.reshape(-1,1)

# k-최근접 이웃 회귀 학습
from sklearn.neighbors import KNeighborsRegressor
knr = KNeighborsRegressor(n_neighbors=3)
knr.fit(train_input, train_target)

# 예측
print(knr.predict([[50]]))

# 시각화
import matplotlib.pyplot as plt
distances, indexes = knr.kneighbors([[50]])
plt.scatter(train_input, train_target)
plt.scatter(train_input[indexes], train_target[indexes], marker='D')
plt.scatter(50,1033,marker='^')
plt.xlabel('length')
plt.ylabel('weight')
plt.show()

# 50이든 100이든 같은 값으로 출력됨.
# 왜냐하면 주어진 데이터에선 50이후의 샘플이 없기 때문에 50 이후는 전부 최근접 샘플이 같음

# 선형 회귀 사용
from sklearn.linear_model import LinearRegression
lr = LinearRegression()
lr.fit(train_input, train_target)
print(lr.predict([[50]]))

# 찾은 모델 파라미터 출력
print(lr.coef_, lr.intercept_)

# 시각화
plt.scatter(train_input, train_target)
plt.plot([15,50],[15*lr.coef_+lr.intercept_, 50*lr.coef_+lr.intercept_])
plt.scatter(50, 1241.8, marker='^')
plt.xlabel('length')
plt.ylabel('weight')
plt.show()

# 다항 회귀 데이터 준비 및 데이터셋 확인
train_poly = np.column_stack((train_input**2, train_input))
test_poly = np.column_stack((test_input**2, test_input))
print(train_poly.shape, test_poly.shape)

# 다항 회귀 사용
lr = LinearRegression()
lr.fit(train_poly, train_target)
print(lr.predict([[50**2,50]]))
print(lr.coef_, lr.intercept_)

# 시각화
point = np.arange(15,50)
plt.scatter(train_input, train_target)
plt.plot(point, 1.01*point**2 - 21.6*point +116.05)
plt.scatter(50, 1574, marker='^')
plt.xlabel('length')
plt.ylabel('weight')
plt.show()

# 훈련 세트와 데이터 세트의 결정계수 평가
print(lr.score(train_poly, train_target))
print(lr.score(test_poly, test_target))

03-3 (특성 공학과 규제)

다중 회귀는 여러 개의 특성을 사용하는 회귀 모델, 특성이 많으면 선형 모델은 강력한 성능을 발휘
특성 공학은 주어진 특성을 조합하여 새로운 특성을 만드는 일련의 작업 과정
릿지는 규제가 있는 선형 회귀 모델 중 하나이며 선형 모델의 계수를 작게 만들어 과대적합을 완화시킨다. 릿지는 비교적 효과가 좋아 널리 사용하는 규제 방법
라쏘는 또 다른 규제가 있는 선형 회귀 모델이며 릿지와 달리 계수 값ㅇ르 아예 0으로 만들 수도 있다.
하이퍼파라미터는 머신러닝 알고리즘이 학습하지 않는 파라미터이다. 이런 파라미터는 사람이 사전에 지정해야 한다. 대표적으로 릿지와 라쏘의 규제 강도 alpha 파라미터이다.
변환기는 사이킷런에서 특성을 만들거나 전처리하기 위한 다양한 클래스를 제공
규제는 머신러닝 모델이 훈련 세트를 너무 과도하게 학습하지 못하도록 훼방하는 것

# 사이킷런의 변환기
from sklearn.preprocessing import PolynomialFeatures

# 2개의 특성 2와 3으로 이루어진 샘플을 적용
poly = PolynomialFeatures()
poly.fit([[2,3]])
print(poly.transform([[2,3]]))

# include_bias = False로 지정하지 않아도 사이킷런 모델은 자동으로 특성에 추가된 절편 항을 무시

# 아래 코드는 명시적으로 지정
poly = PolynomialFeatures(include_bias=False)
poly.fit([[2,3]])
print(poly.transform([[2,3]]))

# 다중 회귀 모델 훈련
from sklearn.linear_model import LinearRegression
lr = LinearRegression()
lr.fit(train_poly, train_target)
print(lr.score(train_poly, train_target))
print(lr.score(test_poly, test_target))

# 5제곱까지 특성을 만들어 출력 (degree=5)
poly = PolynomialFeatures(degree=5, include_bias=False)
poly.fit(train_input)
train_poly = poly.transform(train_input)
test_poly = poly.transform(test_input)
print(train_poly.shape)

# 출력하면 55개의 특성이 만들어졌음을 알 수 있다.
# 55개의 특성을 가지고 선형 회귀 모델 훈련
lr.fit(train_poly, train_target)
print(lr.score(train_poly, train_target))
print(lr.score(test_poly, test_target))

# 표준점수로 바꾸는 변환기
from sklearn.preprocessing import StandardScaler
ss = StandardScaler()
ss.fit(train_poly)
train_scaled = ss.transform(train_poly)
test_scaled = ss.transform(test_poly)

# 릿지 회귀
from sklearn.linear_model import Ridge
ridge = Ridge()
ridge.fit(train_scaled, train_target)
print(ridge.score(train_scaled, train_target))

import matplotlib.pyplot as plt
train_score = []
test_score = []

alpha_list = [0.001, 0.01, 0.1, 1, 10, 100]
for alpha in alpha_list:
  ridge = Ridge(alpha=alpha)
  ridge.fit(train_scaled, train_target)
  train_score.append(ridge.score(train_scaled, train_target))
  test_score.append(ridge.score(test_scaled, test_target))

plt.plot(alpha_list, train_score)
plt.plot(alpha_list, test_score)
plt.xscale('log')
plt.xlabel('alpha')
plt.ylabel('R^2')
plt.show()

# alpha=0.1일 때 두 그래프가 가장 가깝고 테스트 세트의 점수가 가장 높기에 0.1로 최종 모델 훈련
ridge = Ridge(alpha=0.1)
ridge.fit(train_scaled, train_target)
print(ridge.score(train_scaled, train_target))
print(ridge.score(test_scaled, test_target))

# 라쏘 회귀
from sklearn.linear_model import Lasso
lasso = Lasso()
lasso.fit(train_scaled, train_target)
print(lasso.score(train_scaled, train_target))
print(lasso.score(test_scaled, test_target))
train_score = []
test_score = []

alpha_list = [0.001, 0.01, 0.1, 1, 10, 100]
for alpha in alpha_list:
    # 라쏘 모델을 만듭니다
    lasso = Lasso(alpha=alpha, max_iter=10000)
    # 라쏘 모델을 훈련합니다
    lasso.fit(train_scaled, train_target)
    # 훈련 점수와 테스트 점수를 저장합니다
    train_score.append(lasso.score(train_scaled, train_target))
    test_score.append(lasso.score(test_scaled, test_target))
plt.plot(alpha_list, train_score)
plt.plot(alpha_list, test_score)
plt.xscale('log')
plt.xlabel('alpha')
plt.ylabel('R^2')
plt.show()

# 라쏘 모델에서 최적의 alpha 값은 10이기에 10으로 모델 훈련
lasso = Lasso(alpha=10)
lasso.fit(train_scaled, train_target)
print(lasso.score(train_scaled, train_target))
print(lasso.score(test_scaled, test_target))

# 라쏘 모델은 계수 값을 아예 0으로 만들 수 있다.
print(np.sum(lasso.coef_ == 0))

[혼공머신] 1주차

해야지11 — Sun, 6 Jul 2025 16:29:43 +0900

혼공학습단이라는 프로그램이 진도와 숙제를 통해 꾸준히 공부하게 하여 나에게 큰 도움을 줄 수 있을 것 같아 신청하게 되었다.

앞으로 열심히 머신러닝과 딥러닝을 공부하여 기반을 튼튼하게 다질 것이다.

01- 3

k-최근접 이웃 알고리즘을 이용하여 도미와 빙어를 분류하는 머신러닝 모델 훈련

도미 데이터 와 도미 데이터를 산점도로 표현

빙어 데이터와 빙어 데이터를 산점도로 표현

도미와 빙어 데이터를 하나의 객체에 산점도로 표현, zip()함수를 이용해 2차원 리스트 만듦, 정답데이터 생성

k-최근접 이웃 알고리즘 구현

함수:

zip() - 나열된 리스트 각각에서 하나씩 원소를 꺼내 반환

scikit-learn

fit() - 사이킷런 모델을 훈련할 때 사용하는 메서드
predict() - 사이킷런 모델을 훈련하고 예측할 때 사용하는 메서드
score() - 훈련된 사이킷런 모델의 성능을 측정

02- 1

머신러닝 알고리즘의 성능을 평가하려면 훈련 데이터와 평가에 사용할 데이터가 각각 달라야 한다.

zip()함수 이용, 슬라이싱

넘파이 변환, 넘파이 배열 크기 확인

랜덤으로 추출, 배열 인덱싱 이용, 시각화

정확도 확인, 테스트 세트의 예측결과와 실제 타깃을 확인

용어:

훈련데이터 - 입력(데이터), 타킷(정답)

지도 학습 - 타깃(정답)이 있어 알고리즘이 정답을 맞히는 것을 학습

비지도 학습 - 타깃 없이 입력 데이터만 사용, 데이터를 잘 파악하거나 변형하는데 도움을 줌

테스트 세트 - 평가에 사용하는 데이터, 전체 데-이터에서 에서 20~30% 정도 사용

훈련 세트 - 훈련에 사용되는 데이터

샘플링 편향 - 훈련 세트와 테스트 세트에 샘플이 골고루 섞여 있지 않으면 샘플링이 한쪽으로 치우쳤다는 의미

함수:

numpy

seed() - 넘파이에서 난수를 생성하기 위한 정수 초깃값을 지정, 초깃값이 같은면 동일한 난수 추출 가능
arange() - 일정한 간격의 정수 또는 실수 배열을 만듦
shuffle() - 주어진 배열을 랜덤하게 섞음, 다차원 배열일 경우 첫 번째 축(행)에 대해서만 섞음

02- 2

데이터의 스케일이 다르다면 전처리를 해야 함

훈련데이터 설정

훈련 세트, 데이터 세트 크기 확인 및 train_test_split() 함수 이용

새로운 샘플 구분 및 확인

kn.kneighbors()를 통해 가까운 5개의 샘플 확인

기준(범위)를 동일하게 맞춤

표준점수 방법으로 전처리 (새로운 샘플에는 적용 안함)

새로운 샘플에도 동일한 전처리 방법 사용하여 시각화 후 모델 평가 및 새로운 샘플에 대한 모델의 예측 출력

특성을 표준점수 방법을 전처리 후 kneighbors() 함수로 가장 가까운 샘플 5개 확인

용어:

스케일 - 두 특성의 값이 놓인 범위가 매우 다를 때 두 특성의 스케일이 다르다고 함

데이터 전처리 - 샘플 간의 거리에 영향을 많이 받으므로 특성값을 일정한 기준으로 맞춰주는 작업(예: 표준점수)

브로드캐스팅 - 크기가 다른 넘파이 배열에서 자동을 사칙 연산을 모든행이나 열로 확장하여 수행

함수:

numpy

column_stack() - 전달받은 리스트를 일렬로 세운 다음 차례대로 나란히 연결

scikit-learn

train_test_split() - 훈련 데이터를 훈련 세트와 테스트 세트로 나누는 함수
kneighbors() - k-최근접 이웃 객체의 메서드, 입력한 데이터에 가장 가까운 이웃을 찾아 거리와 이웃 샘플의 인덱스를 반환