• 행렬A 와 (1, 1)벡터를 계산하게되면 (8, 8)이라는 벡터가 나옴.
• 이때 8은 Eigenvalues인 고윳값이되고, (1, 1)은 Eigenvector인 고유벡터가 나옴.
• (1, 1)라는 벡터가있을때, (8, 8)벡터를 보고 실수 k배를 한것을 복잡한 연산없이 알아낼수 있음.

왼쪽 식의 내적을 하는 연산은 곱셈과 덧셈을 합쳐 6번을 하게 되지만 오른쪽의 식은 2번의 연산만을 하게 됨.

고유벡터와 고유값의 장점

• 중요한 키가 되는 연산이며 계산상의 장점
• 딥러닝의병렬 연산, 3D게임의 회전행렬연산도 내부적으로 행렬과 벡터에 대한 곱으로 이루어져있어 고유값과 고유벡터를 이용하면 실질적으로 계산이 빨라짐
• 영벡터는 고유값이나 고유벡터가 될 수 없다.(상수배를 할때 어떠한값도 고유값,고유벡터가 되어버리기때문)

PyPI에서 가져오지만 python3.0 이상만 가능

이것은 Ubuntu 및 Fedora와 같은 최신 Linux 배포판에서 가장 간단한(단일 명령) 설치 방법입니다.

pip3 설치 labelImg
레이블Img
labelImg [IMAGE_PATH] [사전 정의된 클래스 파일]

Linux/Ubuntu/Mac에는 Python 2.6 이상이 필요하며 PyQt 4.8 에서 테스트되었습니다 . 그러나 Python 3 이상 및 PyQt5 를 강력히 권장합니다.

우분투 리눅스

파이썬 3 + Qt5

sudo apt-get 설치 pyqt5-dev-tools
sudo pip3 install -r 요구 사항/요구 사항-linux-python3.txt
qt5py3 만들기
python3 labelImg.py
python3 labelImg.py [IMAGE_PATH] [미리 정의된 클래스 파일]

맥 OS

파이썬 3 + Qt5

brew install qt   # Homebrew로 qt-5.xx 설치
양조 설치 libxml2

또는 핍을 사용하여

pip3 install pyqt5 lxml # pip로 qt 및 lxml 설치

qt5py3 만들기
python3 labelImg.py
python3 labelImg.py [IMAGE_PATH] [미리 정의된 클래스 파일]

Python 3 Virtualenv(권장)

Virtualenv는 많은 QT/Python 버전 문제를 피할 수 있습니다.

양조 설치 python3
pip3 설치 pipenv
pipenv 실행 pip install pyqt5==5.15.2 lxml
pipenv 실행 make qt5py3
pipenv 실행 python3 labelImg.py
[선택 사항] rm -rf 빌드 dist ; 파이썬 setup.py py2app -A ; mv " dist/labelImg.app " /응용 프로그램

참고: 마지막 명령은 /Applications 폴더에 새로운 SVG 아이콘이 있는 멋진 .app 파일을 제공합니다. build-tools/build-for-macos.sh 스크립트 사용을 고려할 수 있습니다.

Python , PyQt5 를 설치 하고 lxml 을 설치 합니다.

cmd를 열고 labelImg 디렉토리 로 이동하십시오.

pyrcc4 -o libs/resources.py 리소스.qrc
pyqt5의 경우 pyrcc5 -o libs/resources.py resources.qrc

파이썬 레이블Img.py
파이썬 labelImg.py [IMAGE_PATH] [사전 정의된 클래스 파일]

윈도우 + 아나콘다

Anaconda (Python 3+) 다운로드 및 설치

Anaconda Prompt를 열고 labelImg 디렉토리 로 이동하십시오.

콘다 설치 pyqt=5
conda install -c 아나콘다 lxml
pyrcc5 -o libs/resources.py 자원.qrc
파이썬 레이블Img.py
파이썬 labelImg.py [IMAGE_PATH] [사전 정의된 클래스 파일]

도커 사용

도커 실행 -it \--사용자 $( 아이디 
-u ) \
-e DISPLAY=유닉스 $DISPLAY \
--workdir= $( pwd ) \
--volume= " /home/ $USER :/home/ $USER " \
--volume= " /etc/group:/etc/group:ro " \
--volume= " /etc/passwd:/etc/passwd:ro " \
--volume= " /etc/shadow:/etc/shadow:ro " \
--volume= " /etc/sudoers.d:/etc/sudoers.d:ro " \
-v /tmp/.X11-unix:/tmp/.X11-unix \
쭈탈린/py2qt4

qt4py2 만들기 ; ./labelImg.py

reference : https://github.com/tzutalin/labelImg

labelImg 단축키

Xcode Command Line Tools 설치

% xcode-select --install

Miniforge

% chmod +x ~/Downloads/Miniforge3-MacOSX-arm64.sh
% sh ~/Downloads/Miniforge3-MacOSX-arm64.sh
% source ~/miniforge3/bin/activate

애플 사이트에서는 위와 같은 방법으로 Miniforge를 설치하도록 하고 있는데, 아래 11.0 이하처럼 brew를 사용해도 무방하다.

가상환경 만들기

Conda를 이용한다는 것은 가상환경을 이용한다는 것이니, Tensorflow를 설치할 가상환경을 만들어주자.

% conda create --name DL-tf python=3.8
% conda activate DL-tf

TensorFlow Dependencies 설치

# For TensorFlow v2.5
% conda install -c apple tensorflow-deps==2.5.0

# For TensorFlow v2.6 
% conda install -c apple tensorflow-deps==2.6.0

TensorFlow & Plugin 설치

% python -m pip install tensorflow-macos
% python -m pip install tensorflow-metal

M1 맥에 TensorFlow 설치하기 (macOS 11.0 이하)

Xcode Command Line Tools 설치

% xcode-select --install

Brew 설치

패키지 관리자 Brew를 설치한다!

% /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

Miniforge 설치

방금 설치한 Brew를 이용해 Miniforge를 설치한다.

Miniforge는 맥용 arm64, 즉 M1 맥을 지원하고 있는 conda라고 보면 된다. Anaconda 등은 M1 맥을 지원하고 있지 않다. 사용 자체는 되는데, Rosetta 2를 통한 x64 패키지들을 설치한다.

% brew install cask
% brew install --cask miniforge
% conda init zsh

이렇게 설치한 miniforge의 설치 경로는 다음과 같다.

/opt/homebrew/Caskroom/miniforge

가상환경 만들기

Conda를 이용한다는 것은 가상환경을 이용한다는 것이니, Tensorflow를 설치할 가상환경을 만들어주자.

% conda create --name DL-tf python=3.8
% conda activate DL-tf

–name 뒤의 DL-tf는 원하는 대로 정해도 좋다.

패키지 설치

이후 tensorflow 설치에 필요한 패키지를 설치한다.

 % conda install absl-py astunparse gast google-pasta grpcio h5py=2.10.0 ipython keras-preprocessing numpy=1.19.5 opt_einsum pip=20.2.4 protobuf python-flatbuffers scipy tensorboard tensorflow-estimator termcolor typeguard typing_extensions wheel wrapt

Tensorflow 설치

pip를 이용해 tensorflow를 설치한다.

% pip install --upgrade --force --no-dependencies https://github.com/apple/tensorflow_macos/releases/download/v0.1alpha3/tensorflow_macos-0.1a3-cp38-cp38-macosx_11_0_arm64.whl https://github.com/apple/tensorflow_macos/releases/download/v0.1alpha3/tensorflow_addons_macos-0.1a3-cp38-cp38-macosx_11_0_arm64.whl

설치 확인

% conda activate DL-tf
% python3 -c "import tensorflow as tf; print(tf.reduce_sum(tf.random.normal([1000, 1000])))"

결과가 tf.Tensor(-771.1804, shape=(), dtype=float32) 형태로 나오면 import 하고 실행하는데 성공한 것이다.

Reference

• https://github.com/apple/tensorflow_macos/issues/153

일반적으로 네트워킹의 구조는 몇 가지 아키텍처가 지배하고 있다. 고성능 라우터주변에 모여든 분산(Distributed) 백본은 전통적인 라우터 중심의 백본이다. 이 백본 네트워크 아키텍처는 각 층별 워크그룹을 구성할 수 있는 방안으로 이용되기도 했다. 그러나 분산 백본은 각 층마다 라우터와 서버를 설치해야 함으로 과다한 비용을 유발할 수 있다. 이러한 단점을 극복하기 위해 출현한 것이 콜랩스드 백본, 그물망 구조의 백본, 스위칭 백본이다.

분산(Distributed) 백본

초창기 네트워크를 구축하는 방식의 대부분은 분산 백본 형태였다. 공유 허브가 각 층에 설치됐고, 라우터 중심의 백본은 각 층과 층을 연결하는 역할을 수행했다. 예를 들어, 10Mbps 이더넷을 공유 허브와 라우터를 묶고 이들을 다시 대형 라우터로 연계해 WAN으로 연결하는 형태가 바로 그것이다.

각각의 LAN 세그먼트는 분리된 서브 네트워크로 구성된다. 세그먼트 사이의 모든 패킷은 최소 한개의 라우터를 통과해야만 하는 불편함이 있다. 따라서 서버는 빌딩의 각 층에 흩어져 사용자가 서버를 액세스할 수 있도록 구성된다.

분산 백본 방식의 장점은 여러 개의 라우터가 존재하기 때문에 특정 라우터의 장애가 발생해도 다른 라우터를 이용해 네트워킹이 가능하다는 것이다. 때문에 특정 사용자를 제외한 사용자들은 네트워크를 이용하는데 어려움이 없다. 그러나 이러한 형태의 네트워크는 전체적인 시스템의 성능과 관리가 매우 어렵다.

즉, 네트워크 구조상 개별 세그먼트간 네트워킹을 실시할 때 각 세그먼트의 서버의 데이터를 입출력할 때 두 개 이상의 라우터 홉을 거처야 하기 때문에 트래픽 전송에 많은 지연시간이 소요된다. - 이러한 라우터의 지연 문제를 해결하고자 현재 3계층 스위치가 생겨 라우터의 기능을 일부 담당하여 트래픽 정체 현상을 해소시킨다. - 그리고 개별 층마다 시스템이 구성돼 있어 네트워크 관리자가 이를 관리하기가 어려운 단점이 있다. 콜랩스드(Collapsed) 백본

분산 형태 백본의 단점을 보안하기 위해 등장한 것이 콜랩스드 백본이다. 즉, 각 층에 위치한 허브는 네트워크 센터의 스위치에 접속을 하고 스위치는 라우터에 접속하는 형태를 취함으로써 네트워크의 속도와 설치 운용의 부담을 줄인 것이 콜랩스드 백본 네트워크다. - 현재 2계층 스위치가 주종을 이루나 3계층 스위치 사용도 점차 늘어나는 추세다. - 또한 서버와 클라이언트간의 접속이 한 홉 이상 떨어져 있지 않기 때문에 트래픽의 레이턴시 비율을 낮출 수 있는 장점을 제공한다. 그러나 콜랩스드 백본 역시 단점이 없는 것은 아니다. 설치된 모든 스위칭 허브는 단일 라우터에 접속 되므로 라우터의 병목 현상을 제거할 방법이 없다는 것이다.

이 백본은 네트워크의 융통성과 효과적인 관리를 위해 스위치 허브를 콜랩스드 백본에 포함시킴으로써 각 층의 네트워크 세그먼트를 통합할 수 있다. 이러한 스위칭 허브의 설치는 허브와 라우터를 연결할 때 홉 수를 줄일 수 있는 기능을 제공한다.

콜랩스드 백본 네트워크 구조는 서버가 네트워크 성능에 영향을 주지 않고 관리를 할 수 있도록 하나의 서버팜을 이용할 수 있는 장점이 있다.

일반적으로 콜랩스드 백본은 빌딩에서 사용하는 것이 이상적이지만, 여러 빌딩과 빌딩을 연결한 캠퍼스 네트워크에서는 비효율적이다. 이는 백본과 백본을 단일 네트워크 형태로 케이블링하고 백본 라우터들을 상호 연동해야 하는 불편함과 시스템의 성능과 관리, 관다한 투자 비용 등의 문제점들이 나타나기 때문이다.

그물망 백본

폭넓은 WAN 범주에서 사용하는 그물망 백본 아키텍처는 케이블링이 끝나고 나면, 로컬 대역폭사용은 무료이지만, 리모트 지역과 접속되는 지역은 대역폭을 제공하는 서비스 프로바이더에게 회선을 임대해 사용해야 한다. 일반적으로 WAN 규모의 네트워크는 몇 개의 그물망 형태로 구축된다.

각 지역의 네트워크와 네트워크는 라우터로 연결돼 있다. 흔히 이들 백본을 연결해 주는 매개체는 포인트 투 포인트 방식의 전용 회선을 사용하는 방법과 최근 56Kbps나 ISDN, 또는 LAN 릴레이, X.25 등을 이용해 지역과 지역을 접속한 네트워크를 운용하고 있다.

특히, LAN 릴레이는 WAN을 연결하는 중요한 수단으로 자리잡고 있다. LAN 릴레이는 높은 쓰루풋을 제공하며 전용회선 보다 저렴하다는 장점을 제공한다. 이와 함께 LAN 릴레이의 가상회선은 다수의 라우터 트렁크에 단일 고속 접속을 허용해 시스템 성능을 향상할 수 있다.

스위치 백본

최근 LAN 백본으로 등장한 것이 고성능의 대형 스위치다. 스위치는 저렴한 가격과 다양한 포트 수를 제공하고, 가상LAN, 빠른 속도를 제공한다는 점에서 백본으로써 손색이 없는 장비로 등장했다. 스위치 백본은 개별층의 스위치를 데이터 센터의 스위치와 접속하는형태와 워크그룹 단위의 네트워크를 백본 스위치에 접속하는 방법으로 네트워크를 구성할 수 있다.

워크그룹의 경우, 그룹내 서버가 위치하고 있어 레이턴시비율과 트래픽 처리 속도가 빠르게 구현될 수 있고, 워크그룹 사이의 네트워킹 속도도 빠르게 접속할 수 있는 등의 장점을 제공한다. 최근 스위치는 라우터의 기능까지 수용함으로써(3계층 스위치; 멀티레이어 스위치) 가격과 속도, 성능을 향상했다는 점에서 사용자들의 관심을 제공한다.

그러나 백본 스위치에서 라우터가 전혀 필요 없는 것은 아니다. 즉, 외부 네트워크와 접속을 위해서는 어떤 형태의 라우터도 수용해야 한다. 예를 들어, 지역과 지역을 연결할 때 ISDN 라우터나 중소형 라우터를 장착해야 한다. 이러한 라우터의 장착은 과거의 대용량을 라우터에 비해 매우 저렴한 비용으로 도입이 가능하다.

• Domain (정의역) : 함수의 입력에 들어가는 모든 집합.

• Co-domain(공역) : target함수의 출력값 output의 집합.

• Image : 함수의 output.

• range(치역) : 수가 취하는 값 전체의 집합 공역에 대한 y의 부분집합.

• note : x 는 유니크하게 정의된다.

쉽게 말해 자판기가 있다.(모두 아는 자판기)

• 누르는 버튼 : 정의역
• 눌렀을 때 나오는 음료수 : 치역
• 자판기 안에 음료수 자체는 : 공역

• 왼쪽과 오른쪽식이 성립했을시 선형변환. 즉, 선형결합이 가능하면 선형변환이 가능합니다.
• 즉, 상수배를 해서 변환을 하던, 변환을 해서 상수배를 하던 그값이 같으면 선형변환이라고 할 수 있습니다.

• 행렬은 분배법칙이 가능하므로 왼쪽 과 오른쪽 식이 같아 선형변환이 가능합니다.

선형변환의 요약

• 변환은 곧 함수다.

• 어떤 값을 집어넣어서 2차원 이상 벡터가 나왔다 = 벡터변환함수

• 실수배를 해서 변환을 하던, 변환을 해서 실수배를 하던 그값이 같습니다.

  • 즉, 실수배가 변환의 영향을 주지않고 변환을 보존

• 선형변환이 가능하지 않을 때는 원소들끼리 곱해지거나 벡터에 지수배가 존재할때는 가능하지않다.

• 선형변환이 되지않는 함수에 넣게되면 벡터가 아닌 엉뚱한 것 이 나오게됨.

선형변환 정리

• 선형변환은 선형 결합을 보존하는 두 벡터 공간 사이의 함수이며, 벡터를 벡터로 변환해주는 것입니다.
• 간단하게 좌표평면 위에 점 두개가 있다고 가정했을때, 두점을 이동시키는게 선형변환.
• '선형'이라는 규칙을 지키며V 공간상의 벡터를 ,W 공간상의 벡터로 바꿔주는 역할을 합니다
• 선형결합이 되어야 선형변환이 가능하다.
• 벡터가 어떤 함수를 통해 또 다른벡터가나오는데 크기나 방향이 다른 벡터가 나오는것

ex) 함수 f가 임의의 두 벡터 x,y 와 실수 k에 대하여

1. f(k x) =k f(x)
2. f(x+y) = f(x) + f(y)만족시키면. 선형변환 이라고 합니다.

• 모든 선들은 변환이후에도 휘지않고 직선이어야 하며, 원점은 변환이후에도 여전히 원점이야 한다.
• 선형변환이라면 격자 라인들이 변형 이후에도 여전히 “평행”하고 “동일한간격”으로 있어야한다.

지도학습과 달리 training data로 정답(label)이 없는 데이터가 주어지는 학습방법을 말합니다.

비지도학습은 주어진 데이터가 어떻게 구성되어 있는지 스스로 알아내는 방법이라고도 말할 수 있습니다. 아무도 정답을 알려주지 않은 채 오로지 데이터셋의 특징(feature) 및 패턴을 기반으로 모델 스스로가 판단하는 것이니까요.

이렇게 몯느 데이터셋에 각각에 대한 정보가 명시되어 있으면 참 좋겠지만 ,그렇지 않을 경우가 대부분일뿐더러 라벨링이 되어 있는 데이터셋을 마련하기 위해서는 적지 않은 인적 자원이 소모됩니다.

결국 어떤 이미지가 고양이 사진이다, 강아지 사진이다라는 정답을 매기는 과정은 이간이 수행해야 하기 때문입니다.

이 문제를 해결하기 위해, 라벨링이 되어 있지 않은 데이터들 내에서 비슷한 특징이나 패턴을 가진 데이터들끼리 군집화한 후, 새로운 데이터가 어떤 군집에 속하는지를 추론하는 비지도학습과 같은 방법론이 제시되었어요.

비지도학습의 대표적인 예시로는 군집화(클러스터링, clustering) 가 있지만, 비지도학습이라는 용어는 정답이 없는 데이터를 이용한 학습 전체를 포괄하는 용어이기 때문에 클러스터링 외에도 차원 축소(dimensionality reduction) 및 이를 이용한 데이터 시각화, 생성 모델(generative model) 등 다양한 task를 포괄하는 개념입니다.

러스터링의 대표적인 알고리즘인 K-means와 DBSCAN 알고리즘, 차원 축소의 대표적인 방법인 PCA(Principal Component Analysis), T-SNE에 대해서 알아보도록 하겠습니다.

클러스터링(1) K-means 지도학습 상황과 달리, 비지도학습이 필요한 상황에서는 지도학습 때 당연히 주어지던 몇 가지가 생략되어 있습니다.

선은 데이터 X가 무엇인지에 대한 정답(label) y가 없습니다. 또 없는 게 있다면, y가 될 수 있는 분류 기준(클래스 또는 카테고리)도 없다고 할 수 있겠네요.

군집화(클러스터링)이란 그렇게 명확한 분류 기준이 없는 상황에서도 데이터들을 분석하여 가까운(또는 유사한) 것들끼리 묶어 주는 작업입니다. 이를 통해서 개별적인 데이터들을 몇 개의 그룹으로 추상화하여 새로운 의미를 발견해 나갈 수 있게 되겠습니다.

그런데 명확한 분류 기준이 없다면 무엇을 기준으로 묶어낼 수 있을까요?

가장 쉽게 생각해 볼 수 있는 방법은 임의로 k개의 그룹으로 뭉쳐 보라고 하는 것이겠군요.

단 아무렇게나 뭉치진 말고 k개의 기준점을 중심으로 가장 가까운 데이터들을 뭉쳐 보는 방식으로요.

k_means알고리즘은 k 값이 주어져 있을 떄, 주어진 데이터들을 k 개의 클러스터로 묶는 알고리즘으로 대표적인 크러스터링 기법 중 하나입니다.

밑에 코드를 통해 K-means알고리즘이 어떻게 동작하는지 보겠습니다.

%matplotlib inline
from sklearn.datasets import make_blobs
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import random

# 중심점이 5개인 100개의 점 데이터를 무작위로 생성합니다.
points, labels = make_blobs(n_samples=100, centers=5, n_features=2, random_state=135)

print(points.shape, points[:10])  # 무작위로 생성된 점의 좌표 10개 출력
print(labels.shape, labels[:10])    # 10개의 점들이 각각 대응하는 중심점(label) 값 출력

비지도학습에는 label이 없다고 했었는데 위 코드에는 label이 등장하네요? 그렇습니다. 임의로 지정한 k개의 중심점이 새로운 label 역할을 하는 것이 K-means 의 아이디어입니다.

그리고 좌표를 그려보겠습니다.

# 축 그리기
fig = plt.figure()
ax = fig.add_subplot(1, 1, 1)

# 위에서 생성한 점 데이터들을 pandas DataFrame 형태로 변환하기
points_df = pd.DataFrame(points, columns=['X', 'Y'])
display(points_df.head())

# 점 데이터를 X-Y grid에 시각화하기
ax.scatter(points[:, 0], points[:, 1], c='black', label='random generated data')

# 축 이름을 라벨에 달고, 점 데이터 그리기
ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.legend()
ax.grid()

위와 같이 scikit-learn의 make_blob()을 활용하여 중심점이 5개인 무작위의 점 데이터 100개를 생성해 보았습니다.

한눈에 보기에도 위의 데이터들은 5개의 군집을 이루고 있는 것처럼 보이는데요, 과연 k-means 알고리즘을 적용하여 위 데이터들을 올바르게 군집화할 수 있는지 알아보겠습니다.

생성한 데이터에 K-means 알고리즘 적용

이제 K-means 알고리즘을 적용해 봅시다. 그런데, 데이터들끼리의 거리를 어떻게 측정하는 걸까요?

실은 우리는 위에서 자연스럽게 데이터를 X-Y 좌표축 위에 생성했습니다.

좌표축 위에 존재하는 데이터들 사이의 거리는 쉽게 계산해 낼 수 있죠? 피타고라스 정리를 응용하여 계산한 좌표축 사이의 두 점 사이의 직선거리를 유클리드 거리(Eucledian distance) 또는 L2 Distance라고 부릅니다.

자세한 설명은 아래 링크를 참고해 주세요.

링크 : 유클리디안 거리

• 유클리드라는 수학자가 고안해낸 이론이다.

• 최대공약수를 계산하는 유클리드 호제법으로 유명한 분이다.

• 유클리디안 거리의 다른이름으로 L2 Distance 라고도 한다.

2차원 평면에 두점이 ( x1, y1 ) 과 ( x2, y2 )로 표현되어있다고 가정한다면, 실제 이 두점간의 거리는 피타고라스 정리를 이용하여 쉽게 구할수 있다. 이것을 3차원 4차원 등등 다차원지 확장시킨것이 유클리디안 거리라고 생각하면 되겠다.

예를 들어 n 차원에 있는 두점 P와 Q가 있다고 생각하자 P = ( p1, p2, p3, p4 ,,,, pn ) Q = ( q1, q2, q3, q4 ,,,, qn ) 이 두점간의 거리를 유클리디안 거리로 표현한다면 아래 처럼 표현할수 있다.

추가적으로 유클리디안 거리 공식으로 계싼을 하면 거리의 최대값이라는 게 없어서 뭔가와 비교할 수가 없다. 그래서 이 거리를 0 ~ 1 사이의 값으로 갖도록 정규화? 하는 방법을 아래와 같이 사용하기도 한다.

유클리디안 거리 공식을 이용해 얻은 거리의 값을 Ed 라고 한다면

이렇게 표현한다면 가장 가까운 경에는 1에 가까울 것이고 멀수록 0에 가까운 값을 갖게 된다.

전체적인 K-mean 알고리즘의 순서는 다음과 같이 구성됩니다.

원하는 클러스터의 수(K)를 결정합니다. 무작위로 클러스터의 수와 같은 K개의 중심점(centroid)을 선정합니다. 이들은 각각의 클러스터를 대표합니다. 나머지 점들과 모든 중심점 간의 유클리드 거리를 계산한 후, 가장 가까운 거리를 가지는 중심점의 클러스터에 속하도록 합니다.

각 K개의 클러스터의 중심점을 재조정합니다. 특정 클러스터에 속하는 모든 점들의 평균값이 해당 클러스터 다음 iteration의 중심점이 됩니다.(이 중심점은 실제로 존재하는 데이터가 아니어도 상관없습니다.) 재조정된 중심점을 바탕으로 모든 점들과 새로 조정된 중심점 간의 유클리드 거리를 다시 계산한 후, 가장 가까운 거리를 가지는 클러스터에 해당 점을 재배정합니다. 4번과 5.번을 반복 수행합니다. 반복의 횟수는 사용자가 적절히 조절하면 되고, 특정 iteration 이상이 되면 수렴(중심점이 더 이상 바뀌지 않음)하게 됩니다.

from sklearn.cluster import KMeans

# 1), 2) 위에서 생성한 무작위 점 데이터(points)에 클러스터의 수(K)가 5인 K-means 알고리즘을 적용 
kmeans_cluster = KMeans(n_clusters=5)

# 3) ~ 6) 과정이 전부 함축되어 있는 코드입니다. points에 대하여 K가 5일 때의 K-means iteration을 수행
kmeans_cluster.fit(points)

print(type(kmeans_cluster.labels_))
print(np.shape(kmeans_cluster.labels_))
print(np.unique(kmeans_cluster.labels_))

# n 번째 클러스터 데이터를 어떤 색으로 도식할 지 결정하는 color dictionary
color_dict = {0: 'red', 1: 'blue', 2:'green', 3:'brown', 4:'indigo'} 

# 점 데이터를 X-Y grid에 시각화합니다.
fig = plt.figure()
ax = fig.add_subplot(1, 1, 1)

# K-means clustering의 결과대로 색깔별로 구분하여 점에 색칠한 후 도식
for cluster in range(5):
    cluster_sub_points = points[kmeans_cluster.labels_ == cluster] # 전체 무작위 점 데이터에서 K-means 알고리즘에 의해 군집화된 sub data를 분리합니다. 
    ax.scatter(cluster_sub_points[:, 0], cluster_sub_points[:, 1], c=color_dict[cluster], label='cluster_{}'.format(cluster)) # 해당 sub data를 plot합니다.

# 축 이름을 라벨에 달고, 점 데이터 그리기
ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.legend()
ax.grid()

처음에 우리가 중심점 5개인 무작위 데이터를 생성하고 나서, 이를 K-means 알고리즘을 활용해 5개의 군집으로 분류한 결과가 위와 같습니다.

그런데 사실, K-means 알고리즘이 항상 만능열쇠는 아닙니다. 주어진 데이터의 분포에 따라 우리가 의도하지 않은 결과를 초래할 수 있어요.

K-means 알고리즘이 잘 동작하지 않는 예시들

다음 코드를 통해 어떤 특성의 데이터들이 K-means 알고리즘을 적용하였을 때 잘 군집화되지 않는지 살펴보도록 하겠습니다.

# K-means algorithm이 잘 동작하지 않는 예시 (1) 원형 분포
from sklearn.datasets import make_circles

# 원형 분포 데이터 생성
circle_points, circle_labels = make_circles(n_samples=100, factor=0.5, noise=0.01) # 원형 분포를 가지는 점 데이터 100개를 생성합니다.

# 캔버스 생성
fig = plt.figure()
ax = fig.add_subplot(1, 1, 1)

# 원형 분포에 대해 K-means 수행
circle_kmeans = KMeans(n_clusters=2)
circle_kmeans.fit(circle_points)
color_dict = {0: 'red', 1: 'blue'}
for cluster in range(2):
    cluster_sub_points = circle_points[circle_kmeans.labels_ == cluster]
    ax.scatter(cluster_sub_points[:, 0], cluster_sub_points[:, 1], c=color_dict[cluster], label='cluster_{}'.format(cluster))
ax.set_title('K-means on circle data, K=2')
ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.legend() 
ax.grid()

첫 번째 원형으로 분포되어 있는 데이터 같은 경우는 아마 대부분의 사람들이 '가운데 작은 원'과 '바깥쪽 큰 원' 두 개의 군집으로 분류하기를 원했을 거예요. 하지만 K-means 알고리즘은 이 데이터들을 마치 케잌을 칼로 자르듯이 반으로 나눴네요.

# K-means algorithm이 잘 동작하지 않는 예시 (2) 달 모양 분포
from sklearn.datasets import make_moons

# 달 모양 분포의 데이터 생성
moon_points, moon_labels = make_moons(n_samples=100, noise=0.01) # 달 모양 분포를 가지는 점 데이터 100개를 생성합니다.

# 캔버스 생성
fig = plt.figure()
ax = fig.add_subplot(1, 1, 1)

# 달 모양 분포 데이터 plot
moon_kmeans = KMeans(n_clusters=2)
moon_kmeans.fit(moon_points)
color_dict = {0: 'red', 1: 'blue'}
for cluster in range(2):
    cluster_sub_points = moon_points[moon_kmeans.labels_ == cluster]
    ax.scatter(cluster_sub_points[:, 0], cluster_sub_points[:, 1], c=color_dict[cluster], label='cluster_{}'.format(cluster))
ax.set_title('K-means on moon-shaped data, K=2')
ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.legend() 
ax.grid()

두 번째 초승달 모양의 데이터도 마찬가지예요. 두 개의 달 형태를 분리해서 군집화하지 않고, 이 역시 y축에 대하여 칼로 자른 형태의 느낌으로 두 개의 군집을 나눴네요.

정보 이론(information theory)이란 추상적인 '정보'라는 개념을 정량화하고 정보의 저장과 통신을 연구하는 분야입니다.

• Information Content

• Entropy

• Kullback Leibler Divergence

• Cross Entropy Loss

• Decision Tree와 Entropy

정보 이론(information theory)이란 추상적인 '정보'라는 개념을 정량화하고 정보의 저장과 통신을 연구하는 분야입니다.

눈에 보이지 않는 '정보'를 어떻게 정량적으로 표현할 수 있을까요? 아래 그림처럼 두 개의 주머니에 공이 들어 있다고 생각해 봅시다. 왼쪽 주머니에는 4가지 색깔의 공들이 들어있고, 오른쪽 주머니에 들어 있는 공은 모두 파란색입니다.

왼쪽 주머니에서 공을 하나 꺼내서 색깔을 보고 다시 넣는 과정을 반복하면, 관찰된 공의 색깔은 4가지 중 무작위입니다.

반면에 오른쪽 주머니에서 공을 꺼낸다면 파란색 공만 관찰될 것입니다.

직관적으로 주머니에서 공을 꺼낼 때 우리가 얻을 수 있는 정보의 양은 왼쪽이 더 많습니다.

오른쪽 주머니에서는 공을 꺼내봤자 어차피 파란색이니 별다른 정보가 없는 것이죠.

오늘 아침에 해가 동쪽에서 떴다는 이야기가 뉴스거리가 되지 못하는 것과 같은 이유입니다.

상황을 약간 바꿔서, 파란색 공 999개와 빨간색 공 1개가 들어 있는 주머니가 있다고 합시다.

어떤 사람이 공을 하나 꺼내고 다시 넣는 실험을 반복합니다.

이 사람은 주머니에 어떤 색깔의 공이 몇 개씩 들어 있는지 모르기 때문에, 공을 하나씩 뽑을 때마다 이 사람이 추측하는 확률 분포가 업데이트됩니다.

파란색 공을 처음 몇 번 뽑았을 때, 파란색 공을 뽑는 사건은 정보량이 높습니다.

하지만 파란색 공만 수십, 수백 번 뽑고 나서는 파란색 공을 뽑는 사건은 확률이 1에 가깝기 때문에 큰 의미를 주지 못합니다.

그러다가 만약에 하나 있는 빨간색 공을 뽑는다면, 이 사건은 정보량이 엄청나게 높을 것입니다.

빨간색 공을 뽑기 전까지 관찰된 파란색 공의 수가 많을수록(즉 빨간색 공이 뽑힐 확률이 낮을수록) 빨간색 공을 뽑는 사건의 정보량은 높아집니다.

Goodfellow, Bengio, Courville의 책 Deep Learning에는 정보를 정량적으로 표현하기 위해 필요한 세 가지 조건이 설명되어 있습니다.

일어날 가능성이 높은 사건은 정보량이 낮고, 반드시 일어나는 사건에는 정보가 없는 것이나 마찬가지입니다.

일어날 가능성이 낮은 사건은 정보량이 높습니다.

두 개의 독립적인 사건이 있을 때, 전체 정보량은 각각의 정보량을 더한 것과 같습니다.

사건 xx가 일어날 확률을 P(X=x)P(X=x)라고 할 때, 사건의 정보량(information content) I(x)I(x)는 다음과 같이 정의됩니다.

I(x)=−log_b * P(x)

이 식은 위의 세 가지 조건을 모두 만족하는 것을 확인할 수 있습니다.

로그의 밑 bb에는 주로 2, ee, 10과 같은 값이 사용되는데, b=2b=2인 경우 정보량은 정보를 나타내기 위해 필요한 비트(bit)의 개수와 같습니다.

여기에서는 밑이 ee인 자연로그를 사용하겠습니다. 아래의 그림은 P(x)P(x)의 값에 대한 -\log P(x)−logP(x)의 그래프입니다.

파란색 공 nn개와 빨간색 공 1개가 있을 때 빨간색 공을 뽑는 사건의 정보량을 코드로 계산해 보겠습니다.

빨간색 공이 뽑힐 때까지 공을 꺼내는 시뮬레이션이 반복됩니다. 전체 공의 개수가 많을수록 1개 있는 빨간색 공이 뽑힐 확률은 작아지고, 평균적으로 계산되는 정보량이 커집니다.

import numpy as np
import math
import random

# 주머니 속에 들어있는 공의 개수입니다. 숫자를 바꾸면서 실험해보세요!
total = 1000

#---------------#

count = 1   # 실험이 끝날 때까지 꺼낸 공의 개수

# 1부터 total까지의 정수 중에서 하나를 뽑고 total과 같으면 실험 종료
# total=1000인 경우 1~999: blue / 1000: red
while True:
    sample = random.randrange(1,total+1)
    if sample == total:
        break
    count += 1

print('number of blue samples: '+str(count-1))
print('information content: '+str(-math.log(1/count)))

#randint

# randint 함수는 인자로 들어온 a, b 사이의 랜덤한 정수(int)를 반환합니다.

# 반환하는 x는  a, b를 포함한 범위 입니다. (a <= N <= b)

# randrange 함수에 a, b+1을 넣은것과 동일하게 동작합니다.



# x = random.randint(10, 20)

# print(x)    # 10 <= x <= 20


a = random.randint(1,10)
print(a)

# ------------------------------------------------------------------------

#randrange

#  randrange(a, b), randrange(b)

# randrange 함수는 매개변수 1개 버전, 2개 버전이 존재합니다.

# randrange(a, b)는 a <= x < b 의 범위 내에서의 랜덤한 정수(int)를 반환합니다. b를 포함하지 않는 범위입니다!

# randrange(b)는 0 <= x < b 의 범위 내에서의 랜덤한 정수(int)를 반환합니다.  b를 포함하지 않습니다!
#list_range랑 똑같음


# x1 = random.randrange(10, 20)

# print(x1)    # 10 <= x < 20 사이의 랜덤한 int 반환

# x2 = random.randrange(20)

# print(x2)    # 0 <= x < 20 사이의 랜덤한 int 반환

b = random.randrange(2,50)
print(b)

이전 스텝을 돌이켜보면, 사건 xx의 정보량 I(x)I(x)는 사건이 일어날 확률 P(x)P(x)에 의해 결정되었습니다.

I(x)=−log * P(x)

보량은 한 가지 사건에 대한 값입니다.

예를 들면 주사위를 던졌을 때 1이 나오는 사건, 여러 색깔의 공이 들어 있는 주머니에서 빨간색 공을 꺼내는 사건 등이죠.

그러면 여러 가지 경우의 수가 존재하는 실험의 정보량도 구할 수 있을까요?

직관적으로 확률 변수가 가지는 모든 경우의 수에 대해 정보량을 구하고 평균을 내면 확률 변수의 평균적인 정보량을 구할 수 있을 것입니다.

특정 확률분포를 따르는 사건들의 정보량 기댓값을 엔트로피(entropy)라고 합니다.

For Discrete Random Variables

이산 확률 변수 XX가 x_1, x_2, \dots, x_n_1,x_2 ,…,x_n 중 하나의 값을 가진다고 가정합시다. 엔트로피는 각각의 경우의 수가 가지는 정보량에 확률을 곱한 후, 그 값을 모두 더한 값입니다.

위 그림은 여러 개의 공이 들어 있는 주머니에서 공을 꺼낼 때 각각의 엔트로피 값을 계산한 예제입니다.

위쪽 주머니에는 4가지 색깔의 공이 들어있고, 특정한 색깔의 공이 뽑힐 확률이 각각 0.4, 0.3, 0.2, 0.1이므로 엔트로피는 약 1.28입니다.

반면에 아래쪽 주머니에는 파란색 공만 들어있는데, 파란색 공이 뽑힐 확률이 1이므로 엔트로피는 -1 \log 1=0−1log1=0이 됩니다.

여러 가지 색깔의 공이 들어있을 때 엔트로피가 높고, 같은 색깔의 공이 많이 들어있을 때 엔트로피가 낮습니다.

주머니에 공 10개가 있을 때, 10개가 모두 다른 색깔인 경우 엔트로피는 -(0.1 \log 0.1) \times 10 \approx 2.3−(0.1log0.1)×10≈2.3으로 최댓값을 가지고, 모두 같은 색깔인 경우 엔트로피는 0으로 최솟값을 가집니다.

이러한 사실은 엔트로피의 직관적인 개념인 무질서도 또는 불확실성 과도 비슷합니다.

이번에는 공의 색깔을 2가지로 고정시키고, 두 색깔의 비율만 조절해 보겠습니다. 파란색 공 9개, 빨간색 공 1개가 들어 있는 경우는 엔트로피가 약 0.325입니다. 각각 6개, 4개가 들어 있는 경우는 엔트로피가 약 0.673이 나옵니다.

확률 변수가 가질 수 있는 값의 가짓수가 같을 때(여기에서는 빨간색/파란색), 사건들의 확률이 균등할수록 엔트로피값은 증가합니다.

아래 그림은 동전을 던질 때 앞면이 나올 확률에 따른 엔트로피를 나타낸 그래프입니다.

앞면이 나올 확률이 0.5일 때(앞면과 뒷면의 확률이 각각 0.5로 같은 균등 분포(uniform distribution)) 엔트로피값이 최대가 됩니다.

앞면이 나올 확률이 90%인 동전을 던질 때보다 앞면과 뒷면의 확률이 같은 동전을 던질 때 결과를 예측하기가 더 어렵기 때문에 불확실성이 크다고 할 수 있겠죠.

머신러닝의 목표는 새로운 입력 데이터가 들어와도 예측이 잘 되도록, 모델의 확률 분포를 데이터의 실제 확률 분포에 가깝게 만드는 것입니다.

머신 러닝 모델은 크게 두 가지가 있습니다. 우선 결정 모델(discriminative model)은 데이터의 실제 분포를 모델링 하지 않고 결정 경계(decision boundary)만을 학습합니다.

예를 들면 모델의 결괏값이 0보다 작을 경우 데이터를 1번 클래스로 분류하고, 0보다 클 경우 2번 클래스로 분류하는 식이죠.

반면에 생성 모델(generative model)은 데이터와 모델로부터 도출할 수 있는 여러 확률 분포와 베이즈 이론을 이용해서 데이터의 실제 분포를 간접적으로 모델링 합니다. 그렇기 때문에 생성 모델을 학습시킬 때는 두 확률 분포의 차이를 나타내는 지표가 필요한데, 대표적인 예가 쿨백-라이블러 발산(Kullback-Leibler divergence, KL divergence)입니다.

데이터가 따르는 실제 확률 분포를 P(x)P(x), 모델이 나타내는 확률 분포를 Q(x)Q(x)라고 합시다.

두 확률 분포의 KL divergence는 P(x)P(x)를 기준으로 계산된 Q(x)Q(x)의 평균 정보량과, P(x)P(x)를 기준으로 계산된 P(x)P(x)의 평균 정보량의 차이로 정의할 수 있습니다.

실제 확률 분포 P(x)P(x) 대신 근사적인 분포 Q(x)Q(x)를 사용했을 때 발생하는 엔트로피의 변화량을 나타내는 값입니다.

P(x)는 데이터의 실제 분포이므로, 우리가 바꿀 수 없는 고정된 값입니다.

위의 식에서 오른쪽의 파란색 부분은 모델을 아무리 잘 만들어도 값을 줄일 수 없죠. 우리가 바꿀 수 있는 부분은 Q(x)Q(x)에 관한 식이기 때문에 KL divergence를 최소화하는 문제는 곧 빨간색 부분을 최소화하는 문제가 됩니다.

이 부분은 P(x)P(x)를 기준으로 계산한 Q(x)Q(x)의 엔트로피, 즉 P(x)P(x)에 대한 Q(x)Q(x)의 교차 엔트로피(cross entropy)입니다.

Cross Entropy Loss

머신러닝에서 모델이 나타내는 확률 분포와 데이터가 따르는 실제 확률 분포 사이의 차이를 나타내는 함수를 손실 함수(loss function)라고 합니다.

모델의 확률 분포는 파라미터에 따라 달라지기 때문에 손실 함수 역시 파라미터에 의해 결정됩니다.

likelihood 노드에서 잠깐 다루었던 최소제곱법의 함수도 손실 함수라고 할 수 있죠. 데이터가 연속적인 값을 가지는 회귀(regression) 문제와는 다르게, 이산적인 값을 가지는 분류(classification) 문제에서는 모델의 출력 결과가 로지스틱 함수(logistic function)로 표현됩니다.

분류 클래스가 2개인 로지스틱 함수를 클래스가 nn개일 때로 확장한 것이 딥러닝에서도 자주 사용되는 소프트맥스 함수(softmax function)입니다.

이 함수와 데이터의 확률 분포의 차이가 분류 문제의 손실 함수가 됩니다.

앞에서 KL divergence를 최소화하는 것이 cross entropy를 최소화하는 것과 같다는 이야기를 했습니다.

cross entropy 또한 손실 함수의 한 종류입니다. cross entropy의 식을 다시 살펴봅시다.

분류 문제에서 데이터의 라벨은 one-hot encoding을 통해 표현됩니다.

클래스의 종류가 NN가지이고 특정 데이터가 nn번째 클래스에 속할 때, nn번째 원소만 1이고 나머지는 0으로 채운 NN차원 벡터로 놓는 것이죠.

입력 데이터의 특성(feature) 값이 모델을 통과하면 출력 레이어의 소프트맥스 함수에 의해서 각각의 클래스에 속할 확률이 계산됩니다.

이 확률 값들이 모델이 추정한 확률 분포 Q(x)Q(x)를 구성하는 값들입니다. 3개의 클래스 c_1,c_2,c_3c 가 존재하는 분류 문제에서 어떤 데이터의 출력값이 다음과 같다고 가정합시다.

데이터가 실제로 2번 클래스에 속할 경우, 데이터의 실제 확률 분포는 one-hot encoding과 같은 [0,1,0][0,1,0]입니다.

데이터가 2번 클래스에 포함된다는 사실이 이미 확실하게 알려졌기 때문에 확률 분포가 이와 같이 계산되는 것입니다.

분류 문제에서는 데이터의 확률 분포가 위와 같이 one-hot vector로 표현되기 때문에, P(x)P(x)와 Q(x)Q(x)의 차이를 cross entropy로 계산할 경우 계산이 간단해진다는 장점이 있습니다.

아래는 Q(x)Q(x) 분포가 랜덤하게 생성되었을 때 P(x)P(x)를 변형시키면서 cross entropy를 계산해볼 수 있는 코드입니다.

우선 아래 코드를 실행해 Q(x)Q(x) 생성합니다.

실제 환경에서는 Q(x)Q(x)가 랜덤값으로 생성되는 것이 아니라 모델의 예측을 통해 얻게 된 값일 거예요. 그러니 softmax_output이라는 변수를 사용하겠습니다.

import numpy as np
import random

# generate random output
#-----------------#
# can be modified
class_num = 4
#-----------------#
q_vector = []
total = 1

for i in range(class_num-1):
    q = random.uniform(0,total)
    q_vector.append(round(q,3))
    total = total - q

q_vector.append(total)
softmax_output = np.array(q_vector)

print(softmax_output)

이제 P(x)P(x)를 생성해 Cross Entropy를 계산해 봅시다.

p_vector변수를 사용하는 P(x)P(x) 는 one-hot vector이므로 직접 class_index를 바꿔가며 확인해 볼 수 있어요.

#-----------------#
# can be modified
class_index = 1
#-----------------#

p_vector = np.zeros(class_num)
p_vector[class_index-1] = 1

cross_entropy = -np.sum(np.multiply(p_vector, np.log(softmax_output)))

print('model prediction: '+str(softmax_output))
print('data label: '+str(p_vector))
print('cross entropy: '+str(round(cross_entropy,4)))

Decision Tree와 Entropy

딥러닝의 분류 모델 학습의 기초를 이루는 Cross Entropy 개념에 대해 지금까지 살펴보았습니다.

그 외에도 엔트로피 개념이 활발하게 쓰이는 분야를 하나만 더 짚어 보자면 의사결정나무(Decision Tree) 계열의 모델일 것입니다.

의사결정나무를 설명하는 가장 간단한 데이터셋을 기준으로, 잠시 의사결정나무의 원리를 설명하겠습니다.

아래 그림은 날씨에 따른 운동경기 여부를 기록한 데이터입니다. Day를 제외하고, 다음과 같은 4개의 데이터 컬럼이 있으며, Play(Yes/No) 컬럼이 라벨 역할을 하게 됩니다.

• Outlook : 전반적 날씨 (Sunny(맑은), Overcast(구름 낀), Rainy(비 오는))
• Temperature : 기온 정보(섭씨온도)
• Humidity : 습도 정보 (수치형 변수(%), 범주형으로 변환된 경우 (high, normal))
• Wind : 풍량 정보 (TRUE(바람 붊), FALSE(바람 안 붐) )

의사결정 트리는 가지고 있는 데이터에서 어떤 기준으로 전체 데이터를 나눴을 때 나누기 전보다 엔트로피가 감소하는지를 따져서, 엔트로피가 감소하면 그만큼 모델 내부에 정보 이득(Information Gain) 을 얻었다고 보는 관점입니다.

엔트로피 증가가 정보 손실량이라고 정의하는 것의 반대 관점이죠.

• S : 전체 사건의 집합
• FF : 분류 기준으로 고려되는 속성(feature)의 집합
• f \in Ff∈F : ff는 FF 에 속하는 속성 (예를 들어 FF가 Outlook일 때, ff는 Sunny, - Overcast, Rainy 중 하나가 될 수 있다. )
• S_f:f 속성을 가진 S의 부분집합
• |X|∣X∣ : 집합 X의 크기(원소의 개수)
• e(X)e(X) : X라는 사건 집합이 지닌 엔트로피

위 수식 IG(S, F)IG(S,F)는 FF라는 분류 기준을 선택했을 때의 엔트로피를 전체 사건의 엔트로피에 빼준 값, 즉 분류 기준 채택을 통해 얻은 정보 이득의 양을 말합니다.

먼저 e(S)e(S)부터 구해 봅시다. 전체 14가지 경우 중 play하는 경우가 9번, 하지 않는 경우가 5번입니다. 그렇다면 e(S)e(S)는 다음과 같습니다.

이런 방식으로 가능한 모든 분류 기준 FF에 대해 정보 이득을 계산해서, 가장 정보 이득이 큰 순서대로 전체 사건을 2등분 합니다.

그 후 다시 다른 분류 기준으로 위에서 했던 것과 동일하게, 이번에는 첫 번째로 사용했던 기준으로 나뉜 절반의 사건 집합 안에서의 정보 이득을 계산하는 방식으로 세부 분류 기준을 계속 찾아나갑니다.

그렇게 사건의 분류 기준을 세워나가다 보면 전체 사건 분류 기준이 트리 구조가 되기 때문에 이를 의사결정나무(Decision Tree) 라 부르게 됩니다.

그럼 엔트로피만 낮은 쪽으로 간다면 무조건 정교한 분류가 가능할까요? 한번 의사결정나무 모델을 학습시켜 보고, 이를 시각화하는 과정을 통해 살펴보겠습니다.

위에서 예로 든 데이터셋은 실험하기에는 너무 작은 데이터셋이므로 다른 데이터셋을 준비해 보겠습니다.

아래는 캐글에서 제공하는 Pima Indians Diabetes Database입니다.

import pandas as pd
import numpy as np
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import train_test_split
from sklearn import metrics

import os
csv_path = os.getenv('HOME')+'/aiffel/information_theory/diabetes.csv'

col_names = ['pregnant', 'glucose', 'bp', 'skin', 'insulin', 'bmi', 'pedigree', 'age', 'label']
# load dataset
df = pd.read_csv(csv_path, header=0, names=col_names)
df.head()

# Decision Tree  모델 학습
# Create Decision Tree classifer object
clf = DecisionTreeClassifier()

# Train Decision Tree Classifer
clf = clf.fit(X_train,y_train)

#Predict the response for test dataset
y_pred = clf.predict(X_test)

print("Accuracy:",metrics.accuracy_score(y_test, y_pred))

*Accuracy: 0.6883116883116883 *

Decision Tree를 아무 제약조건 없이 학습시켜 나온 결과 정확도는 66% 정도 됩니다.

Decsion Tree의 장점은 어떻게 모델이 이런 결과를 내었는지 분류 기준을 따져보고 시각화를 통한 원인 추적이 가능하다는 점입니다.

다음과 같이 방금 학습시킨 Decision Tree 모델을 시각화해 보겠습니다.

생성된 이미지 파일이 꽤 크기 때문에 저장된 이미지를 직접 열어 확인해도 좋습니다. diabetes1.png로 저장됩니다.

from sklearn.tree import export_graphviz
from six import StringIO  
import pydotplus

dot_data = StringIO()
export_graphviz(clf, 
                out_file=dot_data,  
                filled=True, 
                rounded=True,
                special_characters=True, 
                feature_names=feature_cols, 
                class_names=['0','1'])
graph = pydotplus.graph_from_dot_data(dot_data.getvalue())  
graph.write_png('diabetes1.png')
Image(graph.create_png(), retina=True)

여기서 사용한 정보의 총량은 얼마나 될까요? 사용되지 않은 정보가 적을 수록 많은 정보를 사용한 것일테니, 정보 이득이 되지 않은 Impurity를 측정해 봅시다.

# 정보 이득이 되지 않고 남은 Impurity  총량 측정
ccp_path1 = clf.cost_complexity_pruning_path(X_train,y_train)
ccp_path2 = clf.cost_complexity_pruning_path(X_test,y_test)
print(np.mean(ccp_path1.impurities))
print(np.mean(ccp_path2.impurities))

0.15499314715839188 0.14933968140533083

위 두 가지 사실을 볼 때 우리가 학습시킨 Decision Tree 는 정보 이득을 최대화할 수 있는 지점까지 극한적으로 많은 분류 기준을 적용한 경우임을 알 수 있었습니다. 그런데 이것이 과연 타당할까요?

비교 실험을 해 보겠습니다. 우리는 Decision Tree를 3depth 까지만 발전시켜 볼 것입니다.

clf = DecisionTreeClassifier(criterion="entropy", max_depth=3)

# Train Decision Tree Classifer
clf = clf.fit(X_train, y_train)

#Predict the response for test dataset
y_pred = clf.predict(X_test)

# Model Accuracy, how often is the classifier correct?
print("Accuracy:",metrics.accuracy_score(y_test, y_pred))

*Accuracy: 0.7705627705627706 *

어떤가요? 오히려 훨씬 Accuracy가 올라갔습니다.

이때의 트리구조 및 정보 이득되지 않은 남은 엔트로피(Impurity) 총량은 어떨까요?

분명 엔트로피 기준으로는 더욱 정보 이득을 얻을 수 있음에도 불구하고 분류 기준을 더 세우지 않는 것이 전체 모델의 정확도 향상에 낫다는 것을 알 수 있었습니다.

왜냐하면 Decision Tree 의 분류 기준은 임의로 정한 것이기 때문입니다.

무한정 기준을 쪼개서 엔트로피를 떨어뜨릴 수 있지만, 그것은 Overfitting의 결과를 낳게 됩니다.

시각화된 결과를 통해 이를 확인해 보면 좋습니다.

하지만 다양한 분류 기준을 가진 Decision Tree 여러 개를 앙상블한 Random Forest 모델은 이러한 문제점을 극복하고 훌륭한 성능을 보일 수 있음도 우리는 알고 있습니다.

그렇다면 Decision Tree를 몇 depth까지 학습시키는 것이 가장 좋을까요? 실험을 통해 확인해 보시기 바랍니다.

Localization이란 이미지 내에 하나의 물체(Object)가 있을 때 그 물체의 위치를 특정하는 것인데, Detection이라 함은 다수의 물체(Object)가 존재할 때 각 Object의 존재 여부를 파악하고 위치를 특정하며 클래스 분류(Classification)까지 수행하는 것이지요.

기본적으로 물체 한 개의 위치를 찾아낼 수 있다면 반복 과정을 통해 여러 물체를 찾아낼 수 있겠죠?

그러니 먼저 localization부터 파헤쳐 보도록 하겠습니다.

• 딥러닝 용어 설명

• 객체감지를 위한 딥러닝

바운딩 박스(Bounding box)는 이미지 내에서 물체의 위치를 사각형으로 감싼 형태의 도형으로 정의하고 이를 꼭짓점의 좌표로 표현하는 방식입니다.

이때 2개의 점을 표현하는 방식은 두 가지가 있습니다.

첫 번째로 전체 이미지의 좌측 상단을 원점으로 정의하고 바운딩 박스의 좌상단 좌표와 우하단 좌표 두 가지 좌표로 표현하는 방식이 있습니다.

두 번째는 이미지 내의 절대 좌표로 정의하지 않고 바운딩 박스의 폭과 높이로 정의하는 방식입니다.

이 경우 좌측 상단의 점에 대한 상대적인 위치로 물체의 위치를 정의할 수 있습니다.

이번에는 직접 이미지에 박스를 그려보는 시간을 갖도록 하겠습니다.

from PIL import Image, ImageDraw
import os

img_path=os.getenv('HOME')+'/aiffel/object_detection/images/person.jpg'
img = Image.open(img_path)

draw = ImageDraw.Draw(img)
draw.rectangle((130, 30, 670, 450), outline=(0,255,0), width=2)

img

3) Intersection over Union(IOU) 면적의 절대적인 값에 영향을 받지 않도록 두 개 박스의 차이를 상대적으로 평가하기 위한 방법 중 하나가 IoU(Intersection over Union) 입니다.

import tensorflow as tf
from tensorflow import keras

output_num = 1+4+3 # object_prob 1, bbox coord 4, class_prob 3

input_tensor = keras.layers.Input(shape=(224, 224, 3), name='image')
base_model = keras.applications.resnet.ResNet50(
    input_tensor=input_tensor,
    include_top=False,
    weights='imagenet',
    pooling=None,
)
x = base_model.output
preds = keras.layers.Conv2D(output_num, 1, 1)(x)
localize_model=keras.Model(inputs=base_model.input, outputs=preds)

localize_model.summary()

앵커 박스(Anchor box)

이제 확인했던 Detection 모델로 위의 그림을 인식한다고 가정해 봅시다.

한 가지 문제가 생겼습니다. 차 사이에 사람이 있습니다.

우리는 한 칸에 한 가지 물체를 감지하기 때문에 만약 모두 차를 잡게 된다면 사람을 놓칠 수밖에 없습니다.

앵커 박스(anchor box)는 서로 다른 형태의 물체와 겹친 경우에 대응할 수 있습니다.

일반적으로 차는 좌우로 넓고 사람은 위아래로 길쭉합니다. 따라서 사람의 형태와 유사한 형태와 차와 유사한 형태의 가상의 박스 두 개를 정의합니다.

기존에 위에서 본 모델의 구조에서 두 개의 클래스로 확장해 봅시다.

차와 사람 클래스에 대해서 물체를 감지하기 위해서는 한 개의 그리드 셀에 대한 결괏값 벡터가 물체가 있을 확률, 2개의 클래스, 그리고 바운딩 박스 4개로 총 7개의 차원을 가지게 될 것입니다.

따라서 입력값이 16x16 일 때, 이 그림을 2x2로 총 4칸의 그리드로 나누었다고 하면, 결괏값의 형태는 7개의 채널을 가져 2x2x7이 됩니다.

이때 7개의 차원을 한 벌 더 늘려주어 한 개의 물체의 수를 늘려줍니다. 앵커 박스가 두 개가 된다면 결괏값의 형태는 2x2x14가 됩니다.

바운딩 박스와 앵커 박스라는 두 가지 개념이 혼동이 되시지 않나요?

바운딩 박스 : 네트워크가 predict한 object의 위치가 표현된 박스로서, 네트워크의 출력이다. 앵커 박스 : 네트워크가 detect해야 할 object의 shape에 대한 가정(assumption)으로서, 네트워크의 입력이다. 4) NMS(Non-Max Suppression) 우리가 2x2 또는 더 큰 Grid cell에서 물체가 있는지에 대한 결과를 받게 되면 매우 많은 물체를 받게 됩니다.

Anchor box를 사용하지 않더라도 2x2격자에 모두 걸친 물체가 있는 경우 하나의 물체에 대해 4개의 Bounding box를 얻게 되죠.

이렇게 겹친 여러 개의 박스를 하나로 줄여줄 수 있는 방법 중 하나가 NMS(non-max suppression) 입니다.

NMS는 겹친 박스들이 있을 경우 가장 확률이 높은 박스를 기준으로 기준이 되는 IoU 이상인 것들을 없앱니다.

이때 IoU를 기준으로 없애는 이유는 어느 정도 겹치더라도 다른 물체가 있는 경우가 있을 수 있기 때문입니다.

이때 Non-max suppression은 같은 class인 물체를 대상으로 적용하게 됩니다.

5) 정리 Convolutional implementation of Sliding Windows Anchor box Non-max suppression(NMS) 지금까지 위의 세 가지 개념과 CNN을 활용한 물체 검출(Object detection) 방법을 배워보았습니다.

Convolution으로 슬라이딩 윈도우를 대신함으로써 여러 window에서 Object localization을 병렬로 수행할 수 있게 되어 속도 측면의 개선이 있었습니다.

Anchor box는 겹친 물체가 있을 때, IoU를 기준으로 서로 다른 Anchor에 할당하도록 하여 생긴 영역이 다른 물체가 겹쳤을 때도 물체를 검출할 수 있도록 할 수 있게 되었습니다.

마지막으로 Non-max suppression은 딥러닝 모델에서 나온 Object detection 결과들 중 겹친 결과들을 하나로 줄이면서 더 나은 결과를 얻을 수 있게 했습니다.

이제는 위 3가지를 토대로 접근한 다양한 검출 모델을 확인해 보도록 하겠습니다.

앞에서 봐왔던 바운딩 박스 regression과 앵커 박스, 그리고 NMS를 이용하면 어느 정도 동작하는 Detection 모델을 만들 수 있습니다.

그렇다면 이보다 더 나아간 방법들은 어떤 것들이 있을까요?

Detection task는 많은 분야에서 필요하듯이 연구도 활발하게 진행되고 있습니다.

활발한 연구만큼 다양한 방법들이 있는데요.

딥러닝 기반의 Object Detection 모델은 크게 Single stage detector와 Two stage detector로 구분할 수 있습니다. 아래에서 그 예시를 볼 수 있습니다.

Many stage라고 적혀있는 방법에서는 물체가 있을 법한 위치의 후보(proposals) 들을 뽑아내는 단계, 이후 실제로 물체가 있는지를 Classification과 정확한 바운딩 박스를 구하는 Regression을 수행하는 단계가 분리되어 있습니다. 대표적으로는 Faster-RCNN을 예로 들 수 있습니다. One stage Detector는 객체의 검출과 분류, 그리고 바운딩 박스 regression을 한 번에 하는 방법입니다.

Normalization : 정규화 이는 데이터의 형태를 좀 더 의미 있게, 혹은 트레이닝에 적합하게 전처리하는 과정입니다. 데이터를 z-score로 바꾸거나 minmax scaler를 사용하여 0과 1사이의 값으로 분포를 조정하는 것들이 해당됩니다. 예를 들어, 금액과 같은 큰 범위의 값(10,000 ~ 10,000,000)과 시간(0~24) 의 값이 들어가는 경우, 학습 초반에는 데이터 거리 간의 측정이 피처 값의 범위 분포 특성에 의해 왜곡되어 학습에 방해를 받게 되는 문제가 있습니다. Normalization은 이를 모든 피처의 범위 분포를 동일하게 하여 모델이 풀어야 하는 문제를 좀 더 간단하게 바꾸어 주는 전처리 과정입니다.

핵심을 정리하면, Regularization은 오버피팅을 막고자 하는 방법, Normalization은 트레이닝을 할 때에 서로 범위가 다른 데이터들을 같은 범위로 바꿔주는 전처리 과정이라는 것입니다.

iris data로 예를 들어 보겠습니다.

from sklearn.datasets import load_iris
import pandas as pd 
import matplotlib.pyplot as plt

iris = load_iris()
iris_df = pd.DataFrame(data=iris.data, columns=iris.feature_names)
target_df = pd.DataFrame(data=iris.target, columns=['species'])

# 0, 1, 2로 되어있는 target 데이터를 
# 알아보기 쉽게 'setosa', 'versicolor', 'virginica'로 바꿉니다 
def converter(species):
    if species == 0:
        return 'setosa'
    elif species == 1:
        return 'versicolor'
    else:
        return 'virginica'

target_df['species'] = target_df['species'].apply(converter)

iris_df = pd.concat([iris_df, target_df], axis=1)
iris_df.head()

Iris data 중 virginica라는 종의 petal length(꽃잎 길이)를 X, sepal length(꽃받침의 길이)를 Y로 두고 print 해보겠습니다.

X = [iris_df['petal length (cm)'][a] for a in iris_df.index if iris_df['species'][a]=='virginica']
Y = [iris_df['sepal length (cm)'][a] for a in iris_df.index if iris_df['species'][a]=='virginica']

print(X)
print(Y)

값으로만 보니 직관적으로 잘 와닿지 않네요! 산점도로 그려봅시다.

아직 Normalization을 하지 않았기 때문에 x축과 y축은 각각의 최솟값과 최댓값의 범위로 그려집니다.

plt.figure(figsize=(5,5))
plt.scatter(X,Y)
plt.title('petal-sepal scatter before normalization') 
plt.xlabel('petal length (cm)')
plt.ylabel('sepal length (cm)')
plt.grid()
plt.show()

이제 0-1로 normlization을 해주는 minmax_scale를 이용해서 산점도를 다시 한번 그려보겠습니다.

from sklearn.preprocessing import minmax_scale

X_scale = minmax_scale(X)
Y_scale = minmax_scale(Y)

plt.figure(figsize=(5,5))
plt.scatter(X_scale,Y_scale)
plt.title('petal-sepal scatter after normalization') 
plt.xlabel('petal length (cm)')
plt.ylabel('sepal length (cm)')
plt.grid()
plt.show()

결과를 비교해보면, 가장 큰 값을 1, 가장 작은 값을 0으로 하여 축 범위가 바뀜을 확인할 수 있습니다. 데이터의 상대적인 분포는 바뀌지 않았지만, feature의 스케일이 0과 1 사이로 변환되었으므로 이후 X, Y 의 관계를 다루기 용이 해졌습니다. sklearn.linear_model에는 L1, L2 Regression 인 Lasso와 Ridge모델도 함께 포함되어 있으므로, 이들의 차이점을 먼저 직관적으로 이해해 보겠습니다. 수학적 정의나 보다 구체적인 설명은 다음 스텝에 이어집니다.

from sklearn.linear_model import LinearRegression
import numpy as np 

X = np.array(X)
Y = np.array(Y)

# Iris Dataset을 Linear Regression으로 학습합니다. 
linear= LinearRegression()
linear.fit(X.reshape(-1,1), Y)

# Linear Regression의 기울기와 절편을 확인합니다. 
a, b=linear.coef_, linear.intercept_
print("기울기 : %0.2f, 절편 : %0.2f" %(a,b))

output = 기울기 : 1.00, 절편 : 1.06

위에서 Linear regression 으로 구한 기울기와 절편을 가지고 일차함수를 만들어 산점도와 함께 그려보겠습니다.

plt.figure(figsize=(5,5))
plt.scatter(X,Y)
plt.plot(X,linear.predict(X.reshape(-1,1)),'-b')
plt.title('petal-sepal scatter with linear regression') 
plt.xlabel('petal length (cm)')
plt.ylabel('sepal length (cm)')
plt.grid()
plt.show()

이번에는 L1, L2 Regularization으로 Regression을 해보겠습니다. 이는 Lasso, Ridge라고 부릅니다.

먼저 L1 regularization인 Lasso로 문제를 풀어보겠습니다.

#L1 regularization은 Lasso로 import 합니다.
from sklearn.linear_model import Lasso

L1 = Lasso()
L1.fit(X.reshape(-1,1), Y)
a, b=L1.coef_, L1.intercept_
print("기울기 : %0.2f, 절편 : %0.2f" %(a,b))

plt.figure(figsize=(5,5))
plt.scatter(X,Y)
plt.plot(X,L1.predict(X.reshape(-1,1)),'-b')
plt.title('petal-sepal scatter with L1 regularization(Lasso)') 
plt.xlabel('petal length (cm)')
plt.ylabel('sepal length (cm)')
plt.grid()
plt.show()

어떤가요? 혹시 기울기가 0으로 나오지 않았나요? Lasso 방법은 제대로 문제를 풀어내지 못하는 것 같습니다.

이제 같은 데이터셋으로 L2 regularization인 Ridge로 문제를 풀어보고 서로 비교해보겠습니다.

#L2 regularization은 Ridge로 import 합니다. 
from sklearn.linear_model import Ridge

L2 = Ridge()
L2.fit(X.reshape(-1,1), Y)
a, b = L2.coef_, L2.intercept_
print("기울기 : %0.2f, 절편 : %0.2f" %(a,b))

plt.figure(figsize=(5,5))
plt.scatter(X,Y)
plt.plot(X,L2.predict(X.reshape(-1,1)),'-b')
plt.title('petal-sepal scatter with L2 regularization(Ridge)') 
plt.xlabel('petal length (cm)')
plt.ylabel('sepal length (cm)')
plt.grid()
plt.show()

다시 다루겠지만, Linear Regression이 L2 Norm과 관련이 있습니다. 그래서 L2 Regularization을 쓰는 Ridge방법으로는 앞서 Linear Regression과 큰 차이가 없는 결과가 나옵니다.

그러나 왜 L1 Regularization을 쓰는 Lasso에서는 답이 나오지 않았을까요?

다음 스텝에서 그 이유를 알아보도록 하겠습니다!

from sklearn.datasets import load_iris
import pandas as pd 
import matplotlib.pyplot as plt

iris = load_iris()
iris_df = pd.DataFrame(data=iris.data, columns=iris.feature_names)
target_df = pd.DataFrame(data=iris.target, columns=['species'])

def converter(species):
    if species == 0:
        return 'setosa'
    elif species == 1:
        return 'versicolor'
    else:
        return 'virginica'

target_df['species'] = target_df['species'].apply(converter)

iris_df = pd.concat([iris_df, target_df], axis=1)
iris_df.head()

X = [iris_df['petal length (cm)'][a] for a in iris_df.index if iris_df['species'][a]=='virginica']
Y = [iris_df['sepal length (cm)'][a] for a in iris_df.index if iris_df['species'][a]=='virginica']

X = np.array(X)
Y = np.array(Y)

plt.figure(figsize=(5,5))
plt.scatter(X,Y)
plt.xlabel('petal length (cm)')
plt.ylabel('sepal length (cm)')
plt.grid()
plt.show()

from sklearn.linear_model import Lasso

L1 = Lasso()
L1.fit(X.reshape(-1,1), Y)
a, b = L1.coef_, L1.intercept_
print("기울기 : %0.2f, 절편 : %0.2f" %(a,b))

plt.figure(figsize=(5,5))
plt.scatter(X,Y)
plt.plot(X,L1.predict(X.reshape(-1,1)),'-b')
plt.xlabel('petal length (cm)')
plt.ylabel('sepal length (cm)')
plt.grid()
plt.show()

from IPython.display import Image

비지도학습(Unsupervised learning)이란, 지도학습과 달리 training data로 정답(label)이 없는 데이터가 주어지는 학습방법을 말합니다.

비지도학습은 주어진 데이터가 어떻게 구성되어 있는지 스스로 알아내는 방법이라고도 말할 수 있습니다. 아무도 정답을 알려주지 않은 채 오로지 데이터셋의 특징(feature) 및 패턴을 기반으로 모델 스스로가 판단하는 것이니까요.

이렇게 몯느 데이터셋에 각각에 대한 정보가 명시되어 있으면 참 좋겠지만 ,그렇지 않을 경우가 대부분일뿐더러 라벨링이 되어 있는 데이터셋을 마련하기 위해서는 적지 않은 인적 자원이 소모됩니다.

결국 어떤 이미지가 고양이 사진이다, 강아지 사진이다라는 정답을 매기는 과정은 이간이 수행해야 하기 때문입니다.

이 문제를 해결하기 위해, 라벨링이 되어 있지 않은 데이터들 내에서 비슷한 특징이나 패턴을 가진 데이터들끼리 군집화한 후, 새로운 데이터가 어떤 군집에 속하는지를 추론하는 비지도학습과 같은 방법론이 제시되었어요.

비지도학습의 대표적인 예시로는 군집화(클러스터링, clustering) 가 있지만, 비지도학습이라는 용어는 정답이 없는 데이터를 이용한 학습 전체를 포괄하는 용어이기 때문에 클러스터링 외에도 차원 축소(dimensionality reduction) 및 이를 이용한 데이터 시각화, 생성 모델(generative model) 등 다양한 task를 포괄하는 개념입니다.

러스터링의 대표적인 알고리즘인 K-means와 DBSCAN 알고리즘, 차원 축소의 대표적인 방법인 PCA(Principal Component Analysis), T-SNE에 대해서 알아보도록 하겠습니다.

클러스터링(1) K-means 지도학습 상황과 달리, 비지도학습이 필요한 상황에서는 지도학습 때 당연히 주어지던 몇 가지가 생략되어 있습니다.

선은 데이터 X가 무엇인지에 대한 정답(label) y가 없습니다. 또 없는 게 있다면, y가 될 수 있는 분류 기준(클래스 또는 카테고리)도 없다고 할 수 있겠네요.

군집화(클러스터링)이란 그렇게 명확한 분류 기준이 없는 상황에서도 데이터들을 분석하여 가까운(또는 유사한) 것들끼리 묶어 주는 작업입니다. 이를 통해서 개별적인 데이터들을 몇 개의 그룹으로 추상화하여 새로운 의미를 발견해 나갈 수 있게 되겠습니다.

그런데 명확한 분류 기준이 없다면 무엇을 기준으로 묶어낼 수 있을까요?

가장 쉽게 생각해 볼 수 있는 방법은 임의로 k개의 그룹으로 뭉쳐 보라고 하는 것이겠군요.

단 아무렇게나 뭉치진 말고 k개의 기준점을 중심으로 가장 가까운 데이터들을 뭉쳐 보는 방식으로요.

k_means알고리즘은 k 값이 주어져 있을 떄, 주어진 데이터들을 k 개의 클러스터로 묶는 알고리즘으로 대표적인 크러스터링 기법 중 하나입니다.

밑에 코드를 통해 K-means알고리즘이 어떻게 동작하는지 보겠습니다.

%matplotlib inline
from sklearn.datasets import make_blobs
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import random

# 중심점이 5개인 100개의 점 데이터를 무작위로 생성합니다.
points, labels = make_blobs(n_samples=100, centers=5, n_features=2, random_state=135)

print(points.shape, points[:10])  # 무작위로 생성된 점의 좌표 10개 출력
print(labels.shape, labels[:10])    # 10개의 점들이 각각 대응하는 중심점(label) 값 출력

output

(100, 2) [[ 4.63411914 -6.52590383]
 [-6.52008604  7.16624288]
 [ 2.14142339 -5.21092623]
 [ 1.70054231  8.54077897]
 [-0.33809159  8.76509668]
 [-7.69329744  7.94546313]
 [ 3.89090121 -3.06531839]
 [ 3.22338498 -2.93209009]
 [-6.63962964  5.34777334]
 [ 6.37904965 -6.46617328]]
(100,) [2 1 0 3 3 1 0 0 1 2]

비지도학습에는 label이 없다고 했었는데 위 코드에는 label이 등장하네요? 그렇습니다. 임의로 지정한 k개의 중심점이 새로운 label 역할을 하는 것이 K-means 의 아이디어입니다.

그리고 좌표를 그려보겠습니다.

# 축 그리기
fig = plt.figure()
ax = fig.add_subplot(1, 1, 1)

# 위에서 생성한 점 데이터들을 pandas DataFrame 형태로 변환하기
points_df = pd.DataFrame(points, columns=['X', 'Y'])
display(points_df.head())

# 점 데이터를 X-Y grid에 시각화하기
ax.scatter(points[:, 0], points[:, 1], c='black', label='random generated data')

# 축 이름을 라벨에 달고, 점 데이터 그리기
ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.legend()
ax.grid()

위와 같이 scikit-learn의 make_blob()을 활용하여 중심점이 5개인 무작위의 점 데이터 100개를 생성해 보았습니다.

한눈에 보기에도 위의 데이터들은 5개의 군집을 이루고 있는 것처럼 보이는데요, 과연 k-means 알고리즘을 적용하여 위 데이터들을 올바르게 군집화할 수 있는지 알아보겠습니다.

생성한 데이터에 K-means 알고리즘 적용 이제 K-means 알고리즘을 적용해 봅시다. 그런데, 데이터들끼리의 거리를 어떻게 측정하는 걸까요?

실은 우리는 위에서 자연스럽게 데이터를 X-Y 좌표축 위에 생성했습니다.

좌표축 위에 존재하는 데이터들 사이의 거리는 쉽게 계산해 낼 수 있죠? 피타고라스 정리를 응용하여 계산한 좌표축 사이의 두 점 사이의 직선거리를 유클리드 거리(Eucledian distance) 또는 L2 Distance라고 부릅니다.

자세한 설명은 아래 링크를 참고해 주세요. 링크 : 클릭!

※ 유클리디안 거리

유클리드라는 수학자가 고안해낸 이론이다.

최대공약수를 계산하는 유클리드 호제법으로 유명한 분이다.

유클리디안 거리의 다른이름으로 L2 Distance 라고도 한다.

2차원 평면에 두점이 ( x1, y1 ) 과 ( x2, y2 )로 표현되어있다고 가정한다면, 실제 이 두점간의 거리는 피타고라스 정리를 이용하여 쉽게 구할수 있다. 이것을 3차원 4차원 등등 다차원지 확장시킨것이 유클리디안 거리라고 생각하면 되겠다.

예를 들어 n 차원에 있는 두점 P와 Q가 있다고 생각하자 P = ( p1, p2, p3, p4 ,,,, pn ) Q = ( q1, q2, q3, q4 ,,,, qn ) 이 두점간의 거리를 유클리디안 거리로 표현한다면 아래 처럼 표현할수 있다.

** 추가적으로 유클리디안 거리 공식으로 계싼을 하면 거리의 최대값이라는 게 없어서 뭔가와 비교할 수가 없다.** 그래서 이 거리를 0 ~ 1 사이의 값으로 갖도록 정규화? 하는 방법을 아래와 같이 사용하기도 한다.

유클리디안 거리 공식을 이용해 얻은 거리의 값을 Ed 라고 한다면

이렇게 표현한다면 가장 가까운 경에는 1에 가까울 것이고 멀수록 0에 가까운 값을 갖게 된다.

전체적인 K-mean 알고리즘의 순서는 다음과 같이 구성됩니다.

원하는 클러스터의 수(K)를 결정합니다. 무작위로 클러스터의 수와 같은 K개의 중심점(centroid)을 선정합니다. 이들은 각각의 클러스터를 대표합니다. 나머지 점들과 모든 중심점 간의 유클리드 거리를 계산한 후, 가장 가까운 거리를 가지는 중심점의 클러스터에 속하도록 합니다. 각 K개의 클러스터의 중심점을 재조정합니다. 특정 클러스터에 속하는 모든 점들의 평균값이 해당 클러스터 다음 iteration의 중심점이 됩니다.(이 중심점은 실제로 존재하는 데이터가 아니어도 상관없습니다.) 재조정된 중심점을 바탕으로 모든 점들과 새로 조정된 중심점 간의 유클리드 거리를 다시 계산한 후, 가장 가까운 거리를 가지는 클러스터에 해당 점을 재배정합니다. 4번과 5.번을 반복 수행합니다. 반복의 횟수는 사용자가 적절히 조절하면 되고, 특정 iteration 이상이 되면 수렴(중심점이 더 이상 바뀌지 않음)하게 됩니다.

from sklearn.cluster import KMeans

# 1), 2) 위에서 생성한 무작위 점 데이터(points)에 클러스터의 수(K)가 5인 K-means 알고리즘을 적용 
kmeans_cluster = KMeans(n_clusters=5)

# 3) ~ 6) 과정이 전부 함축되어 있는 코드입니다. points에 대하여 K가 5일 때의 K-means iteration을 수행
kmeans_cluster.fit(points)

print(type(kmeans_cluster.labels_))
print(np.shape(kmeans_cluster.labels_))
print(np.unique(kmeans_cluster.labels_))

output

K-means 결과를 시각화해서 확인해 보겠습니다.

# n 번째 클러스터 데이터를 어떤 색으로 도식할 지 결정하는 color dictionary
color_dict = {0: 'red', 1: 'blue', 2:'green', 3:'brown', 4:'indigo'} 

# 점 데이터를 X-Y grid에 시각화합니다.
fig = plt.figure()
ax = fig.add_subplot(1, 1, 1)

# K-means clustering의 결과대로 색깔별로 구분하여 점에 색칠한 후 도식
for cluster in range(5):
    cluster_sub_points = points[kmeans_cluster.labels_ == cluster] # 전체 무작위 점 데이터에서 K-means 알고리즘에 의해 군집화된 sub data를 분리합니다. 
    ax.scatter(cluster_sub_points[:, 0], cluster_sub_points[:, 1], c=color_dict[cluster], label='cluster_{}'.format(cluster)) # 해당 sub data를 plot합니다.

# 축 이름을 라벨에 달고, 점 데이터 그리기
ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.legend()
ax.grid()

처음에 우리가 중심점 5개인 무작위 데이터를 생성하고 나서, 이를 K-means 알고리즘을 활용해 5개의 군집으로 분류한 결과가 위와 같습니다.

그런데 사실, K-means 알고리즘이 항상 만능열쇠는 아닙니다. 주어진 데이터의 분포에 따라 우리가 의도하지 않은 결과를 초래할 수 있어요.

K-means 알고리즘이 잘 동작하지 않는 예시들

• 다음 코드를 통해 어떤 특성의 데이터들이 K-means 알고리즘을 적용하였을 때 잘 군집화되지 않는지 살펴보도록 하겠습니다.

  # K-means algorithm이 잘 동작하지 않는 예시 (1) 원형 분포
  from sklearn.datasets import make_circles
  

원형 분포 데이터 생성

circle_points, circle_labels = make_circles(n_samples=100, factor=0.5, noise=0.01) # 원형 분포를 가지는 점 데이터 100개를 생성합니다.

캔버스 생성

fig = plt.figure() ax = fig.add_subplot(1, 1, 1)

원형 분포에 대해 K-means 수행

circle_kmeans = KMeans(n_clusters=2) circle_kmeans.fit(circle_points) color_dict = {0: 'red', 1: 'blue'} for cluster in range(2): cluster_sub_points = circle_points[circle_kmeans.labels_ == cluster] ax.scatter(cluster_sub_points[:, 0], cluster_sub_points[:, 1], c=color_dict[cluster], label='cluster_{}'.format(cluster)) ax.set_title('K-means on circle data, K=2') ax.set_xlabel('X') ax.set_ylabel('Y') ax.legend() ax.grid()

![](https://images.velog.io/images/deep_lini/post/a0f1dcbe-8d0e-4b7f-9430-647a3f05d382/%E1%84%89%E1%85%B3%E1%84%8F%E1%85%B3%E1%84%85%E1%85%B5%E1%86%AB%E1%84%89%E1%85%A3%E1%86%BA%202022-02-23%2014.34.05.png)
첫 번째 원형으로 분포되어 있는 데이터 같은 경우는 아마 대부분의 사람들이 '가운데 작은 원'과 '바깥쪽 큰 원' 두 개의 군집으로 분류하기를 원했을 거예요. 하지만 K-means 알고리즘은 이 데이터들을 마치 케잌을 칼로 자르듯이 반으로 나눴네요.

K-means algorithm이 잘 동작하지 않는 예시 (2) 달 모양 분포

from sklearn.datasets import make_moons

달 모양 분포의 데이터 생성

moon_points, moon_labels = make_moons(n_samples=100, noise=0.01) # 달 모양 분포를 가지는 점 데이터 100개를 생성합니다.

캔버스 생성

fig = plt.figure() ax = fig.add_subplot(1, 1, 1)

달 모양 분포 데이터 plot

moon_kmeans = KMeans(n_clusters=2) moon_kmeans.fit(moon_points) color_dict = {0: 'red', 1: 'blue'} for cluster in range(2): cluster_sub_points = moon_points[moon_kmeans.labels_ == cluster] ax.scatter(cluster_sub_points[:, 0], cluster_sub_points[:, 1], c=color_dict[cluster], label='cluster_{}'.format(cluster)) ax.set_title('K-means on moon-shaped data, K=2') ax.set_xlabel('X') ax.set_ylabel('Y') ax.legend() ax.grid()

```

두 번째 초승달 모양의 데이터도 마찬가지예요. 두 개의 달 형태를 분리해서 군집화하지 않고, 이 역시 y축에 대하여 칼로 자른 형태의 느낌으로 두 개의 군집을 나눴네요.

이걸로 비지도학습에대해 마치겠습니다 !

  -Lag 에서 Data의 Trend를 찾는다.

  -ARIMA Model

import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib as mpl
import matplotlib.pyplot as plt

mpl.rc("font", family = "Malgun Gothic")

필요한 모듈을 import 해줍니다.

df1= pd.read_csv("C:/000/data11.csv")

데이터를 불러와 줍니다.

df1.info()

info() 함수로 data의 형태를 check해 줍니다.

df1.head()

구매일    구매금액    물품대분류

0 2018-04-20 57120 기저귀 1 2018-04-20 15900 더블하트 2 2018-04-20 7000 더블하트 3 2018-04-20 20900 더블하트 4 2018-05-06 26500 더블하트

head()함수로 data 위 5개를 살펴봅니다.

df1["Datetime"] = pd.to_datetime(df1["구매일"])
df1

구매일이 object 로 되어있기 때문에 dtype를 datetime 형태로 바꿔줍니다.

pd.todatetime()

구매일    구매금액    물품대분류    Datetime

0 2018-04-20 57120 기저귀 2018-04-20 1 2018-04-20 15900 더블하트 2018-04-20 2 2018-04-20 7000 더블하트 2018-04-20 3 2018-04-20 20900 더블하트 2018-04-20 4 2018-05-06 26500 더블하트 2018-05-06 ... ... ... ... ... 803670 2020-08-06 30960 더블하트 2020-08-06 803671 2020-08-06 6640 더블하트 2020-08-06 803672 2020-08-06 5600 더블하트 2020-08-06 803673 2020-08-06 7840 더블하트 2020-08-06 803674 2020-08-06 8500 기타 2020-08-06 803675 rows × 4 columns

df1["Datetime"].describe()

count 803675 unique 589 top 2019-10-11 00:00:00 freq 10500 first 2018-04-20 00:00:00 last 2020-08-07 00:00:00 Name: Datetime, dtype: object

describe()를 볼때, data의 처음은 first,

data 마지막은 last,

data중 제일 많이 차지하는건 top

전체 data는 589일(unique) - 판매가 안된 날짜가 있ㄷ. ex)주말휴무

df1["year"] =df1["Datetime"].dt.year
df1["month"] =df1["Datetime"].dt.month
df1["week"] =df1["Datetime"].dt.week
df1["day_of_week"] =df1["Datetime"].dt.day_name()

연도,월,일 로 바꿔준다.

시각화

sns.lineplot(data=df1, x="Datetime", y="구매금액", estimator=sum)

data가 80만개라 lineplot 그리면 시간이 오래걸리니 피보팅을 하여 시리즈를 정리해주고,피보팅한 변수로 lineplot을 그려준다. 시간도 효율적이고 값도 똑같다.

# 일별 구매계산 합
p1 = pd.pivot_table(data=df1,
                    index="Datetime", values="구매금액", aggfunc="sum").reset_index()

p1

Datetime    구매금액

0 2018-04-20 100920 1 2018-05-06 26500 2 2018-05-14 20600 3 2018-08-12 75700 4 2018-09-01 48300 ... ... ... 584 2020-08-03 27560340 585 2020-08-04 31832500 586 2020-08-05 27683180 587 2020-08-06 22574070 588 2020-08-07 12099370 589 rows × 2 columns

sns.lineplot(data=p1, x="Datetime", y="구매금액")

p2 = pd.pivot_table(data=df1,
                    index=["Datetime","물품대분류"], values="구매금액", aggfunc="sum").reset_index()
print(p2)

p2 를 출력해봅니다.

• 더블하트라는 물품이 제일 많이 팔린 것 을 볼 수 있습니다.(유아용품에 대한 Data)
• White_noise 를 생각하며 data를 분석해봅니다.
• 더블하트제툼을 볼때 판매량이 많은 것 을 감안하여, 어떤이벤트가 있었거나 물품대란이 있었을 수 도있다는 가정을 해보자.
• 시계열 분석을 할때에는 시각화를 하여, 확인을 해보는게 낫다.

# 기저귀 data 만 따로 뽑아 분석
# 2018년에는 1개에 data 만 존재하고 2019부터 data가 존재하므로 빼는 것 이 낫다는 결론.
cond1 = (df1["물품대분류"] == "기저귀")
df1.loc[cond1]

구매일    구매금액    물품대분류    Datetime    year    month    week    day_of_week

0 2018-04-20 57120 기저귀 2018-04-20 2018 4 16 Friday 29 2019-05-13 59520 기저귀 2019-05-13 2019 5 20 Monday 30 2019-05-10 50640 기저귀 2019-05-10 2019 5 19 Friday 31 2019-06-06 50640 기저귀 2019-06-06 2019 6 23 Thursday 32 2019-07-01 50640 기저귀 2019-07-01 2019 7 27 Monday ... ... ... ... ... ... ... ... ... 803578 2020-06-25 43400 기저귀 2020-06-25 2020 6 26 Thursday 803602 2020-06-26 43400 기저귀 2020-06-26 2020 6 26 Friday 803610 2020-06-28 49900 기저귀 2020-06-28 2020 6 26 Sunday 803631 2020-07-09 49900 기저귀 2020-07-09 2020 7 28 Thursday 803632 2020-07-25 49900 기저귀 2020-07-25 2020 7 30 Saturday

df2 = df1.loc[cond1].iloc[1:]
df2.head()

구매일 구매금액 물품대분류 Datetime year month week day_of_week 29 2019-05-13 59520 기저귀 2019-05-13 2019 5 20 Monday 30 2019-05-10 50640 기저귀 2019-05-10 2019 5 19 Friday 31 2019-06-06 50640 기저귀 2019-06-06 2019 6 23 Thursday 32 2019-07-01 50640 기저귀 2019-07-01 2019 7 27 Monday 33 2019-07-29 101280 기저귀 2019-07-29 2019 7 31 Monday

ARIMA(Auto Regressive Inegrated Moving Average)

• ARIMA 사용 시기 및 조건
  • 단기예측에 적합
  • 계절적 변동요인 (주기적 변동요인)
  • 표본의 크기가 최소 50개 이상
  • 정상적(Stationary)자료에 적용 가능
    • 평균이 증가/감소 -> 차분(Difference)을 실시
    • 분산이 증가/감소 -> Lag 변환

3가지가 조합된 모델

* AR(Auto Regressive Model) : 자기회귀모델 - ex)주식 - 어제마감했던금액이 다음날의 영향을주는 것

- P 시점 전의 자료가 현재 시점의 데이터에 영향을 주는 자기회귀모델
- 자기상관함수 (ACF : Auto Correlation Function) 
    - p 구간 내 데이터 사이의 상관관계 (교회 - 범죄 - [인구])
- 부분자기상관함수 (PACF : Partial Auto Correlation Function) : 
    - 다른 시점의 데이터들의 영향을 제외한 두 관측치 사이의 상관관계 (교회 

- 범죄 !- [인구])  
- 일반적인 AR 모델에서는 ACF는 일정히 감소 / PACF가 절단면을 갖는다 
- ACF와 PACF를 확인하여 분석 모델을 선택한다 

* MA(Moving Average Model) : 이동평균모델 - 특정데이터의 평균을 계산

- 일정한 p구간의 데이터들의 평균을 계산하여, 미래를 예측하는 방법 
- 시계열의 불규칙적인 변동을 제거하기 위함 

* Difference(차분) : 정상적으로 변환해주는 작업

 - 정상성(Stationary)을 만족하지 못하는 시계열 데이터를 정상성이 만족하는 데이   터로 변환 
 - AR만 사용하면 변동자료들의 설명이 떨어짐 그래서 MA(이동평균모델)을 같이 사용해 줍니다.

AR, MA 모델에 차분까지 집어넣은 모델이 Arima-Model 이다.

** ARIMA Model** (사용하기 위한 조건)

• 단기예측에 적합
• 계절적 변동요인 (주기적 변동)
• sample수가 많아야함. 기본적으로 Sample > 50
• 정성적자료(나열했을때 일정한 trend를 갖는) -> 차분

# ARIMA_model 을 쓸떄 사용하는 모듈
import statsmodels.tsa.api as tsa

df2.head()

df2의 head()를 찍어 봅니다.

df_time = pd.pivot_table(data=df2, index="Datetime",
                         values="구매금액", aggfunc="sum")
df_time.head()

구매금액

Datetime
2019-01-01 3051240 2019-01-02 2556280 2019-01-03 2729480 2019-01-04 2238440 2019-01-05 2478680

예를 들어서 밑에 방법으로도 사용 가능

• set_index를 사용하여

# df_time = pd.pivot_table(data=df2, index="Datetime",
#                          values="구매금액", aggfunc="sum").reset_index()
# df_time.head().set_index("Datetime")
# # 일주일 단위로 평균 금액을 계산해줌
# EX) 1Y, 1M, 1W, 1D
# y = df_time["구매금액"].resample("1W").mean()
# y

y = df_time["구매금액"].resample("1D").mean()
y

Datetime 2019-01-01 3051240.0 2019-01-02 2556280.0 2019-01-03 2729480.0 2019-01-04 2238440.0 2019-01-05 2478680.0 ...
2020-08-03 3075900.0 2020-08-04 4010200.0 2020-08-05 2937800.0 2020-08-06 2647000.0 2020-08-07 1022300.0 Freq: D, Name: 구매금액, Length: 585, dtype: float64

#결측치를 채우기 위한 것중, 그나마 괜찮은방법이 .fillna(method="bfill") 사용

이전자료를 대처값으로 채워줌(여기선 전날 data로 채워 줌)

• bfill 은 이전데이터를 결측치에 채워줌.(Backward)
• ffill 은 다음데이터를 결측치에 채워줌.(Forward)

# Missing 값이 있는 경우에
y1  = y.fillna( method="ffill")
y1.isnull().sum()

*시계열 모델 생성과 모델 시각화

• 주단위로 했을 때, 데이터 수가 50개 채 되지않아, tsa.seasonal_decompose에 적합하지 않기 때문에 일단위평균값으로 맟춤

• 분해 시계열

  • 시계열에 영향을 주는 일반적 요인을 시계열에서 분리해 분석하는 방법
  • 계절요인 Seasonal
  • 추세요인 Trend
  • 순환요인 Cyclical
  • 불규칙요인 Irregular

from pylab import rcParams

rcParams["figure.figsize"]= 13,10 #그래프의 SIZE를 조정해주는 함수

# #차트 기본 크기 설정
# mpl.rcParams['axes.labelsize'] = 14
# mpl.rcParams['xtick.labelsize'] = 12
# mpl.rcParams['ytick.labelsize'] = 12
# mpl.rcParams['text.color'] = 'k'

#시계열 모델 생성

model_series = tsa.seasonal_decompose(y1, model="additive")

#모델 시각화
fig = model_series.plot()
plt.show()

import itertools # 반복수를 만드는 라이브러리 
p = d  = q = range(0, 2)
pdq = list(itertools.product(p, d, q))
seasonal_pdq = [(x[0], x[1], x[2] , 12) for x in list(itertools.product(p, d, q))]

seasonal_pdq

seasonal_pdq를 출력해 봅니다. [(0, 0, 0, 12), (0, 0, 1, 12), (0, 1, 0, 12), (0, 1, 1, 12), (1, 0, 0, 12), (1, 0, 1, 12), (1, 1, 0, 12), (1, 1, 1, 12)]

param_list = []
param_seasonal_list = []
results_AIC_list = []

for param in pdq:
    for param_seasonal in seasonal_pdq:
        try:
            mod = tsa.statespace.SARIMAX(y1, order=param,
                                        seasonal_order= param_seasonal,
                                        enforce_stationarity=False,
                                        enforce_invertibility=False)
            results = mod.fit()
            param_list.append(param)
            param_seasonal_list.append(param_seasonal)
            results_AIC_list.append(results.aic)
        except:
            continue

ARIMA_list = pd.DataFrame({'Parameter':param_list,'Seasonal':param_seasonal_list,'AIC':results_AIC_list})
ARIMA_list.to_excel('arima_model_list.xlsx')

• Likelihood (최대우도) : 특정 데이터가 모수로부터 추출되었을 가능도
  • 특정 값에 대한 분포의 확률 추정 (연속 확률 밀도 함수 pdf의 y값)

• AIC (Akaike Information Criterion) : 데이터에 대한 모델의 상대적 품질
  • AIC = -2 ln(L) + 2k
  • 값이 낮을 수록 모형 적합도가 높은것을 의미

• BIC (Bayes Information Criterion)
  • BIC = -2 ln(L) + log(n)p
  • 변수가 더 많은 경우, AIC에 더 많은 패널티를 부여해 계산

• HQIC (Hannan Quinn Information Criterion)
  • HQIC = -2 ln(L) + 2k ln(ln(n))

mod = tsa.statespace.SARIMAX(y1,order=(0, 1, 1),seasonal_order=(0, 1, 1, 12),
                              enforce_stationarity=False, enforce_invertibility=False)
results = mod.fit()
print(results.summary())

mod = tsa.statespace.SARIMAX(y1,order=(0, 1, 1),seasonal_order=(0, 1, 1, 12), enforce_stationarity=False, enforce_invertibility=False) results = mod.fit() print(results.summary()) mod = tsa.statespace.SARIMAX(y1,order=(0, 1, 1),seasonal_order=(0, 1, 1, 12), enforce_stationarity=False, enforce_invertibility=False) results = mod.fit() print(results.summary()) SARIMAX Results
========================================================================================== Dep. Variable: 구매금액 No. Observations: 585 Model: SARIMAX(0, 1, 1)x(0, 1, 1, 12) Log Likelihood -9521.297 Date: Wed, 22 Sep 2021 AIC 19048.594 Time: 14:34:08 BIC 19061.567 Sample: 01-01-2019 HQIC 19053.660 - 08-07-2020
Covariance Type: opg
============================================================================== coef std err z P>|z| [0.025 0.975]

ma.L1 -0.0721 0.063 -1.137 0.256 -0.196 0.052 ma.S.L12 -0.9948 0.022 -45.508 0.000 -1.038 -0.952 sigma2 6.593e+13 nan nan nan nan nan =================================================================================== Ljung-Box (L1) (Q): 0.21 Jarque-Bera (JB): 324.63 Prob(Q): 0.65 Prob(JB): 0.00 Heteroskedasticity (H): 0.42 Skew: 0.31 Prob(H) (two-sided): 0.00 Kurtosis: 6.69 ===================================================================================

Warnings: [1] Covariance matrix calculated using the outer product of gradients (complex-step). [2] Covariance matrix is singular or near-singular, with condition number 9.18e+43. Standard errors may be unstable.

Order (p,d,q), Seasonal Order (P,D,Q,M)

• p : AR에서의 p값 (p 구간 내 데이터 사이의 상관관계)

• d : 차분

• q : q MA PACF 편상관계수 q 값

• P

• D

• Q

• M

• Ljung - Box Test : 일정 기간동안 관측치가 랜덤이고, 독립적인지 여부를 검정

• 귀무 : 데이터가 상관관계를 나타내지 않는다.

• 대립 : 데이터가 상관관계를 나타낸다.

• P.value(귀무가설이 참일 확률) < 0.05 (유의수준) -> 대립가설 참

• Jarque Bera Test : 왜도와 첨도가 정규분포와 일치하는지 가설검정

• SARIMAX : 잔차의 분포가 정규분포 인가

• 귀무 가설 : 해당 잔차(residual)는 정규분포와 일치한다.

• 대립 가설 : 해당 잔차(residual)는 정규분포와 일치하지 않는다.

• P.value < 0.05 , 해당 잔차(residual)는 정규분포와 일치하지 않는다.

results.plot_diagnostics(figsize=(16, 8))
plt.show()

results.get_prediction()

<statsmodels.tsa.statespace.mlemodel.PredictionResultsWrapper at 0x202851c0700>