Box World

GPT-5가 바꾸는 LLM의 법칙: 단일 모델 시대의 종말과 새로운 전략

Box형 — Thu, 21 Aug 2025 09:27:04 +0900

소개

지난 몇 년간 우리는 더 크고, 더 강력한 단일 모델의 등장을 숨 가쁘게 지켜봐왔습니다. 하지만 이제 게임의 규칙이 바뀌고 있습니다. "가장 강력한 모델 하나"를 넘어, 여러 모델이 유기적으로 협력하는 '지능형 시스템'의 시대가 열리고 있습니다. 이 글에서는 가상의 GPT-5 출시를 통해 드러난 새로운 LLM 패러다임을 심층적으로 분석합니다. 단순히 새로운 모델의 성능을 나열하는 대신, 이 변화가 개발자, 기획자, 그리고 기술 리더의 의사결정에 어떤 영향을 미치는지 구체적인 전략과 함께 살펴보겠습니다.

본문

1. 거대 모델의 시대는 끝났다: 팀 스포츠로의 전환

과거의 LLM 선택은 수동 변속기 차량을 운전하는 것과 같았습니다. 빠른 응답이 필요하면 가벼운 모델을, 깊이 있는 추론이 필요하면 무거운 모델을 직접 선택해야 했습니다. 모든 작업에 동일한 모델을 사용하며 성능과 비용 사이에서 끊임없이 저울질해야 했습니다.

이제 LLM은 하나의 거대한 두뇌가 아닌, 각기 다른 역할을 수행하는 전문가들로 구성된 '팀'으로 진화하고 있습니다. 이 팀의 중심에는 모든 요청을 지능적으로 분배하는 컨트롤 타워, 즉 '실시간 라우터'가 있습니다.

2. GPT-5의 심장, '실시간 라우터'의 작동 방식

[수정된 설명]
스크립트에서는 라우터가 항상 최고 성능 모델(GPT-5 Pro)로 요청을 보내 품질을 보장한다고 언급했지만, 실제 핵심은 그 반대입니다. 실시간 라우터의 진정한 역할은 '동적 컴퓨팅(Dynamic Compute)' 입니다. 즉, 모든 요청을 가장 비싸고 강력한 모델로 보내는 것이 아니라, 요청의 복잡도와 의도를 실시간으로 파악하여 가장 적합한 모델에 동적으로 할당하는 것입니다.

이 시스템은 다음과 같이 구성됩니다.

실시간 라우터(Real-time Router): 시스템의 총괄 프로젝트 매니저입니다. "오늘 날씨 어때?"와 같은 단순 요청은 빠른 주력 모델에게, "이 복잡한 코드의 버그를 찾고 리팩토링해줘"와 같은 복잡한 요청은 전문가 모델에게 할당하여 자원을 효율적으로 사용합니다.
GPT-5 모델 제품군(Model Suite):
- Pro 모델: 복잡한 추론, 분석, 창의적 생성을 담당하는 전문가입니다. 비용은 높지만 최고의 성능을 보장합니다.
- Standard 모델: 대부분의 일상적인 작업을 빠르고 효율적으로 처리하는 주력 선수입니다.
- 경량 모델(Mini/Nano): 대규모 트래픽을 저비용, 저지연으로 처리하는 데 특화된 모델입니다.

[보강된 설명]
이 라우터는 단순히 사전에 정의된 규칙에 따라 움직이는 if-else 구문이 아닙니다. 사용자의 피드백("깊게 생각해봐"와 같은 명시적 지시 포함)을 통해 지속적으로 학습하고 라우팅 정책을 개선하는 강화 학습(Reinforcement Learning) 루프를 포함하고 있습니다. 이는 개발자가 직접 라우팅 로직을 구현해야 했던 기존 방식(e.g., Claude Opus/Sonnet/Haiku)과 차별화되는 지점으로, '그냥 더 잘 작동하는' 매끄러운 경험을 제공하는 핵심 기술입니다.

[시각 자료 제안]
사용자 요청 -> 실시간 라우터 -> (분기) -> Pro 모델 / Standard 모델 / 경량 모델 로 이어지는 간단한 아키텍처 다이어그램을 삽입하면 독자의 이해를 도울 수 있습니다.

3. 열린 생태계와 닫힌 생태계의 공존: OpenAI의 이중 전략

이번 변화에서 가장 주목할 만한 전략적 움직임은 최고 성능의 독점 API와 함께, 매우 유능한 오픈 가중치 모델(Open-weight Model)을 동시에 제공한다는 점입니다. 이는 단순한 선택지 추가가 아닌, 시장 전체를 장악하려는 고도의 플랫폼 전략입니다.

진입 장벽 완화: 개발자와 기업은 오픈 가중치 모델을 통해 비교적 낮은 비용으로 LLM 도입을 시작하고, 자체 데이터로 미세 조정(Fine-tuning)하며 기술 내재화를 꾀할 수 있습니다.
생태계 포섭(Ecosystem Envelopment): [보강된 설명] 이는 경쟁 오픈소스 모델(e.g., Llama, Mistral)의 위협을 무력화하고, 오픈소스 개발자들을 자사 생태계 안으로 끌어들이는 '깔때기(funnel)' 역할을 합니다. 일단 생태계에 진입한 사용자가 더 높은 성능이나 안정성을 원할 때, 가장 자연스러운 다음 단계는 자사의 상위 API 모델로 전환하는 것이기 때문입니다.

결과적으로, 조직은 데이터 주권과 규제 준수가 중요한 작업은 온프레미스(On-premise, 자체 서버에 직접 설치) 환경의 오픈 가중치 모델로 처리하고, 최고 수준의 성능이 필요한 작업은 API를 호출하는 유연한 하이브리드 아키텍처를 구축할 수 있게 됩니다.

4. 개발자의 새로운 현실: '바이브 코딩'과 책임의 균형

LLM의 발전은 개발 생산성을 극적으로 끌어올렸습니다. 아이디어를 즉시 코드로 구현하는 이른바 '바이브 코딩(Vibe Coding)' 은 프로토타이핑과 데모 제작 속도를 혁신적으로 단축시킵니다.

하지만 이는 양날의 검입니다. AI가 생성한 코드를 검증 없이 운영 환경에 적용하는 것은 조용히 기술 부채와 보안 취약점을 쌓는 것과 같습니다. [보강된 설명] 우리는 AI를 '엄청나게 똑똑하지만 사회 경험이 없는 인턴'으로 대해야 합니다. 아이디어 구현 속도는 뛰어나지만, 그 결과물은 반드시 숙련된 시니어 개발자의 감독과 검증을 거쳐야 합니다.

따라서 다음과 같은 AI 거버넌스 원칙을 개발 파이프라인에 내장해야 합니다.

인간 검토 필수: 모든 AI 생성 코드는 머지(Merge) 전에 반드시 동료 개발자의 코드 리뷰를 거칩니다.
보안 요구사항 명시: 프롬프트에 입력값 검증, 비밀 정보 처리(환경 변수 사용), 일반적인 웹 취약점 방어 등 보안 요구사항을 명확히 포함시킵니다.
CI/CD 파이프라인 자동화: 코드 통합 시 정적 분석 보안 테스트(SAST)와 비밀 정보 스캐닝을 자동화하여 사람의 실수를 방지합니다.

생성 속도가 빨라진 만큼, 검증과 감사의 속도도 자동화를 통해 높여야만 지속 가능한 개발이 가능합니다.

결론: 당신의 다음 행동 계획

거대한 단일 모델에 모든 것을 의존하던 시대는 저물고 있습니다. 이제는 상황에 맞게 최적의 도구를 조합하고 지능적으로 분배하는 '시스템 아키텍처' 관점이 중요해졌습니다.

당장 내일부터 적용할 수 있는 액션 아이템은 다음과 같습니다.

AI 게이트웨이 구축: 모든 LLM 요청을 단일 창구(게이트웨이)를 통해 관리하세요. 이를 통해 요청의 민감도, 복잡도, 비용 기준에 따라 사내 모델과 외부 API로 라우팅하는 규칙을 중앙에서 관리할 수 있습니다.
내부 벤치마크 수립: 공개된 순위표에만 의존하지 마세요. 우리 회사의 실제 데이터와 핵심 과제를 바탕으로 한 내부 성능 평가 기준을 만들고, 주기적으로 여러 모델을 테스트하여 최적의 솔루션을 찾아야 합니다.
AI 코드 검증 프로세스 확립: '바이브 코딩'의 생산성을 수용하되, 프롬프트 가이드라인, 자동화된 보안 스캔, 동료 리뷰를 포함한 코드 검증 프로세스를 개발 문화의 기본값으로 설정하세요.

API의 민첩함과 온프레미스의 통제력을 현명하게 조합하고, 빠른 생성 속도를 자동화된 검증으로 뒷받침하는 팀이 앞으로의 AI 시대를 주도하게 될 것입니다.

핵심 내용 퀴즈

이 글을 잘 이해했는지 간단한 퀴즈로 확인해보세요!

Q1. GPT-5 시스템의 '실시간 라우터'는 사용자 요청을 어떻게 처리하는 것이 핵심 원칙인가요?
a) 모든 요청을 항상 최고 성능의 Pro 모델로 보내 최고의 품질을 보장한다.
b) 요청의 복잡도를 분석하여 가장 비용 효율적인 모델에 동적으로 할당한다.
c) 사용자가 직접 모델을 선택할 때까지 대기한다.
d) 무작위로 여러 모델에 요청을 분산시킨다.

Q2. OpenAI가 강력한 API와 함께 오픈 가중치 모델을 출시하는 가장 큰 전략적 이유는 무엇일까요?
a) 모든 소프트웨어를 무료로 제공하기 위한 자선 활동이다.
b) 개발자들이 쉽게 LLM을 시작하게 하여 자사 생태계로 유입시키고, 궁극적으로 상위 API 사용자로 전환시키기 위함이다.
c) API 서버의 부하를 줄이기 위해서다.
d) 오픈소스 커뮤니티의 피드백을 받아 모델을 개선하기 위해서다.

Q3. '바이브 코딩'으로 AI가 생성한 코드를 운영 환경에 적용할 때, 보안과 품질을 위해 가장 중요한 원칙은 무엇인가요?
a) AI가 만든 코드는 완벽하므로 별도의 검증 없이 즉시 배포한다.
b) 코드 생성 속도를 높이기 위해 동료 리뷰와 같은 절차는 생략한다.
c) AI가 똑똑한 주니어 개발자라고 생각하고, 반드시 인간의 코드 리뷰와 자동화된 보안 검증 절차를 거친다.
d) 프롬프트 작성에만 집중하고, 생성된 코드의 내용은 신경 쓰지 않는다.

정답 확인

Q1: b) 요청의 복잡도를 분석하여 가장 비용 효율적인 모델에 동적으로 할당한다.

Q2: b) 개발자들이 쉽게 LLM을 시작하게 하여 자사 생태계로 유입시키고, 궁극적으로 상위 API 사용자로 전환시키기 위함이다.

Q3: c) AI가 똑똑한 주니어 개발자라고 생각하고, 반드시 인간의 코드 리뷰와 자동화된 보안 검증 절차를 거친다.

이제 트랜스포머의 시대는 끝날까? Google Titans 논문 리뷰

Box형 — Sun, 9 Feb 2025 15:34:15 +0900

무언가가 충분히 중요하다면 확률이 당신에게 유리하지 않더라도 시작하라

- 일론 머스크 -

Introduction:

ChatGPT 같은 AI 모델이 이전 대화 내용을 기억하는 것처럼 보이는 게 신기하지 않으셨나요? 마치 진짜 기억력이 있는 것 같죠! 하지만 기존 AI 모델, 특히 엄청나게 강력한 Transformer 모델들은 사실 기억력에 약간 문제가 있습니다. 엄청나게 큰 책을 읽으려고 하는데 한 번에 몇 페이지만 집중할 수 있는 상황이라고 생각해보세요. Transformer의 "attention" 메커니즘이 대단하긴 하지만, 너무 많은 걸 기억하려고 하면 속도가 느려지고 엄청난 컴퓨팅 파워를 잡아먹거든요. 이 논문에서는 "Titans"라는 새로운 종류의 AI 아키텍처를 소개합니다. 이 녀석은 방대한 양의 정보를 다룰 때도 효과적으로 기억하는 방법을 스스로 학습하도록 설계되었죠. AI 모델에게 우리처럼 더 나은 장기 기억 능력을 부여하는 거라고 보시면 됩니다!

Motivation & Contribution:

그럼 AI에게 기억력이 왜 그렇게 중요할까요? 만약 영화의 마지막 몇 장면만 기억할 수 있다면 전체 줄거리를 이해할 수 있을까요? 연결고리나 큰 그림을 놓치게 되겠죠. 마찬가지로, AI가 긴 이야기, 비디오, 심지어 시간의 흐름에 따른 과학 데이터 같은 복잡한 데이터를 제대로 이해하려면, 최근 정보뿐만 아니라 훨씬 이전의 정보도 기억해야 합니다.

문제점: 현대 AI의 핵심인 Transformer는 제한된 "context window" 내에서 관계를 파악하는 데는 환상적입니다. 마치 책의 몇 페이지처럼요. 하지만 context가 책 전체처럼 엄청 길어지면, Transformer는 힘들어합니다. 속도가 느려지고 엄청난 컴퓨터 메모리를 필요로 하죠. 왜냐하면 Transformer의 attention 메커니즘은 quadratic cost를 갖기 때문입니다. 즉, context 길이가 길어질수록 처리 비용이 엄청나게 빠르게 증가한다는 뜻이죠. Linear Transformer는 이 속도 문제를 해결하기 위해 발명되었지만, 정보를 작은, 고정 크기 메모리에 너무 많이 압축하기 때문에 정확도가 떨어지는 경우가 많습니다. 마치 전체 책을 몇 개의 요점으로 요약하는 것과 같아요. 많은 세부 정보가 사라지죠!

새로운 점 & 기여: Titans와 Neural Long-Term Memory의 등장! 이 논문의 핵심 아이디어는 AI 모델에게 attention의 단기 기억과는 별개의, 학습 가능한 long-term memory 모듈을 제공하는 겁니다. 마치 현재 문장에 집중하는 작업 기억 (attention)과 전체 책에서 얻은 지식 (long-term memory)을 함께 사용하는 것과 같죠.

핵심적인 새로운 점: Titans는 테스트 시간에 기억하는 법을 학습하는 neural long-term memory를 도입합니다. 이건 단순히 데이터를 저장하는 게 아니라, AI가 정보를 처리하면서 효과적으로 기억하는 방법을 능동적으로 학습하는 거죠. 인간의 기억에서 영감을 얻어 "surprise" 메트릭을 사용하여 무엇을 기억할지 결정합니다. 이건 meta-learning 접근 방식입니다. 메모리 모듈이 학습하고 기억하는 방법을 학습하는 거죠. 게다가, 이들은 이 long-term memory를 Titans라고 부르는 아키텍처에서 전통적인 attention (short-term memory)과 통합하는 다양한 방법을 설계하여 유연성과 효율성을 제공합니다. 이것은 단순히 attention을 더 빠르게 만드는 것에서 벗어나, AI 모델이 메모리를 처리하는 방식을 근본적으로 다시 생각하는 중대한 변화입니다. 인간의 인지에서 영감을 얻은 거죠! 한마디로: "Attention은 현재에 집중하는 데는 좋지만, 과거를 위해서는 다른 종류의 메모리가 필요하고, AI는 그걸 효과적으로 사용하는 법을 학습할 수 있다!"라고 말하는 겁니다.

Method:

자, 이제 Titans가 실제로 어떻게 기억하는 법을 배우는지 자세히 알아봅시다. 좀 복잡하게 들릴 수도 있지만, 차근차근 살펴볼게요.

1. Neural Long-Term Memory: Surprise로부터 배우기

Titans의 핵심은 neural long-term memory module입니다. 이 모듈은 과거의 정보를 저장하고 검색하는 방법을 배우는 별도의 neural network와 같습니다. 그런데 무엇을 기억할지는 어떻게 결정할까요? 핵심 아이디어는 바로 surprise입니다!

생각해보세요. 놀랍거나 예상치 못한 일을 더 잘 기억하는 경향이 있잖아요? Titans의 메모리 모듈도 비슷하게 작동합니다. surprise metric을 사용해서 각각의 새로운 정보가 얼마나 "예상 밖"인지 파악하는 거죠.

이 surprise metric은 neural network의 입력에 대한 gradient를 사용하여 계산됩니다. "gradient"라는 기술 용어에 너무 얽매이지 마세요. 그냥 모델의 "기대"가 새로운 입력에 의해 얼마나 위반되는지를 측정하는 거라고 생각하면 됩니다. 큰 gradient는 높은 surprise를 의미합니다. 즉, 모델이 새롭거나 예상치 못한 것을 배우고 있다는 거죠.

메모리 업데이트 방정식 (초기 Surprise Metric):

$$M_t = M_{t-1} - \theta_t \nabla l(M_{t-1}; x_t)$$

하나씩 뜯어볼까요:

$M_t$: 현재 시점 $t$에서의 메모리입니다. 장기 기억의 현재 상태라고 생각하면 됩니다.
$M_{t-1}$: 이전 시점의 메모리입니다. 지금까지 쌓아온 메모리죠.
$x_t$: 현재 시점의 새로운 입력입니다.
$\nabla l(M_{t-1}; x_t)$: 이게 바로 surprise metric입니다. loss function $l$ (모델이 얼마나 잘 수행하고 있는지를 측정)의 메모리 $M_{t-1}$과 입력 $x_t$에 대한 gradient입니다. gradient가 클수록 surprise가 크다는 뜻이죠.
$\theta_t$: surprise에 따라 메모리가 얼마나 업데이트되는지를 제어하는 learning rate입니다.

쉽게 말하면: 메모리 $M_t$는 이전 메모리 $M_{t-1}$을 가져와서 surprise ($\nabla l(M_{t-1}; x_t)$)에 따라 조정하는 방식으로 업데이트됩니다. surprise가 클수록, 이 새롭고 예상치 못한 정보를 통합하기 위해 메모리가 더 많이 변합니다.

개념 체크포인트: 지금까지, 새로운 정보가 얼마나 놀라운지에 따라 업데이트되는 메모리 모듈을 살펴봤습니다. 이건 마치 장기 기억을 돋보이고 기대에 어긋나는 일에 집중시키는 것과 같죠.

2. Surprise Metric 개선: Past and Momentary Surprise

초기 surprise metric도 좋지만, 더 개선할 수 있습니다. 때로는 중요한 정보가 큰 surprise 이후에 나타날 수 있는데, surprise metric이 너무 빨리 작아지면 모델이 놓칠 수 있습니다. 이걸 해결하기 위해, Titans는 surprise metric을 두 부분으로 나누어 개선합니다.

Past Surprise ($S_{t-1}$): 최근 과거의 surprise를 측정합니다. 최근에 놀라운 일이 있었는지를 추적하는 것과 같습니다.
Momentary Surprise ($\nabla l(M_{t-1}; x_t)$): 현재 입력으로부터의 surprise입니다. 초기 metric과 동일하죠.

개선된 메모리 업데이트 방정식:

$$M_t = M_{t-1} + S_t$$
$$S_t = \eta_t S_{t-1} - \theta_t \nabla l(M_{t-1}; x_t)$$

자세히 살펴보죠:

$M_t$와 $M_{t-1}$는 이전과 마찬가지로 현재 및 이전 시점의 메모리입니다.
$S_t$: 시점 $t$에서의 total surprise입니다. 과거와 현재 surprise의 조합이죠.
$S_{t-1}$: 이전 시점의 past surprise입니다.
$\eta_t$: data-dependent surprise decay입니다. 과거 surprise ($S_{t-1}$)가 현재로 얼마나 많이 전달되는지를 제어합니다. $\eta_t$가 1에 가까우면 과거 surprise가 강한 영향을 미칩니다. 0에 가까우면 과거 surprise는 빠르게 잊혀지죠. 이건 context 변화를 처리하는 데 중요합니다.
$\theta_t$: 여전히 learning rate이며, momentary surprise가 업데이트에 얼마나 영향을 미치는지 제어합니다.
$\nabla l(M_{t-1}; x_t)$: 이전과 동일한 momentary surprise입니다.

쉽게 말하면: 메모리 $M_t$는 total surprise $S_t$를 더하여 업데이트됩니다. total surprise $S_t$는 past surprise*의 감쇠된 버전 ($ηt S{t-1}$)을 취하고 *momentary surprise ($\theta_t \nabla l(M_{t-1}; x_t)$)를 빼서 계산됩니다. $S_t$를 surprise의 "모멘텀"이라고 생각하면 됩니다. 과거 surprise를 축적하지만, 현재 surprise에 의해서도 구동되죠.

Gradient Descent with Momentum과의 유사성: 흥미롭게도, 저자들은 이 공식이 neural network에서 일반적인 최적화 기술인 gradient descent with momentum과 유사하다고 지적합니다. $S_t$는 모멘텀처럼 작용하여 "surprise" 신호를 시간 경과에 따라 전달합니다.

개념 체크포인트: 이제 과거와 현재 surprise를 모두 고려하는 더 정교한 surprise metric을 갖게 되었습니다. surprise decay ($\eta_t$)는 모델이 데이터 context에 따라 기억하는 방식을 조정할 수 있게 해줍니다. 이건 즉각적인 surprise에 반응할 뿐만 아니라 시간 경과에 따른 surprise 패턴에도 민감한 메모리를 갖는 것과 같죠.

3. Forgetting Mechanism: Adaptive Memory Management

매우 긴 시퀀스를 다룰 때, 단순히 메모리를 축적하기만 하면 "memory overflow"가 발생하고 성능이 저하될 수 있습니다. Titans는 메모리 용량을 관리하기 위해 forgetting mechanism을 도입합니다. 이 메커니즘은 과거 메모리를 얼마나 잊을지 적응적으로 결정합니다.

Forgetting Mechanism을 포함한 방정식:

$$M_t = (1 - \alpha_t) M_{t-1} + S_t$$

$M_t$, $M_{t-1}$, $S_t$는 이전과 동일합니다.
$\alpha_t$: data-dependent forgetting gate이며, 0과 1 사이의 값입니다. 이전 메모리 $M_{t-1}$을 얼마나 유지할지 제어합니다. $\alpha_t$가 0에 가까우면 이전 메모리의 대부분이 유지됩니다. 1에 가까우면 이전 메모리의 대부분이 잊혀지죠.

쉽게 말하면: 메모리 $M_t$는 이전 메모리 $M_{t-1}$의 일부분 $(1 - \alpha_t)$을 가져와서 total surprise $S_t$를 더하여 업데이트됩니다. forgetting gate $\alpha_t$는 현재 입력을 기반으로 과거 메모리를 얼마나 "decay"하거나 잊을지 학습합니다.

Weight Decay와의 유사성: 저자들은 또한 이 forgetting mechanism이 overfitting을 방지하는 데 도움이 되는 neural network의 regularization 기술인 weight decay와 관련이 있다고 언급합니다. 여기서는 memory overflow를 방지하고 관련 정보에 집중하는 데 사용됩니다.

개념 체크포인트: forgetting mechanism을 통해 Titans의 메모리는 적응적이고 효율적이 됩니다. 인간의 기억처럼 중요한 정보는 기억하고 덜 중요한 세부 사항은 잊는 법을 배울 수 있죠!

4. Titans 아키텍처: Long-Term Memory 통합

이제 neural long-term memory module이 있으니, 이걸 실제로 neural network 아키텍처에서 어떻게 사용할까요? 이 논문에서는 이 메모리를 Titans라고 부르는 아키텍처에 통합하는 세 가지 주요 방법을 제안합니다.

Memory as a Context (MAC): 이 아키텍처에서는 long-term memory의 출력이 attention에 의해 처리되기 전에 현재 입력과 결합되는 추가 "context"로 취급됩니다. attention이 short-term (현재 입력) 및 long-term memory context 모두에 접근할 수 있도록 하는 것과 같죠.
Memory as a Gate (MAG): 여기서 long-term memory는 핵심 처리 분기 (attention과 같은 short-term memory를 사용)의 정보가 persistent memory와 결합되는 방식을 제어하는 "gate" 역할을 합니다. long-term memory를 사용하여 정보 흐름을 필터링하거나 조절하는 것과 같죠.
Memory as a Layer (MAL): 이 경우, long-term memory module 자체가 neural network의 layer 역할을 하여 attention 메커니즘을 통과하기 전에 입력 시퀀스를 처리합니다. attention이 현재 context에 집중하기 전에 전용 메모리 처리 단계를 갖는 것과 같죠.

또한, LMM (Long-term Memory Module)을 attention이 없는 독립형 모델로 평가하여 long-term memory 자체가 얼마나 효과적인지 확인합니다.

개념 체크포인트: Titans는 short-term (attention) 및 long-term memory를 결합하는 다양한 방법을 제공하여 네트워크 내에서 메모리가 활용되는 방식에 유연성을 제공합니다.

5. 효율성을 위한 병렬화:

이러한 long-term memory module을 효율적으로 훈련하는 것은 매우 중요합니다. 이 논문에서는 mini-batch gradient descent와 matmul operations를 사용하여 훈련 프로세스를 병렬화하는 영리한 방법을 설명합니다. 시퀀스를 청크로 나누고 메모리 업데이트 규칙을 GPU 및 TPU에서 고도로 최적화된 행렬 곱셈 (matmuls)을 사용하여 효율적으로 계산할 수 있도록 재구성합니다. 이렇게 하면 특히 긴 시퀀스의 경우 Titans 훈련 속도가 훨씬 빨라집니다.

전체 방법 요약: Titans는 surprise를 기반으로 기억하는 법을 배우고, 과거 surprise를 통합하고, 적응적으로 잊고, 다양한 아키텍처에 통합될 수 있는 neural long-term memory module을 도입합니다. 훈련 프로세스도 효율성을 위해 병렬화됩니다. AI 모델에 효과적인 long-term memory를 장착하기 위한 포괄적인 접근 방식이죠!

실험 결과:

Titans가 실제로 작동하는지 확인하기 위해 연구자들은 다양한 까다로운 task에 대한 광범위한 실험을 수행했습니다.

Language Modeling and Common Sense Reasoning: 표준 언어 벤치마크와 상식 추론 task에서 Titans를 테스트했습니다. 결과: Titans, 특히 MAC, MAG, MAL 변형은 최첨단 linear recurrent 모델과 context window가 제한된 Transformer보다 우수한 성능을 보였습니다. 독립형 LMM도 강력한 성능을 보여 long-term memory module 자체의 강력함을 강조했습니다.
Needle-in-a-Haystack (NIAH) Task: 이건 long-context 이해를 테스트하기 위해 특별히 설계된 task입니다. 모델은 매우 긴 문서 ("haystack") 안에 숨겨진 특정 정보 ("needle")를 찾아야 합니다. 결과: Titans (특히 MAC)는 GPT-4와 같은 매우 큰 모델을 포함한 모든 baseline보다 훨씬 뛰어난 성능을 보였습니다. 이는 Titans가 극도로 긴 context를 처리하고 먼 과거로부터 정보를 검색하는 능력이 탁월함을 입증했습니다. haystack이 길어져도 Titans의 성능은 다른 모델만큼 저하되지 않아 더 나은 확장성을 보여주었습니다.
BABILong Benchmark: 매우 긴 문서에 분산된 사실들을 추론해야 하는 훨씬 더 어려운 long-context 추론 task입니다. 결과: 다시 한번, Titans (MAC)는 GPT-4와 같은 매우 큰 모델과 심지어 다른 모델의 fine-tuned 버전을 포함한 모든 baseline보다 뛰어난 성능을 보였습니다. 이는 Titans가 복잡한 long-context 시나리오에서 효과적임을 더욱 입증했습니다.
Time Series Forecasting: Titans는 시계열 데이터의 미래 값을 예측하는 데 테스트되었습니다. 결과: neural memory module (LMM)은 specialized time series 모델을 포함한 모든 baseline보다 뛰어난 성능을 보여 언어뿐만 아니라 다양한 분야에 적용될 수 있음을 보여주었습니다.
DNA Modeling: Titans는 DNA 모델링 task에서도 평가되어 과학 데이터에 대한 적용 가능성을 보여주었습니다. 결과: LMM은 genomics 분야의 최첨단 아키텍처와 경쟁할 만한 성능을 보여 광범위한 적용 가능성을 보여주었습니다.
Ablation Studies: Titans의 각 구성 요소의 기여도를 이해하기 위해 convolution, momentum, weight decay, persistent memory와 같은 부분을 제거하는 ablation studies를 수행했습니다. 결과: 모든 구성 요소가 성능에 긍정적인 영향을 미쳤으며, weight decay, momentum, convolution, persistent memory가 가장 큰 영향을 미쳤습니다.
Memory Depth Analysis: neural memory module의 다양한 깊이를 테스트했습니다. 결과: 더 깊은 메모리 (더 많은 layer)는 일반적으로 특히 더 긴 시퀀스에서 더 나은 성능으로 이어졌지만, 훈련 속도는 약간 느려졌습니다. 이는 메모리 깊이, 성능, 효율성 간의 trade-off를 보여주었습니다.

전반적인 실험 검증: 실험 결과는 neural long-term memory module을 갖춘 Titans가 기존 모델보다 특히 long-context 이해가 필요한 task에서 훨씬 더 효과적임을 설득력 있게 보여줍니다. 또한 효율적이고 확장 가능하여 방대한 양의 정보를 처리하고 기억해야 하는 미래 AI 시스템에 유망한 접근 방식입니다.

리뷰:

이 논문은 AI 메모리 분야에서 정말 흥미로운 발전을 제시합니다! 학습 가능한 neural long-term memory를 갖춘 "Titans" 아키텍처는 AI 모델이 긴 context를 처리하고 시간이 지나도 정보를 "기억"할 수 있는 강력하고 효율적인 방법을 제공합니다. 핵심 혁신은 "surprise" 기반 학습 메커니즘으로, 메모리 모듈이 인간의 인지에서 영감을 받아 무엇을 기억하고 언제 잊을지 적응적으로 학습할 수 있도록 합니다. 실험 결과는 인상적이며, Titans는 특히 long-context 시나리오에서 다양한 까다로운 task에서 최첨단 모델을 능가하는 성능을 보여줍니다. 이 연구는 방대한 양의 데이터로부터 효과적으로 추론하고 학습할 수 있는 AI 시스템을 구축할 수 있는 새로운 가능성을 열어줍니다. 마치 인간처럼요. AI 모델이 고정 크기 메모리에 의존하는 대신 테스트 시간에 어떻게 기억하는지 능동적으로 학습한다는 아이디어는 중대한 진전이며 AI의 미래에 큰 영향을 미칠 수 있습니다!

[떠먹여주는 논문] CVPR 2024 Best Paper : Generative Image Dynamics

Box형 — Tue, 14 Jan 2025 21:09:54 +0900

틀린 질문에서 올바른 답이 나올 수 없다

- 최민식, 이상한 나라의 수학자 -

우리는 종종 정지된 이미지를 보면서도 그 속에 담긴 움직임을 상상하곤 합니다. 촛불이 흔들리는 모습, 바람에 나뭇잎이 바스락거리는 소리, 잔잔한 호숫가의 물결 등, 이러한 움직임은 우리의 지각 능력과 밀접하게 연결되어 있습니다. 그렇다면 이러한 자연스러운 움직임을 컴퓨터가 스스로 모델링하고 생성할 수 있다면 어떨까요? "Generative Image Dynamics" 논문은 바로 이러한 질문에서 시작되었습니다.

이 논문에서는 우리가 자연에서 관찰할 수 있는 움직임을 모델링하는 데 집중합니다. 특히, 앞서 언급했던 자연스럽게 반복되는 움직임을 모델링하는 데 초점을 맞추고 있습니다. 단순히 움직임을 예측하는 것을 넘어, 사용자의 상호작용에 반응하는 인터랙티브 시뮬레이션까지 가능하게 하는 것이 이 논문의 핵심 목표입니다. 이러한 목표를 달성하기 위해 이 논문에서는 스펙트럴 볼륨(Spectral Volume) 이라는 새로운 모션 표현 방법을 도입하고, 이를 diffusion model과 결합하여 효과적으로 모델링하고 있습니다.

스펙트럴 볼륨(Spectral Volume): 움직임을 주파수로 표현하다

논문의 핵심 아이디어 중 하나는 이미지 내 움직임을 주파수 공간에서 표현하는 것입니다. 이를 위해 이 논문에서는 스펙트럴 볼륨(Spectral Volume)이라는 새로운 개념을 도입합니다. 스펙트럴 볼륨은 이미지 내 각 픽셀의 시간적 움직임 변화를 푸리에 변환하여 얻어진 주파수 기반 표현입니다.

즉, 각각의 픽셀이 시간에 따라 어떻게 움직이는지를 푸리에 변환을 통해 주파수 성분으로 분해하여 표현한 것입니다. 예를 들어, 바람에 흔들리는 나뭇잎의 움직임을 생각해보면, 그 움직임은 여러 주파수 성분의 조합으로 표현될 수 있습니다. 나뭇잎의 전체적인 흔들림은 저주파 성분으로, 나뭇잎 끝의 미세한 떨림은 고주파 성분으로 표현되는 것이죠. 이러한 움직임을 각 주파수 성분으로 분해하여 표현하는 것이 스펙트럴 볼륨의 핵심입니다.

$$ S(p) = FFT(F(p)) $$

수식은 픽셀 p에서의 움직임 F(p)를 푸리에 변환(FFT, Fast Fourier Transform)하여 스펙트럴 볼륨 S(p)를 얻는 과정을 나타냅니다. 여기서 F(p)는 픽셀의 움직임을 시간 축에 따라 나타낸 것이고, FFT를 통해 이 움직임을 각 주파수 성분으로 분해합니다. 즉, 복잡한 움직임을 여러 주파수 성분으로 분해하여 분석하기 위한 수식입니다. 이렇게 얻어진 S(p)는 각 주파수 성분의 진폭과 위상을 포함하는 복소수로 표현됩니다.

움직임을 주파수 공간에서 표현하는 이유는 무엇일까요? 자연 현상의 움직임은 대부분 진동 운동이나 반복 운동과 같은 주기성을 가지기 때문입니다. 이러한 주기적인 움직임은 푸리에 변환을 통해 다양한 주파수 성분으로 분해할 수 있으며, 각 주파수 성분의 진폭과 위상을 조절함으로써 다양한 움직임을 표현할 수 있습니다.

쉽게 말해, 우리가 음악을 들을 때 여러 악기의 소리가 섞여 있는 것처럼, 자연의 움직임도 여러 주파수의 진동이 섞여 있다고 볼 수 있습니다. 이러한 각 주파수 성분을 분리해서 분석하고 조작하는 것이 스펙트럴 볼륨의 핵심입니다. 따라서 스펙트럴 볼륨은 장기간에 걸친 움직임을 효율적으로 모델링하는 데 효과적인 표현 방식입니다.

Frequency-Coordinated Diffusion Model 을 이용한 스펙트럴 볼륨 예측

스펙트럴 볼륨을 얻었다면 이제 이를 예측하는 방법을 알아야 합니다. 이 논문에서는 Latent Diffusion Model을 사용하여 스펙트럴 볼륨을 예측합니다. LDM은 이미지 또는 데이터의 잠재 공간에서 점진적으로 노이즈를 제거하여 새로운 데이터를 생성하는 생성 모델입니다. LDM은 VAE(Variational Autoencoder)를 통해 입력 데이터를 잠재 공간(latent space)으로 인코딩 한 뒤, 확산 과정을 통해 노이즈를 추가하고, 디노이즈 과정을 통해 다시 복원하여 원본과 유사한 데이터를 생성하는 방식으로 학습됩니다.

확산 모델을 사용하여 스펙트럴 볼륨을 예측하는 과정을 보여줍니다. 입력 이미지를 VAE를 통해 latent space로 인코딩한 후, LDM을 사용하여 점진적으로 노이즈를 제거하면서 스펙트럴 볼륨을 예측합니다. 그림에서는 각 단계를 시각적으로 나타내어 이해를 돕습니다. 특히, 그림에서 각 블록이 2D 공간 레이어와 어텐션 레이어를 번갈아 사용하는 모습을 확인할 수 있습니다. 이는 주파수 성분 간의 의존성을 효율적으로 모델링하기 위한 핵심적인 구조입니다.

이 논문에서는 특히 Diffusion Model을 사용하여, 모션의 움직임을 표현하는 스펙트럴 볼륨을 예측합니다. 자연스러운 움직임은 다양한 주파수 성분의 조합으로 이루어져 있으며, 각 주파수 성분은 서로 긴밀하게 연결되어 있습니다. 따라서 스펙트럴 볼륨을 예측할 때 각 주파수 성분 간의 상관관계를 고려하는 것이 중요합니다.

기존에는 단일 확산 모델을 사용하여 모든 주파수 성분을 한 번에 예측하거나, 각 주파수에 대해 독립적인 확산 모델을 사용하는 방식이 있었습니다. 하지만 이 논문에서는 각 주파수 성분에 대해 독립적인 확산 모델을 사용하되, 각 확산 모델의 중간 레이어에 어텐션 레이어를 도입하여 주파수 성분 간의 의존성을 학습합니다.

이렇게 함으로써 각 주파수 성분이 독립적으로 예측되는 것이 아니라, 서로 연관된 정보를 공유하면서 더욱 자연스러운 스펙트럴 볼륨을 생성할 수 있습니다. 예를 들어, 나뭇잎의 흔들림을 모델링할 때, 저주파 성분이 전체적인 움직임을 담당하고 고주파 성분이 미세한 떨림을 담당한다면, 이 둘 간의 관계를 명시적으로 학습하여 더욱 현실적인 움직임을 예측할 수 있는 것입니다.

$$ L_{LDM} = E_{n\in U[1,N], e_n\in N(0,1)} [||e_n - \epsilon_\theta (z_n; n, c) ||^2] $$

DM(Latent Diffusion Model)의 학습 손실 함수입니다. 여기서 $e_n$은 실제 노이즈, $\epsilon_\theta (z_n; n, c)$는 확산 모델이 예측한 노이즈를 의미하며, 이 둘 사이의 차이를 최소화하는 방향으로 모델을 학습합니다. 즉, 확산 모델이 노이즈를 제거하는 과정을 모방하면서 실제 데이터를 복원하는 능력을 학습하는 것입니다.

여기서 한 가지 더 중요한 것이 있습니다. 스펙트럴 볼륨은 저주파 성분이 크고 고주파 성분이 작다는 특징을 가지고 있습니다. 만약 주파수 성분에 대한 아무런 처리 없이 그대로 사용하면 모델이 저주파 성분에만 집중하고 고주파 성분을 무시할 수 있습니다. 이러한 문제를 해결하기 위해 frequency adaptive normalization 과정이 필요합니다.

$$ S’{fj}(p) = sign(S{fj}(p)) * \sqrt{|S_{fj}(p)| / s_{fj}} $$

이 수식은 스펙트럴 볼륨 S의 푸리에 계수를 정규화하는 과정입니다. 푸리에 계수의 크기가 이미지의 크기에 따라 달라지는 문제를 해결하고, 모델 학습 시 모든 주파수에서 균등한 학습이 이루어지도록 하기 위해 주파수별로 푸리에 계수를 스케일링합니다. 즉, $s_{fj}$는 각 주파수 $fj$에 대한 푸리에 계수 크기의 95번째 백분위수이며, 이를 이용하여 푸리에 계수를 재조정하여 모든 주파수 성분이 학습에 균등하게 기여할 수 있도록 합니다. 이 과정을 통해 모델이 특정 주파수 성분에만 편향되지 않고, 전체적인 움직임을 더 정확하게 모델링할 수 있습니다.

Image-Based Rendering

자, 이제 힘들게 예측한 스펙트럴 볼륨을 눈으로 볼 수 있도록 만들어야겠죠? 이 단계를 Image-Based Rendering이라 칭합니다. 이미지 기반 렌더링은 3D 모델링 없이 2D 이미지들을 사용하여 새로운 시점의 이미지를 생성하는 기술입니다. 마치 사진들을 짜깁기하여 새로운 풍경을 만드는 것처럼, 이미지 기반 렌더링은 기존 이미지들을 활용하여 움직임을 만들어냅니다. 이 논문에서는 다음과 같은 단계를 거쳐 이미지 기반 렌더링을 수행합니다.

특징 맵 추출: 먼저, 입력 이미지에서 다양한 스케일의 특징 맵을 추출합니다. 특징 맵은 이미지의 중요한 특징들을 추출한 것으로, 이미지의 윤곽선, 질감, 색상과 같은 정보를 포함합니다. 이 특징 맵들은 마치 이미지의 뼈대와 같은 역할을 합니다.
움직임 텍스처 적용: 다음으로, 예측된 스펙트럴 볼륨을 기반으로 움직임 텍스처를 생성합니다. 움직임 텍스처는 각 픽셀이 시간에 따라 어떻게 움직이는지를 나타내는 벡터 정보의 집합입니다. 이 움직임 텍스처는 마치 그림의 움직임을 표현하는 화살표와 같은 역할을 합니다.
특징 맵 변형(Warping): 생성된 움직임 텍스처를 사용하여 특징 맵을 변형합니다. 이 과정은 마치 지도 위에 화살표를 따라 움직이는 것처럼, 특징 맵의 픽셀들을 움직임 텍스처에 따라 이동시키는 것입니다.
이미지 합성: 마지막으로, 변형된 특징 맵을 이미지 합성 네트워크에 입력하여 최종적으로 애니메이션된 이미지를 생성합니다. 이 단계는 마치 화가들이 물감을 덧칠하고 혼합하여 그림을 완성하는 과정과 유사합니다.

여기서 핵심은 픽셀을 1대1로 대응시키는 것이 아니라, 여러 픽셀의 값을 부드럽게 혼합하여 더 자연스러운 애니메이션을 생성한다는 점입니다. 만약 픽셀을 단순히 이동시키기만 하면 이미지가 찢어지거나 구멍이 생길 수 있습니다. 이러한 문제를 해결하기 위해 feature pyramid soft splatting이라는 방법을 사용합니다.

마치 물감을 흩뿌리듯이, 소스 픽셀의 값을 여러 타겟 픽셀에 가중치를 두어 분산시켜 보다 부드러운 움직임을 표현하는 것이죠. 또한, 이미지의 여러 스케일에서 특징 맵을 추출하여 움직임 텍스처를 적용함으로써, 저해상도에서는 큰 움직임을, 고해상도에서는 미세한 움직임을 표현하여 애니메이션의 디테일을 향상시킵니다.

Quantitative Results

낮은 FID, KID, FVD, DTFVD 점수: 논문에서 제시하는 방법이 기존의 single-image animation 방법들보다 이미지 합성 품질 (FID, KID) 및 비디오 합성 품질 (FVD, DTFVD) 측면에서 월등히 뛰어난 성능을 보임. 특히, DTFVD (Dynamic Texture Frechet Video Distance) 점수는 제안 방법이 자연스러운 동적 텍스처를 잘 생성한다는 것을 입증.
슬라이딩 윈도우 (Sliding Window) 평가: 슬라이딩 윈도우 FID 및 DTFVD 평가에서 제안 방법이 기존 방법들보다 시간이 지나도 영상 품질 저하가 적고, 일관적인 움직임을 유지함을 확인. 이는 제안 방법이 장기적인 움직임 모델링에 강점을 가지고 있다는 것을 의미함.

Qualitative Results

X-t slices 시각화: 제안 방법으로 생성한 비디오의 X-t 슬라이스(시간에 따른 움직임을 시각화한 그래프)가 ground truth 비디오의 X-t 슬라이스와 가장 유사함. 반면, 기존 방법들은 움직임이 너무 부드럽거나, 비주기적이거나, 일관성이 없는 패턴을 보임.

[ 떠먹여주는 논문 ] Best Paper of NeurIPS 2024, Visual Autoregressive Modeling: Scalable ImageGeneration via Next-Scale Prediction

Box형 — Mon, 6 Jan 2025 19:55:09 +0900

무언가가 충분히 중요하다면 확률이 당신에게 유리하지 않더라도 시작하라

- 일론 머스크-

안녕하세요! 오늘은 NeurIPS 2024 베스트 페이퍼로 선정된 "Visual Autoregressive Modeling: Scalable Image Generation via Next-Scale Prediction" 논문에 대해 이야기해보려고 합니다. 이 논문은 기존 이미지 생성 모델의 한계를 뛰어넘는 새로운 방법론, VAR (Visual Autoregressive Modeling)을 제시합니다. VAR은 이미지의 구조적 특성을 효과적으로 학습하고, 고품질 이미지를 놀라운 속도로 생성할 수 있게 해줍니다. 특히, 이 논문에서는 이미지 생성 분야에서 diffusion 모델이 주류였던 흐름을 뒤집고, autoregressive 모델의 새로운 가능성을 제시했다는 점에서 주목할 만합니다. 본 포스트에서는 VAR의 핵심 아이디어와 작동 원리를 자세히 살펴보고, 실제 적용 가능성과 한계점에 대해 논의해보겠습니다.

이미지 생성 모델의 두 가지 축: Diffusion과 Autoregressive

이미지 생성 모델은 크게 두 가지 축으로 나눌 수 있습니다. 첫 번째는 우리가 흔히 아는 diffusion 모델입니다. Diffusion 모델은 이미지에 점진적으로 노이즈를 추가하고, 이를 역으로 제거하는 과정을 학습하여 고품질 이미지를 생성합니다. 최근 몇 년간 diffusion 모델은 이미지 생성 분야에서 뛰어난 성능을 보여주며 많은 발전을 이루어왔습니다.

반면, autoregressive (AR) 모델은 이미지의 일부를 생성하고, 이를 기반으로 다음 부분을 생성하는 방식을 사용합니다. AR 모델은 텍스트 생성 분야에서 GPT와 같은 large language model (LLM)의 기반이 되었으며, 이미지 생성 분야에서도 연구가 진행되어 왔습니다. AR 모델은 주로 컨볼루션 또는 트랜스포머 기반의 네트워크를 사용하여 이미지를 생성합니다. 이 논문에서 다루는 VAR 모델도 이러한 AR 모델의 일종으로 볼 수 있습니다.

기존 Autoregressive 모델의 문제점

기존 AR 모델은 이미지를 생성할 때, 이미지를 1차원 토큰 시퀀스로 변환하고 raster-scan 방식으로 순차적으로 토큰을 예측합니다. 이러한 방식은 다음과 같은 문제점을 야기합니다.

Mathematical Premise Violation (수학적 전제 위반): 이미지의 토큰들은 양방향 상관관계를 가지지만, 기존 AR 모델은 토큰들을 일방향으로 순차적으로 생성합니다. 이는 모델이 이미지의 전체적인 구조를 이해하는 데 어려움을 초래합니다.
Inability to Perform Some Generalization (일반화 능력 부족): 순차적인 생성 방식은 모델이 학습하지 않은 순서로 입력이 주어질 때 성능 저하를 야기합니다. 예를 들어, 이미지를 위에서 아래로 학습한 모델은 아래에서 위로 생성하는 작업을 잘 수행하지 못합니다.
Structural Degradation (구조적 손상): 이미지를 1차원으로 펼치는 과정에서 인접 토큰 간의 공간적 관계가 손실됩니다. 이로 인해 모델이 이미지의 구조적 정보를 효과적으로 학습하기 어렵습니다.
Inefficiency (비효율성): 이미지 토큰의 개수가 증가함에 따라, AR 모델의 계산 복잡도가 급격하게 증가합니다 (O(n⁶)). 이러한 계산 복잡도는 고해상도 이미지 생성에 큰 제약으로 작용합니다.

VAR: Next-Scale Prediction 기반의 새로운 패러다임

VAR은 이러한 기존 AR 모델의 문제점을 해결하기 위해, 이미지를 "next-token prediction"이 아닌 "next-scale prediction" 방식으로 생성합니다. VAR은 이미지를 여러 단계의 해상도를 가지는 토큰 맵으로 표현하고, autoregressive하게 낮은 해상도부터 높은 해상도 순서로 토큰 맵을 생성합니다. 이 과정을 coarse-to-fine 방식으로 명명하며, 기존의 raster-scan 방식과 차별점을 둡니다.

Multi-scale VQVAE: VAR은 먼저 이미지를 multi-scale VQVAE (Vector Quantized Variational Autoencoder)를 사용하여 여러 해상도의 토큰 맵으로 인코딩합니다. VQVAE는 이미지의 고차원 feature를 이산적인 코드 벡터로 양자화하는 모델입니다. 각 해상도 레벨에서 추출된 feature map은 코드북을 사용하여 양자화되어 토큰 맵으로 표현됩니다.
VAR Transformer: 그 다음으로, VAR transformer는 이전 단계의 모든 토큰 맵을 조건으로 하여 다음 해상도 토큰 맵을 생성합니다. 각 단계에서 토큰 맵 내의 토큰들은 병렬적으로 생성되므로 계산 효율성을 높입니다. 학습 시에는 block-wise causal mask를 사용하여 각 토큰 맵이 이전 단계에만 의존하도록 제한합니다.

VAR의 작동 방식

Multi-scale VQVAE 인코딩: 입력 이미지는 Multi-scale VQVAE의 인코더를 통해 여러 해상도의 feature map으로 변환됩니다. 각 feature map은 양자화 과정을 거쳐 해당 해상도의 토큰 맵으로 변환됩니다.
VAR Transformer 생성: VAR Transformer는 가장 낮은 해상도의 토큰 맵부터 시작하여 autoregressive 방식으로 다음 해상도의 토큰 맵을 생성합니다. 각 단계에서 모델은 이전 단계의 모든 토큰 맵과 함께 해당 단계의 위치 정보 (position embedding)를 입력으로 받습니다.
Multi-scale VQVAE 디코딩: 최종적으로 생성된 모든 토큰 맵은 Multi-scale VQVAE의 디코더를 통해 원본 이미지로 복원됩니다. 디코더는 각 해상도 토큰 맵에서 해당 코드 벡터를 lookup하고, interpolation과 convolution을 통해 이미지로 복원합니다.

예시: 포뮬레이션 1에서 이미지 조각의 나열된 시퀀스에 대한 확률은 각 조각들의 조건부 확률을 모두 곱한 값입니다. 이는 P(x₁, x₂, ..., xₜ) = Π P(xᵢ | x₁...xᵢ₋₁) 로 표현할 수 있습니다. 여기서 xᵢ 는 각 조각이고, t는 전체 조각의 개수입니다. 이 수식에서, xᵢ 는 이미지 조각을 의미하며 x₁...xᵢ₋₁ 는 xᵢ 이전의 모든 이미지 조각을 나타냅니다.

VAR의 장점

VAR은 기존 AR 모델의 단점을 극복하고 다음과 같은 장점을 제공합니다.

개선된 수학적 전제: VAR은 coarse-to-fine 방식으로 이미지를 생성하여 토큰들의 양방향 상관관계 문제를 해결합니다. 각 해상도 단계에서 전체 토큰 맵을 예측하는 방식은 이러한 의존성을 내재적으로 처리합니다.
향상된 일반화 능력: VAR은 이미지의 전체적인 구조를 학습하여 다양한 입력 조건에서도 안정적인 성능을 보입니다. 특히 in-painting, out-painting과 같은 zero-shot task에서도 우수한 성능을 나타냅니다.
보존된 공간적 정보: 이미지의 2D 구조를 유지하면서 토큰 맵을 처리하여 spatial locality를 유지합니다. 멀티스케일 구조는 각 해상도에서 공간 정보를 더 잘 학습하도록 도와줍니다.
높은 효율성: VAR은 병렬적인 토큰 생성과 재귀적인 스케일 확장을 통해 계산 복잡도를 O(n⁴)로 줄입니다. 이는 기존 AR 모델에 비해 훨씬 효율적인 계산을 가능하게 합니다. [수정된 설명] 원래 스크립트에서 언급된 O(n⁶)이 아닌 O(n⁴)가 맞는 수치입니다.
뛰어난 이미지 생성 성능: VAR은 기존의 diffusion 트랜스포머 모델을 능가하는 이미지 생성 품질과 추론 속도를 제공합니다.

VAR의 학습 및 추론 과정

VAR 모델의 학습은 크게 두 단계로 나뉩니다.

Multi-scale VQVAE 학습 (Stage 1): 원본 이미지를 입력으로 하여 Multi-scale VQVAE를 학습합니다. 이때, multi-scale quantization을 통해 여러 해상도 토큰 맵을 생성하고, 복원된 이미지와 원본 이미지 간의 차이를 줄이도록 학습합니다. 코드북은 학습 과정에서 최적화되며, 다양한 정보를 효과적으로 표현할 수 있도록 학습됩니다.
VAR Transformer 학습 (Stage 2): 학습된 VQVAE를 사용하여 이미지를 토큰 맵으로 변환하고, VAR Transformer를 학습합니다. VAR Transformer는 이전 단계의 토큰 맵을 기반으로 다음 단계 토큰 맵을 예측하도록 학습됩니다. 이때, causal masking을 사용하여 미래 정보를 참조하지 않도록 합니다.

VAR 모델의 추론 과정은 다음과 같습니다.

Multi-scale VQVAE 인코딩: 학습된 VQVAE를 사용하여 입력 이미지를 여러 해상도의 토큰 맵으로 인코딩합니다.
VAR Transformer 생성: 가장 낮은 해상도 토큰 맵부터 시작하여 VAR Transformer를 통해 순차적으로 다음 해상도 토큰 맵을 생성합니다.
Multi-scale VQVAE 디코딩: 생성된 모든 토큰 맵을 Multi-scale VQVAE 디코더를 통해 최종 이미지로 복원합니다.

실험 결과 및 Scaling Law

논문에서는 다양한 실험을 통해 VAR 모델의 우수성을 입증했습니다. ImageNet 데이터셋에서 VAR 모델은 diffusion 트랜스포머보다 더 빠른 속도로 더 나은 품질의 이미지를 생성했습니다. 특히 VAR 모델은 scaling law를 따르며, 모델 크기를 늘릴수록 성능이 지속적으로 향상된다는 점을 보여주었습니다.

또한, VAR 모델은 in-painting, out-painting과 같은 다양한 downstream task에서 zero-shot generalization 능력을 보여주었습니다. 이는 VAR 모델이 단순히 이미지를 생성하는 것을 넘어 이미지의 구조를 이해하고 활용할 수 있음을 의미합니다.

한계점 및 개선 방향

VAR 모델은 이미지 생성 분야에서 큰 발전을 이루었지만, 다음과 같은 한계점과 개선점이 존재합니다.

텍스트 기반 이미지 생성 부재: 논문에서 텍스트를 기반으로 한 이미지 생성 기능은 구현되지 않았습니다. 향후 text-to-image 생성을 지원하고, multi-modal 기능을 확장할 필요가 있습니다.
비디오 생성: VAR 모델의 비디오 생성 능력은 아직 실험적으로 검증되지 않았습니다. 향후 VAR 모델을 비디오 생성 분야로 확장하기 위한 연구가 필요합니다.
모델 복잡성: Multi-scale VQVAE와 VAR Transformer 두 단계 학습이 필요하여 모델 학습 과정이 복잡할 수 있습니다. 이를 단순화하고 학습 효율을 개선할 필요가 있습니다.

결론

VAR은 기존 autoregressive 모델의 한계를 극복하고, 이미지 생성 분야에 새로운 가능성을 제시하는 모델입니다. Next-scale prediction이라는 새로운 패러다임을 통해 이미지의 구조적 정보를 효과적으로 학습하고, 고품질 이미지를 매우 효율적으로 생성할 수 있음을 입증했습니다. VAR 모델의 확장성과 일반화 능력은 향후 이미지 생성 분야의 발전에 큰 영향을 미칠 것으로 기대됩니다.

다들 새해복 많이 받으세요 :)

데이터의 힘: 학습 이미지가 많아질수록 Accuracy와 F-1 Score가 개선되는 이유

Box형 — Wed, 31 Jan 2024 17:11:27 +0900

인공지능(AI)이나 기계학습 분야에서, 모델의 성능을 평가하는 데에는 여러 지표가 사용됩니다. 그 중에서도 'Accuracy(정확도)'와 'F-1 Score(F-1 점수)'는 가장 널리 사용되는 지표 중 두 가지입니다. 이 두 지표는 모델이 얼마나 잘 작동하는지를 나타내는 중요한 척도입니다. 그렇다면, 학습 이미지의 양이 증가할수록 이 두 지표의 성능이 왜 개선될 수 있는지 살펴봅시다.

정확도(Accuracy)란?

정확도는 가장 직관적인 성능 지표 중 하나로, 모델이 정확하게 예측한 케이스의 비율을 의미합니다. 즉, 모든 예측 중 올바른 예측의 비율을 나타냅니다. 예를 들어, 100개의 이미지를 분류하는 모델이 90개의 이미지를 올바르게 분류했다면, 정확도는 90%가 됩니다.

F-1 Score(F-1 점수)란?

F-1 점수는 데이터 세트의 불균형을 고려할 때 유용한 지표입니다. 이는 정밀도(Precision)와 재현율(Recall)의 조화 평균을 기반으로 하며, 특히 양성 클래스(예를 들어, '고양이' 이미지)를 정확하게 식별하는 데 중점을 둡니다. 정밀도는 모델이 양성으로 예측한 항목 중 실제로 양성인 항목의 비율이고, 재현율은 실제 양성 항목 중 모델이 양성으로 올바르게 예측한 항목의 비율입니다.

학습 이미지의 양이 성능 개선에 미치는 영향

데이터 다양성의 증가: 학습 이미지가 많아질수록, AI 모델은 더 다양한 패턴과 특성을 학습할 기회를 얻습니다. 이는 모델이 실제 세계에서 발생할 수 있는 다양한 시나리오에 더 잘 적응하고, 정확도와 F-1 점수를 향상시키는 데 도움이 됩니다.
과적합(Overfitting)의 감소: 과적합은 모델이 학습 데이터에 너무 잘 맞춰져서 새로운 데이터에는 잘 작동하지 않는 현상을 말합니다. 학습 데이터가 많아질수록, 모델은 일반적인 패턴을 더 잘 학습하고, 과적합 위험을 줄일 수 있습니다. 이는 모델이 새로운 이미지에 대해 더 정확한 예측을 하고, 높은 F-1 점수를 달성하는 데 기여합니다.
불균형 데이터 처리: 특히, F-1 점수는 불균형한 데이터 세트에서 모델의 성능을 평가할 때 중요합니다. 학습 이미지가 많을수록 모델은 소수 클래스(덜 대표되는 클래스)에 대해서도 더 잘 학습합니다.

실제 사례: 의료 이미지 분석

의료 분야에서 AI 모델은 X-레이, MRI와 같은 이미지를 분석하여 질병을 진단하는 데 사용됩니다. 초기에는 제한된 양의 학습 데이터로 모델을 훈련시켰을 때, 모델의 정확도와 F-1 점수가 상대적으로 낮았습니다. 이는 모델이 다양한 질병 상태, 환자의 다양성(예: 나이, 성별, 인종) 및 이미지의 다양한 촬영 조건을 충분히 학습하지 못했기 때문입니다.

하지만 학습 데이터 세트에 더 많은 이미지가 추가됨에 따라, AI 모델은 다음과 같은 이유로 성능이 개선되었습니다:

다양성 증가: 더 많은 이미지는 다양한 환자와 질병 상태를 포함하게 되어, 모델이 더 넓은 범위의 경우를 학습할 수 있게 됩니다. 이로 인해 모델의 일반화 능력이 향상되고, 실제 환경에서의 정확도와 F-1 점수가 개선됩니다.
세부 특성 학습: 추가된 이미지는 모델이 질병의 미묘한 특성을 더 잘 식별하게 해줍니다. 예를 들어, 특정 유형의 종양이나 조직 변화를 더 정확하게 인식할 수 있게 됩니다.
로버스트성 강화: 더 많은 데이터는 모델이 이미지의 잡음, 촬영 각도의 변화, 조명 조건 등에 더 강건하게 반응하도록 합니다. 이는 실제 의료 환경에서 다양한 조건 하에서도 높은 정확도와 F-1 점수를 유지할 수 있게 합니다.

결론적으로, 의료 이미지 분석 분야에서 학습 이미지의 양이 증가함에 따라 정확도와 F-1 점수가 개선되는 사례는 AI 모델이 더 정확하고 신뢰할 수 있는 진단을 제공할 수 있게 되었음을 보여줍니다. 이처럼 학습 데이터의 양과 질이 모델 성능에 중요한 영향을 미치며, AI 분야의 발전에 있어 핵심 요소임을 강조합니다.

[문과도 이해하는 선형대수 for 딥러닝] 4. 행렬 분해 (Matrix factorization)

Box형 — Mon, 13 Mar 2023 15:45:41 +0900

의심으로 가득 찬 마음은 승리로의 여정에 집중할 수 없다.

- 아서 골드 -

이번 포스팅에서 다룰 내용은 행렬 분해 (Matrix factorization)입니다. Matrix Factorization은 데이터를 분석하고 모델링하는데 널리 사용되는 방법 중 하나입니다. 이 방법은 매우 큰 데이터 집합에서 숨겨진 패턴을 추출하고, 예측 모델을 생성하고, 더 나은 결과를 도출할 수 있는 방법을 제공합니다.

이 방법은 행렬을 작은 크기의 더 간단한 행렬로 분해하여 데이터의 복잡성을 줄이는 방법입니다. 이렇게하면 복잡한 문제를 해결하는 데 더 간단한 알고리즘을 사용할 수 있으며, 더 나은 성능을 얻을 수 있습니다.

이번 포스팅은 이전 개념을 숙지하고 공부하시는 것을 권장드립니다.

[이론/MIT 선형대수] - [문과도 이해하는 선형대수 for 딥러닝] 3. 행렬곱, 역행렬, 가우스-조던 소거법 (Multiplication and Inverse Matrices)

[문과도 이해하는 선형대수 for 딥러닝] 3. 행렬곱, 역행렬, 가우스-조던 소거법 (Multiplication and Inve

늘 명심하라. 성공하겠다는 너 자신의 결심이 다른 어떤 것보다 중요하다는 것을. - 아브라함 링컨 - 곱셈(multiplication)과 역행렬(inverse matrix)은 선형 대수학에서 가장 기본이 되는 연산 중 하나입

box-world.tistory.com

1. 역행렬에 대한 리뷰 (Review of inverse matrix)

여기 곱하면 $P$가 나오는 두 행렬 $A$와 $B$가 있습니다.

$$A \times B = P$$

각 행렬에 대한 역행렬이 존재한다고 가정할 때, 행렬 $AB$에 대한 역행렬은 무엇일까요? 물론 $A^{-1}$과 $B^{-1}$가 곱해진 형태겠지만 중요한건 곱하는 순서도 함께 역으로 바뀌며 $B^{-1}A^{-1}$이라는 것입니다.

이것은 마치 우리가 집에 돌아오면 1) 신발을 벗고 2) 양말을 벗는데, 다시 집밖으로 나갈땐 2) 양말을 신고 1) 신발을 신는 것과 같은 맥락입니다^^.

마찬가지로 $A \times A^{-1}=I$를 전치 (transpose) 시킨다면 마찬가지로 앞 뒤 순서가 바뀌어 다음과 같이 나타납니다.

$$(A^{-1})^TA^T=I$$

당연하겠지만, 단위 행렬은 전치를 해도 여전히 단위 행렬입니다! 어쨌든 여기서 우리가 얻을 수 있는 것은 $(A^{-1})^T$와 $A^T$를 곱했을 때 $I$가 나왔기 때문에 이 둘은 역행렬 관계라는 겁니다.

2. $A =LU$

이제 우리는 본격적으로 행렬 분해 (Matrix factorization)에 대해 살펴보려합니다. 우선 그전에 소거 행렬 (Elimination matrix)에 대해 간단히 짚고 가겠습니다.

$$\begin{bmatrix}-&-\\-&-\end{bmatrix}\begin{bmatrix}2&1\\8&7\end{bmatrix}=\begin{bmatrix}2&1\\0&3\end{bmatrix}$$

위 식에 대하여, 좌변의 행렬에 어떤 Elimination matrix를 곱하여 우변처럼 Upper triangle matrix의 형태로 나타내고 싶다면 Elimination matrix는 어떤 형태가 되어야할까요?

좌변 행렬의 첫번째 row는 그대로 유지되고 두번째 row의 경우 $\begin{bmatrix}0&3\end{bmatrix}$이 되어야 하므로 [첫번째 row의 (-4)배 +두번째 row의 (1)배]를 해야하므로 Elimination matrix는 $\begin{bmatrix}1&0\\-4&1\end{bmatrix}$가 되고 지금부터 이를 2번째 row의 첫번째 component를 0으로 만드는 행렬이라는 의미로 $E_{21}$이라고 정의합니다.

아래 식은 $E_{21}A=U$의 형태이고,

$$\begin{bmatrix}1&0\\-4&1\end{bmatrix}\begin{bmatrix}2&1\\8&7\end{bmatrix}=\begin{bmatrix}2&1\\0&3\end{bmatrix}$$

또 하나의 아래 식은 $A=LU$ 형태의 식입니다.

$$\begin{bmatrix}2&1\\8&7\end{bmatrix}=\begin{bmatrix}-&-\\-&-\end{bmatrix}\begin{bmatrix}2&1\\0&3\end{bmatrix}$$

그렇다면 $L$은 직관적으로 $E_{21}$의 역행렬이라는 것을 알 수 있습니다! 그렇다면 이는 어떻게 구할까요? 그냥 $E_{21}$에서 -4를 4로 바꿔주면 됩니다! 왜냐하면 $E_{21}$이 4배를 빼는 거였는데, 역행렬은 이를 되돌리는 것이기 때문입니다. 그렇기에 부호만 바꾸면 되는 것입니다.

$$\begin{bmatrix}2&1\\8&7\end{bmatrix}=\begin{bmatrix}1&0\\4&1\end{bmatrix}\begin{bmatrix}2&1\\0&3\end{bmatrix}$$

위 식에서 $U$의 pivot을 빼내면 다음과 같이 표현할 수 있습니다. pivot을 빼내면 $U$의 첫번째 row는 2로, 2번째 row는 3으로 나눠주는 것입니다.

$$\begin{bmatrix}2&1\\8&7\end{bmatrix}=\begin{bmatrix}1&0\\4&1\end{bmatrix}\begin{bmatrix}2&0\\0&3\end{bmatrix}\begin{bmatrix}1&1\over2\\0&1\end{bmatrix}$$

이제 $2 \times 2$의 경우를 봤으니 $3 \times 3$의 경우도 살펴보겠습니다. 그렇다면 $3 \times 3$ 행렬 $A$가 다음과 같을때

$$A=\begin{bmatrix}(1,1)&(1,2)&(1,3)\\(2,1)&(2,2)&(2,3)\\(3,1)&(3,2)&(3,3)\end{bmatrix}$$

행렬 $A$를 Upper triangle matrix $U$의 형태로 바꿔주는 Elimination matrix들의 조합은 다음과 같이 표현할 수 있습니다.

$$E_{32}E_{31}E_{21}=U$$

각각은 행렬 $A$의 $(3,2),(3,1),(2,1)$ 자리를 0으로 만들어줍니다. 이것을 $A=LU$형태로 만들어주면, 다음과 같습니다.

$$A=E^{-1}_{21}E^{-1}_{31}E^{-1}_{32}U$$

그렇다면 자꾸 $E_{32}E_{31}E_{21}$을 그대로 처리하지 않고, $E^{-1}_{21}E^{-1}_{31}E^{-1}_{32}$의 형태로 바꾸어 처리하려는 것일까요? 다음은 $E_{32}E_{21}=E$의 경우를 임의로 살펴보겠습니다.

$$\begin{bmatrix}1&0&0\\0&1&0\\0&-5&1\end{bmatrix}\begin{bmatrix}1&0&0\\-2&1&0\\0&0&1\end{bmatrix}=\begin{bmatrix}1&0&0\\-2&1&0\\10&-5&1\end{bmatrix}$$

그리고 다음은 $E^{-1}_{32}E^{-1}_{21}=L$의 경우입니다.

$$\begin{bmatrix}1&0&0\\2&1&0\\0&0&1\end{bmatrix}\begin{bmatrix}1&0&0\\0&1&0\\0&5&1\end{bmatrix}=\begin{bmatrix}1&0&0\\2&1&0\\0&5&1\end{bmatrix}$$

보다시피 일반 행렬의 곱셈과 달리, 역행렬의 곱셈의 경우 배수 2나 5와 같은 배수 부분이 결과로 도출되는 행렬 $L$에 그대로 위치하기 때문에 연산과정이 훨씬 단순해집니다!

결과적으로 만약 행 변환 (row change)가 없다면, 행렬 $A$를 Elimination하면 자연스럽게 $A$는 $LU$를 만들어내게 됩니다.

3. 소거에 대한 연산량 (Complexity of Elimination)

$n \times n$ 차원 행렬에 대해 Elimination을 위해 필요한 연산은 얼마나 클까요? $n=100$을 예로 들겠습니다. 처음에는 1st row는 두고 2nd row부터 $99 \times 100$의 성분에 대한 연산이 필요하니 $100^2$의 연산이 필요합니다. 이런식으로 반복되면 최종적으로는

$$n^2+(n-1)^2+\dots+2^2+1^2$$

가 됩니다. 즉 정석적으로라면, $n$개의 항복이 $n^2$이 되지만, $n$개의 항목이 점점 숫자가 작아지므로 대략 $1 \over 3 n^3$정도가 됩니다!

긴 글 읽어주셔서 감사합니다! 오늘도 행복한 하루 보내세요 :)

[문과도 이해하는 선형대수 for 딥러닝] 3. 행렬곱, 역행렬, 가우스-조던 소거법 (Multiplication and Inverse Matrices)

Box형 — Sat, 11 Mar 2023 15:50:14 +0900

늘 명심하라. 성공하겠다는 너 자신의 결심이

다른 어떤 것보다 중요하다는 것을.

- 아브라함 링컨 -

곱셈(multiplication)과 역행렬(inverse matrix)은 선형 대수학에서 가장 기본이 되는 연산 중 하나입니다. 곱셈은 행렬 간의 연산으로, 두 개의 행렬을 곱할 때 결과 행렬의 크기와 요소는 입력된 두 행렬의 크기와 요소에 의해 결정됩니다. 반면 역행렬은 주어진 행렬의 역원(inverse)을 찾는 연산입니다. 역행렬은 주어진 행렬과 곱했을 때 단위행렬(identity matrix)을 얻을 수 있는 유일한 행렬입니다. 이번 포스팅에서는 이러한 행렬의 곱셈과 역행렬에 대해 자세히 알아보고, 이를 계산하는 방법에 대해서도 살펴보겠습니다.

해당 포스팅은 이전 내용을 공부하고 보시면 더욱 이해하는데 많은 도움이 됩니다.

[이론/MIT 선형대수] - [문과도 이해하는 선형대수 for 딥러닝] 2. 행렬 소거 (Elimination with Matrices)

[문과도 이해하는 선형대수 for 딥러닝] 2. 행렬 소거 (Elimination with Matrices)

성공의 커다란 비결은 결코 지치지 않는 인간으로 인생을 살아가는 것이다. - 알버트 슈바이처 - 안녕하세요 저번 포스팅에서는 선형 대수 공부의 첫 단원으로써, 선형 방정식을 Row picture와 Column

box-world.tistory.com

1. Matrix multiplication

이제부터는 두 행렬 $A$와 $B$를 곱하는 네 가지 방법에 대해서 하나하나 살펴보겠습니다.

1) $C_ij=\sum(A_ik*B_kj)$

우선 위 수식을 이해하기 위해 아래 $C=AB$의 상황을 보며 이해하겠습니다. 두 행렬 $A$와 $B$를 곱한 결과 $C$에서 3번째 row와 4번째 Column에 위치한 $C_{ij}$는 $A$의 세번째 row와 $B$의 네번째 Column간의 내적 (dot product)로 구할 수 있습니다!

$$C_{34}= a_{31}b_{14}+a_{32}b_{24}+\dots=\displaystyle\sum^n_{k=1}a_{3k}b_{k4}$$

그렇다면 두 행렬 $A$와 $B$는 언제 곱해질 수 있을까요? 바로 $A$가 $m \times n$이라면, $B$의 row의 개수는 A의 Column의 개수와 동일한 $n$이어야 합니다. 그리고 $B$의 Column의 개수는 어떤 것이 되든 상관이 없기 때문에 여기서는 $p$라고 하겠습니다.

그렇다면 각자 차원이 정의된 두 행렬을 곱했을 때 $C$의 차원은 $A$의 row 개수와 $B$의 Column 개수를 곱한 $m \times p$가 되는 것입니다!

2) 행렬 $\times$ 벡터로 바라보기

우리는 앞서 <어떤 행렬 E $\times$ 벡터 = E 컬럼의 선형 결합 (Linear combination)>이라는 것을 배웠습니다. 우린 행렬 간의 곱셈을 얘기하고 있는데 벡터가 필요한 Linear combination 얘기를 왜 꺼낼까요? 바로 두 행렬 A$와 $B$의 곱을 다음과 같이 $A$와 $B$의 각 Column간의 Linear combination으로 바라볼 수 있기 때문입니다.

3) $A$의 한 row $\times$ $B$ = $C$의 한 row

앞서 Column의 관점에서 행렬의 곱셈을 바라봤다면, 이번엔 row의 관점에서도 바라볼 수 있겠죠! 2)에선 $A$의 전체와 $B$의 한 Column으로 $C$의 한 Column을 구했다면, row의 관점에서는 $A$의 한 row와 $B$의 전체를 곱하면, 다음과 같이$C$의 한 row를 구하는 것으로 이해할 수 있습니다!

예를 들어 $A$의 3번째 row를 기준으로 $B$의 첫번째 row와 내적하여 나온 값이 $C_{31}$, 두번째 row와 내적하여 나온 값이 $C_{32}$와 같이 되는 것이죠.

4) $A$의 한 Column과 $B$의 한 row의 곱셈으로 바라보기

이 방식은 바로 아래 예시와 함께 살펴보겠습니다!

$$\begin{bmatrix}2&7\\3&8\\4&9\end{bmatrix}\begin{bmatrix}1&6\\0&0\end{bmatrix}=\begin{bmatrix}2\\3\\4\end{bmatrix}\begin{bmatrix}1&6\end{bmatrix}+\begin{bmatrix}7\\8\\9\end{bmatrix}\begin{bmatrix}0&0\end{bmatrix}$$

말 그대로 같은 인덱스에 위치한 $A$의 Column과 $B$의 row를 곱하고, 그것들을 합쳐버리는 것입니다.

2. 역행렬 (Inverse matrix)

우리가 "이 행렬은 역행렬을 가질까?" 에 대해 얘기하려면 다음과 같은 몇가지 조건이 충족되는지를 보아야 합니다.

해당 행렬이 정사각행렬인가?
invertible한가? or 해당 행렬은 non-singular 행렬인가?

그렇다면 우리가 해당 행렬이 invertible한지는 어떻게 알아야할까요? 다음 예시를 보며 알아보겠습니다.

$$A=\begin{bmatrix}1&3\\2&6\end{bmatrix}$$

제가 여러분에게 "행렬 $A$는 역행렬을 가질까요?"라고 물어보면 여러분들은 "A와 곱하여 단위 행렬 (identity matrix)가 나오게 하는 행렬이 있는지 찾아보겠습니다!"라고 대답하셔야 합니다.

그럼 우리는 단위 행렬은 행렬 $A$와 같은 차원인 $2\times2$를 가지는 $\begin{bmatrix}1&0\\0&1\end{bmatrix}$이라는 것을 배웠습니다.

그렇다면 앞서 배운 행렬 곱셈 방식에서 결과로 도출되야하는 단위 행렬의 '첫번째' Column $\begin{bmatrix}1&0\end{bmatrix}$는 행렬 $A$의 전체와 곱해질 행렬의 '첫번째' Column의 linear combination으로 도출된다고 배웠습니다. 그렇다면 그렇게 만들어주는 Column이 존재할까요?

안타깝게도 $A$ 행렬의 두 Columns $\begin{bmatrix}1&2\end{bmatrix}$와 \begin{bmatrix}3&6\end{bmatrix}은 직선 $y=2x$위에 있고, 해당 직선은 $\begin{bmatrix}1&0\end{bmatrix}$을 지나가지 않기 때문에 그러한 Column은 존재하지 않습니다. 이것이 우리가 역행렬의 존재유무를 판단하는 첫번째 방법입니다!

Singular matrix의 의미는 해당 행렬의 Linear combination으로 0을 만들 수 있다는 뜻입니다. 앞서 non-singular 행렬은 역행렬을 가지기 때문에 singular matrix는 역행렬을 가지지 못한다고 해석할 수 있습니다.

왜냐하면 어떤 combination으로 0이 도출된다면 역행렬을 곱했을 때 단위 행렬이 못나오고 0에서 못 빠져나온다는 뜻으로 해석되기 때문입니다!

앞서 본 행렬 $A$는 벡터 $\begin{bmatrix}3&-1\end{bmatrix}$를 곱했을때 0이 나옵니다. 그렇기 때문에 $A$는 singular matrix고 역행렬을 가질 수 없는 또 하나의 이유가 되는 것입니다.

3. 가우스-조던 소거법

가우스-조던 소거법은 선형 대수를 한번이라도 공부해보셨다면 익히 들어보았을 단어입니다. 쉽게 말해서 어떤 행렬 A에 대해 역행렬이 존재한다면, 그 역행렬을 구하는 방법입니다!

$$\begin{bmatrix}1&3\\2&7\end{bmatrix}\begin{bmatrix}a&b\\c&d\end{bmatrix}=\begin{bmatrix}1&0\\0&1\end{bmatrix}$$

위와 같이 행렬 $A$와 역행렬을 가진다면, 그 역행렬과 곱했을 때는 단위 행렬이 나와야할 것입니다. 그때 이 역행렬을 구해보세요!라고 얘기를 한다면, 다음과 같이 우선 그림을 그려주시면 됩니다!

우리가 이전에 배웠던 소거법에 따라 행렬 $A$의 2번째 row에 '3'을 0으로 만들어주려고 합니다! 그러려면 첫번째 row에 3을 곱하여 2번째 row에 빼줘야할텐데요. 이때 $A$에만 3을 곱해서 빼주는것이 아니라, $I$에도 같은 연산을 똑같이 적용해주면 됩니다!

그러면 행렬 $A$는 상삼각행렬 (Upper triangle matrix)가 되는데요. 여기서 멈추는 것이 아니라, 행렬 $A$를 단위 행렬이 되게끔 윗쪽 방향으로 소거를 진행해주시는 겁니다!

그러니까 가우스-조던 소거법이라 하면 행렬 $A$와 $I$를 나란히 놓고 $A$를 단위 행렬로 바꾸는데 그때 적용되는 연산을 똑같이 $I$에 적용하여 나온 행렬이 $A$의 역행렬이 되는것입니다!

즉 위와같이 $A$의 두번째 row에 3을 곱해서 첫번째 row에 빼주면 나온 오른쪽 행렬이 역행렬이라고 할 수 있습니다!

긴 글 읽어주셔서 감사합니다! 행복한 하루 보내세요 :)

바로 다음 강좌로 고고!

[이론/MIT 선형대수] - [문과도 이해하는 선형대수 for 딥러닝] 4. 행렬 분해 (Matrix factorization)

[문과도 이해하는 선형대수 for 딥러닝] 4. 행렬 분해 (Matrix factorization)

의심으로 가득 찬 마음은 승리로의 여정에 집중할 수 없다. - 아서 골드 - 이번 포스팅에서 다룰 내용은 행렬 분해 (Matrix factorization)입니다. Matrix Factorization은 데이터를 분석하고 모델링하는데 널

box-world.tistory.com

[문과도 이해하는 선형대수 for 딥러닝] 2. 행렬 소거 (Elimination with Matrices)

Box형 — Wed, 8 Mar 2023 20:07:49 +0900

성공의 커다란 비결은 결코

지치지 않는 인간으로 인생을 살아가는 것이다.

- 알버트 슈바이처 -

안녕하세요 저번 포스팅에서는 선형 대수 공부의 첫 단원으로써, 선형 방정식을 Row picture와 Column picture의 관점에서 바라보고 이를 이용하여 식의 솔루션을 구하는 방법들에 대해 간단히 살펴보았습니다. 해당 포스팅을 먼저 읽고 이번 포스팅을 공부하시면 면 이해하는데 큰 도움이 됩니다 :)

[이론/MIT 선형대수] - [문과도 이해하는 선형대수 for 딥러닝] 1. 선형 방정식 (The geometry of linear equations)

[문과도 이해하는 선형대수 for 딥러닝] 1. 선형 방정식 (The geometry of linear equations)

사람들이 대개 기회를 놓치는 이유는 기회가 작업복 차림의 일꾼같아 일로 보이기 때문이다. - 토마스 A. 에디슨 - 제 블로그의 'MIT 선형대수' 카테고리의 포스팅들은 Gilbert Strang 교수님의 Linear Al

box-world.tistory.com

이번 시간은 앞서 본 선형 방정식의 해를 구하는 또 하나의 방법인 소거 (Elimination)에 대해 공부해보겠습니다!

1. 소거 (Elimination)

아래엔 우리가 풀어야 할 선형 방정식이 주어져있습니다.

$$\begin{cases}x+2y+z=2 \\ 3x+8y+z=12 \\ 4y+z=2 \end{cases}$$

위 식에서 좌변의 계수 (coefficient)를 행렬로 표현하면 다음과 같습니다. 우변에 존재하던 벡터 $\begin{bmatrix}2 \\ 12 \\ 2 \end{bmatrix}$는 이따가 함께 다시 고려하겠습니다.

$$\begin{bmatrix}1 & 2 & 1 \\ 3 & 8 & 1 \\ 0 & 4 & 1 \end{bmatrix}$$

이제부터 elimination을 해볼텐데요. 이것의 목표는 결국 아래와 같은 모양의 상 삼각행렬 (Upper triangle matrix)를 도출하는 것입니다. 이렇게 되면 가장 아래의 row에서는 $u_{n,n}=?$의 식부터 미지수가 하나씩 풀리면서 이 값을 바로 위 식들에 차례로 연쇄적으로 대입해가며 풀리게 됩니다! (이 과정이 이따 살펴볼 역 대입입니다)

다시 $\begin{bmatrix}1 & 2 & 1 \\ 3 & 8 & 1 \\ 0 & 4 & 1 \end{bmatrix}$로 돌아와서 이것을 위 형태로 변형시키기 위해서는 2행의 3을 제거해줘야합니다. 이를 위해서 1행에 3을 곱해서 2행에서 빼면 간단히 해결되겠죠? 결과는 다음과 같습니다.

$$\begin{bmatrix}1 & 2 & 1 \\ 0 & 2 & -2 \\ 0 & 4 & 1 \end{bmatrix}$$

이제 우리는 3행의 4를 지우면 Upper triangle matrix (=$U$)의 형태를 얻을 수 있습니다. 이를 위해서 2행에 2를 곱하여 3행에 빼면 될 것이고 결과는 다음과 같습니다.

$$U = \begin{bmatrix} \underline{1} & 2 & 1 \\ 0 & \underline{2} & -2 \\ 0 & 0 & \underline{5} \end{bmatrix}$$

이때 위 식에서 밑줄 친 숫자들은 피봇 (pivot)이라고 칭합니다. 이때 pivot은 절대 0이 될 수 없습니다.

그렇다면 다른 예로 소거 과정에서 $\begin{bmatrix}0& 2 & 1 \\ 1 & 2 & -2 \\ 0 & 4 & 1 \end{bmatrix}$처럼 1행의 첫번째 자리에 0이 있다고 해서 elimination에 실패한 것일까요? 그렇진 않고 간단하게 1행과 2행을 바꾸어 주면 됩니다! 그러나 $\begin{bmatrix}0& 2 & 1 \\ 0 & 2 & -2 \\ 0 & 4 & 1 \end{bmatrix}$처럼 어떤 행과 교환해도 소용없다면 이 경우 elimination을 할 수 없다고 판단합니다.

2. 역 대입 (Back subtitution)

이제 우변까지 고려하여 함께 elimination을 진행해보겠습니다. 이를 위해 우변의 벡터를 다음과 같이 첨가하겠습니다. 이때 첨가된 우변의 벡터를 augmented matrix라고 부릅니다.

$$\begin{bmatrix}1 & 2 & 1 & 2 \\ 3 & 8 & 1 & 12\\ 0 & 4 & 1 &2 \end{bmatrix}$$

위 식을 아까 우리가 같이 했던 소거 방식을 똑같이 적용하면 다음과 같은 결과가 도출됩니다! 계산 과정은 생략하겠습니다..ㅎㅎ

$$\begin{bmatrix}1& 2 & 1 & 2 \\ 0 & 2 & -2 & 6\\ 0 & 0 & 5 & -10\end{bmatrix}$$

이제 위 행렬 식을 아래와 같이 우리에게 친숙한 연립 방정식의 형태로 가져오면, 그 다음은 제가 설명드리지 않아도 모두가 너무나도 잘 아시는 과정이죠? $z$부터 시작하여 아래에서 위로 올라가면서 연쇄적으로 미지수를 구하게 됩니다! 이것을 역 대입 (Back subtitution)이라고 합니다.

3. Matrix multiplication

방금까지 우리는 행렬 $A$에서 Upper triangle 행렬 $U$를 도출하는 과정을 보았습니다. 그리고 이때 $A$와의 곱셈을 통해 $U$를 도출시켜주는 행렬을 Elimination matrix라고 부르는데요. 이 과정이 보다 직관적으로 쉽게 다가오게 하는 연산 두가지에 대해 먼저 공부해보겠습니다. 우선 행렬과 Column vector의 곱셈에 대해 살펴보겠습니다.

$$\begin{bmatrix}-&-&- \\ -&-&-\\ -&-&- \end{bmatrix} \begin{bmatrix}3 \\ 4 \\ 5 \end{bmatrix}=\begin{bmatrix}3 \times Column \ 1 \\ 4 \times Column \ 2 \\ 5 \times Column \ 3 \end{bmatrix}$$

위에서 보다시피 행렬곱셈, 즉 왼쪽에 행렬이 있고 이것과 벡터를 곱하게 될땐 Columns에 대한 linear combination과 같습니다. 이제 row vector과 행렬의 곱셈에 대해 살펴보겠습니다.

$$\begin{bmatrix}1 & 2 & 7 \end{bmatrix} \begin{bmatrix}-&-&- \\ -&-&-\\ -&-&- \end{bmatrix}=\begin{bmatrix}1 \times row \ 1 \\ 2 \times row \ 2 \\ 7 \times row \ 2 \end{bmatrix}$$

위와 같이 row vector와 행렬의 곱셈은 row에 대한 선형결합이 됩니다.

4. 소거 행렬 (Elimination matrix) 구하기

$$\begin{bmatrix}E_{1,1}&E_{1,2}&E_{1,3} \\ E_{2,1}&E_{2,2}&E_{2,3}\\ E_{3,1}&E_{3,2}&E_{3,3} \end{bmatrix} \begin{bmatrix}1 & 2 & 1 \\ 3 & 8 & 1 \\ 0 & 4 & 1 \end{bmatrix} = \begin{bmatrix}1 & 2 & 1 \\ 0 & 2 & -2 \\ 0 & 4 & 1 \end{bmatrix}$$

이제 우리는 앞서 보았듯 행렬 $A$를 $U$로 만드는 Elimination matrix를 구해보려 합니다. 우선 $E_1$의 첫번째 row인 $\begin{bmatrix}E_{1,1}&E_{1,2}&E_{1,3}\end{bmatrix}$는 무엇일까요? 쉽게 생각해서 첫번째 row가 무엇이어야 이것을 $A$를 곱하여 $U$의 첫번째 row가 나올까?를 생각하면 됩니다!

마찬가지로 Elimination matrix의 두번째 row와 $A$를 곱하여 $\begin{bmatrix}0 & 2 & -2 \end{bmatrix}$가 나오게 하는 row는 앞서 말했듯 $A$의 첫번째 row를 3배하여 두번째 row에 빼야하므로 $\begin{bmatrix}-3 & 1 & 0 \end{bmatrix}$이 됩니다. 마찬가지의 원리를 세번째 row에도 적용하면 다음과 같이 나오겠죠

$$\begin{bmatrix}1&0&0 \\ -3&1&0\\ 0&0&1 \end{bmatrix} \begin{bmatrix}1 & 2 & 1 \\ 3 & 8 & 1 \\ 0 & 4 & 1 \end{bmatrix} = \begin{bmatrix}1 & 2 & 1 \\ 0 & 2 & -2 \\ 0 & 4 & 1 \end{bmatrix}$$

이제 우리는 $\begin{bmatrix}1 & 2 & 1 \\ 0 & 2 & -2 \\ 0 & 4 & 1 \end{bmatrix}$을 최종적인 U로 만들어준 또다른 Elimination matrix를 찾아야합니다. 마찬가지로 구하면 다음과 같겠죠? (계산은 생략하겠습니다!)

$$\begin{bmatrix}1&0&0 \\ 0&1&0\\ 0&-2&1 \end{bmatrix} \begin{bmatrix}1 & 2 & 1 \\ 0 & 2 & -2 \\ 0 & 4 & 1 \end{bmatrix} = \begin{bmatrix}1 & 2 & 1 \\ 0 & 2 & -2 \\ 0 & 0 & 5 \end{bmatrix}$$

이때 앞서 첫번째 찾았던 Elimination matrix를 $E_1$, 방금 구한 Elimination matrix를 $E_2$라고 한다면, 우린 결국 $U$를 구하는 과정을

$$E_2(E_1A)$$

라고 표현할 수 있습니다. 이때 본래 행렬 간의 곱셈에선 순서를 바꿀 수 없지만, 누굴 먼저 곱할지는 괄호를 바꿔 $$(E_2E_1)A$$처럼 사용할 순 있습니다.

이번 포스팅에서는 선형 방정식의 Solution을 구하는 또 하나의 방법인 Elimination matrix에 대해 공부해보았습니다.

긴 글 읽어주셔서 감사합니다. 오늘도 행복한 하루 보내세요 :)

다음 포스팅도 바로 보러 고고!

[이론/MIT 선형대수] - [문과도 이해하는 선형대수 for 딥러닝] 3. 행렬곱, 역행렬, 가우스-조던 소거법 (Multiplication and Inverse Matrices)

[문과도 이해하는 선형대수 for 딥러닝] 3. 행렬곱, 역행렬, 가우스-조던 소거법 (Multiplication and Inve

box-world.tistory.com

[문과도 이해하는 선형대수 for 딥러닝] 1. 선형 방정식 (The geometry of linear equations)

Box형 — Wed, 1 Mar 2023 15:16:54 +0900

사람들이 대개 기회를 놓치는 이유는 기회가

작업복 차림의 일꾼같아 일로 보이기 때문이다.

- 토마스 A. 에디슨 -

제 블로그의 'MIT 선형대수' 카테고리의 포스팅들은 Gilbert Strang 교수님의 Linear Algebra 강의를 기반으로 작성되었습니다. 이번 포스팅에서는 선형 대수 강의의 첫 포문을 여는 내용인만큼 기본적인 개념부터 시작하여 차근차근 나아가보려 합니다.

포스팅의 제목 그대로 문과생분들도 이해할 수 있을만큼 차분히 설명드릴테니 잘 따라와주셨으면 좋겠습니다:) (저 또한 고등학교때 문과생이었다가 컴퓨터공학과로 와서 수학 공부에 너무 힘들었기 때문입니다...^^;;;)

1. 선형 방정식 (Linear equation) 이란?

여기 두 개의 식이 있습니다.

$$\begin{cases}2x-y=0 \\ -x+2y=3\end{cases}$$

이것을 행렬로 표현하면 어떻게 될까요? 바로 위 식들의 계수들 (coefficients)만 가져와서 이들의 배열을 만들어주면 됩니다!

$$\begin{bmatrix}2 & -1 \\ -1 & 2 \end{bmatrix} \begin{bmatrix}0 \\ 3 \end{bmatrix} = \begin{bmatrix}0 \\ 3 \end{bmatrix}$$

이때 계수에 대한 행렬은 $A$, 미지수에 대한 벡터 (1차원 행렬은 벡터라고 칭합니다)는 $x$ 그리고 이들을 결합하여 만들어진 우변의 벡터는 $b$라고 합니다.

따라서 우린 이제부터 선형대수를 공부하는 것이므로 두개의 식을 보았을 때 고등학교에서 배운 연립 방정식이 아닌 저 식들을 행렬의 형태로 구성하여 '선형방정식' $Ax=b$의 형태로 문제를 접근해야합니다.

2. Row picture

앞서본 선형 방정식의 Row picture은 무엇인가요? 라고 누군가 물어본다면, 우린 저 선형방정식을 구성하는 두 식을 그림의 형태 즉 좌표평면상에서 표현해주면 됩니다! 다시 말해서 $2x-y=0$과 $-x+2y=3$을 좌표평면에 그려주면 되는것이죠.

아무래도 이것을 그리는 방법은 워낙 고등학교 때 많이 해왔던 일이기 때문에 아무 생각없이 그릴 수 있겠지만, 이것을 잘 생각해보면 결국 우린 한 직선이 지나는 두 점을 찾아 그것을 연결하고 있음을 떠올릴 수 있습니다.

$2x-y=0$는 $(0,0),(1,2)$와 같은 점들을 지나고, $-x+2y=3$은 원점을 지나진 않지만 $(-3,0),(-1,2)$와 같은 점들을 지난다는 것을 쉽게 떠올릴 수 있습니다. 이를 이용하여 그림을 그려보면 다음과 같겠죠!

여기서 우리가 보통 주목하는 부분은 각 직선의 $y$절편과 두 직선간의 교점 $(1,2)$ 같은 것들이 있습니다. 결국 우리는 선형방정식의 Row picture를 통해서 두 직선을 모두 만족하는 솔루션 $(1,2)$을 찾았다고 얘기할 수 있습니다.

3. Column picture (중요)

이제 우린 앞서 본 선형 방정식의 Column picture을 살펴보겠습니다. 이름 그대로 행렬의 Column (세로 줄)을 이용하여 다음과 같이 표현한 것이 Column picture라고 할 수 있습니다.

$$x\begin{bmatrix}2 \\ -1 \end{bmatrix}+y\begin{bmatrix}-1 \\ 2 \end{bmatrix}=\begin{bmatrix}0 \\ 3 \end{bmatrix}$$

이 방정식은 벡터 $\begin{bmatrix}2 \\ 1 \end{bmatrix}$와 $\begin{bmatrix}-1 \\ 2 \end{bmatrix}$를 $x$와 $y$를 통해 올바른 양으로 결합하여 $\begin{bmatrix}0 \\ 3 \end{bmatrix}$을 만들라고 우리에게 요구한다고 볼 수 있습니다. 즉 다시말해 우리에게 올바른 선형 조합 (linear combination)을 요구하는 것입니다!

이제 위 Column picture를 그림으로 표현하여 Column들을 결합해보겠습니다. 그림은 다음과 같습니다.

우리는 앞서서 $x=1, y=2$일 때 우변의 벡터 $\begin{bmatrix}0 \\ 3 \end{bmatrix}$를 얻는다는 것을 확인했는데, 이것이 위 그림을 통해서 기하적으로는 어떻게 도출될까요?

우선 $\begin{bmatrix}2 \\ 1 \end{bmatrix}$은 $x=1$이므로 변화없이 그대로 멈춰있지만, $\begin{bmatrix}-1 \\ 2 \end{bmatrix}$의 경우 $y=2$이므로 2배가 되면서 이것을 $\begin{bmatrix}2 \\ 1 \end{bmatrix}$과 더해주면 하늘색 벡터 즉 $\begin{bmatrix}0 \\ 3 \end{bmatrix}$가 도출됩니다.

그렇다면 $\begin{bmatrix}0 \\ 3 \end{bmatrix}$과 상관없이, 어떠한 값이든 $x, y$에 들어갈 수 있게되면서 솔루션은 좌표평면의 모든 공간을 채우게 됩니다. 여기까지는 2개의 방정식과 2개의 미지수를 가지고 다룰 수 있는 개념이었습니다.

이제는 3개의 방정식과 3개의 미지수에 대해서 다뤄보겠습니다.

$$\begin{cases}2x-y+0z=0\\-x+2y-z=-1\\0x-3y+4z=4\end{cases}$$

제가 여러분들에게 위 연립 방정식을 선형대수의 관점에서 어떻게 풀수 있습니까?라고 물어보면 머릿속에서는 1) Row picture 2) Column picture 두가지가 생각나야 합니다. 우선 Row picture의 관점에서 생각하려면 계수 행렬 (Coefficient matrix)부터 표현해야겠죠.

$$A=\begin{bmatrix}2&-1&0\\-1&2&-1\\0&-3&4\end{bmatrix} \; b=\begin{bmatrix}0\\-1\\4\end{bmatrix}$$

우선 저 선형 방정식의 솔루션을 구하기 앞서서 각 식에 대한 솔루션부터 생각해보겠습니다. $-x+2y-z=-1$의 솔루션부터 생각하면 $\begin{bmatrix}0 \\ 0 \\ 1 \end{bmatrix}$같은 것이 솔루션이 될 것이고 모든 해를 구하면 다음과 같은 평면으로 나타날 수 있습니다.

그리고 $2x-y+0z=0$나 $0x-3y+4z=4$의 경우엔 계산해보면 아래와 같은 평면으로 나타날 것입니다.

제 미숙한 그림 실력으로 이해 하시기 어려우실 순 있으시겠지만(^^;;) 중요한건 저 세 평면들은 평행하지 않기에 하나의 점에서 만나게 되고 그것이 곧 선형 방정식의 솔루션이 되는 것입니다. 우리가 느낄 수 있는건 2차원까진 Row picture로도 풀만 했지만 차원이 높아질수록 Row picture로 풀기 어려워집니다. 따라서 우리는 Column picture를 더욱 선호하게 됩니다!

그렇다면 아래와 같이 Column picture로 접근해보겠습니다.

$$x\begin{bmatrix}2 \\ -1 \\ 0 \end{bmatrix}+y\begin{bmatrix}-1 \\ 2 \\ -3 \end{bmatrix}+z\begin{bmatrix}0 \\ -1 \\ 4 \end{bmatrix}=\begin{bmatrix}0 \\ -1 \\ 4 \end{bmatrix}$$

결국 우리는 저 세가지의 벡터를 조합하여 (Linear combination하여) $\begin{bmatrix}0 \\ -1 \\4 \end{bmatrix}$를 얻고 싶은 것입니다. 그렇다면 위 Column picture를 기하적으로 표현하여 접근해보겠습니다.

이제 솔루션을 생각해보자면 가장 쉬운 솔루션 중 하나는 Column 3가 $b$와 동일한 $\begin{bmatrix}0 \\ -1 \\4 \end{bmatrix}$이기 때문에 $(0,0,1)$입니다. 이 점이 결국 앞서 Row picture에서 봤던 세 개의 평면이 만나는 한 점인 것입니다.

4. Non-singular ( invertible ) matrix

앞서서 특정 $b$에 대해 선형 방정식의 솔루션을 구하는 과정에 대해 살펴보았습니다.

그렇다면 앞서 보았던 저 선형 방정식은 모든 3차원 벡터 $b$에 대해 솔루션을 가질까요? 라고 물어본다면 이 말은 곧 저 선형 방정식을 구성하는 Column들의 linear combination은 3차원 공간을 모두 채울 수 있나요?를 물어보는 것입니다.

앞서 우리가 계속 다뤘던 아래 컬럼에 대해서는 우린 'yes'라고 얘기할 수 있습니다. 이런 행렬을 우리는 'non-singular' 혹은 'invertible' 행렬이라고 부릅니다. 반대로 모든 $b$에 대한 솔루션이 존재하지 않고 일부의 $b$에서만 존재한다면 이는 'singular' 행렬입니다. 당연하겠지만 우린 non-singular를 좀더 선호해야겠죠.

정리하자면 우리는 오늘 하나의 선형 방정식을 푸는 두 가지의 접근 1) Row picture와 2) Column picture에 대해서 살펴보았고, Non-singular ( invertible ) matrix의 개념까지 살펴보았습니다. 한가지 유념하면 좋을 것은 $Ax=b$에서 각각의 row와 $x$를 곱하는 관점은 내적 (dot product)의 관점이다라고 보고, Column picture의 관점에서 $A$의 컬럼을 기준으로 해를 푼다면 컬럼들의 Linear combination의 관점이다라고 이해해주시면 좋습니다.

오늘도 긴 저의 포스팅을 읽어주셔서 감사합니다. 행복한 하루 보내세요! :)

다음 포스팅도 보러 바로 고고!

[이론/MIT 선형대수] - [문과도 이해하는 선형대수 for 딥러닝] 2. 행렬 소거 (Elimination with Matrices)

[문과도 이해하는 선형대수 for 딥러닝] 2. 행렬 소거 (Elimination with Matrices)

box-world.tistory.com

[ Flutter ] 앱 시작할때 나오는 로딩 화면 구현하기! (Splash Screen)

Box형 — Wed, 4 Aug 2021 15:56:09 +0900

배민이든, 넷플릭스 등 우리가 쓰고 있는 99%의 앱은 처음 실행하면 바로 메인 페이지가 나오지 않고, 위처럼 로고가 떠있는 화면을 지나서 들어가게 됩니다.

이러한 화면이 필요한 이유는 단순히 로고 자랑을 하려고 보여준다기보다는, 여기에 머무는 동안 자동 로그인을 통해 데이터를 가져오거나, 보안과 관련되어 검사를 진행하는데 약간의 시간이 필요하기 때문입니다.

혹은 경우에 따라서 서비스 점검을 위해 이 화면에서 더 이상 접근을 못하게 막는다던가 간단해 보이지만 상당히 의미있는 화면이라고 할 수 있습니다.

이러한 화면을 Splash Screen이라고 합니다. 이번 포스팅에서는 이러한 SplashScreen을 구현하는 방법에 대해 알아보겠습니다.

화면 준비하기

우선 SplashScreen이 될 화면을 준비해줍니다.

@override
  Widget build(BuildContext context) {
    final String imageLogoName = 'assets/images/public/PurpleLogo.svg';

    var screenHeight = MediaQuery.of(context).size.height;
    var screenWidth = MediaQuery.of(context).size.width;

    return WillPopScope(
      onWillPop: () async => false,
      child: MediaQuery(
        data: MediaQuery.of(context).copyWith(textScaleFactor:1.0),
        child: new Scaffold(
          backgroundColor: hexToColor('#6F22D2'),
          body: new Container(
            //height : MediaQuery.of(context).size.height,
            //color: kPrimaryColor,
            child: Column(
              mainAxisAlignment: MainAxisAlignment.start,
              children: <Widget>[
                SizedBox(height: screenHeight * 0.384375),
                Container(
                  child: SvgPicture.asset(
                    imageLogoName,
                    width: screenWidth * 0.616666,
                    height: screenHeight * 0.0859375,
                  ),
                ),
                Expanded(child: SizedBox()),
                Align(
                  child: Text("© Copyright 2020, 내방니방(MRYR)",
                      style: TextStyle(
                        fontSize: screenWidth*( 14/360), color: Color.fromRGBO(255, 255, 255, 0.6),)
                  ),
                ),
                SizedBox( height: MediaQuery.of(context).size.height*0.0625,),
              ],
            ),

          ),
        ),
      ),
    );
  }

initState에 다음 화면으로 넘어가는 코드를 추가

화면이 준비됐으면, 일정 시간 이후 다음 화면으로 넘어가는 코드를 추가해줍니다. 아래 코드는 1.5초 후에 자동으로 Navigate하는 코드입니다.

@override
  void initState() {
  	Timer(Duration(milliseconds: 1500), () {
                  Navigator.push(context, MaterialPageRoute(
                      builder: (context) => LoginMainScreen()
                  )
                  );
                });
  }

다음은 구현된 결과입니다.

(응용) 특정 조건을 만족시키지 않으면 Navigate 막고 앱 종료하기

앞서 말씀드린대로 SplashScreen에서는 상황에 따라, 서비스 점검이나 기타 사안들에 의해 더 이상이 Navigate를 막고 앱을 종료시켜야하는 경우도 있습니다. 이 또한 initState()에서 구현합니다.

@override
  void initState() {
  	Timer(Duration(milliseconds: 1500), () {
    		if(Condition){
					exit(0);
                }
                else{              
                      Navigator.push(context, MaterialPageRoute(
                      builder: (context) => LoginMainScreen()
                  )
                  );
                }
                });
  }

[ Flutter ] PageView 자동 스크롤 기능 넣기!

Box형 — Tue, 3 Aug 2021 17:25:19 +0900

대부분 스타트업에서 만든 플랫폼 서비스 앱의 첫 메인페이지를 들어가게 되면 보통 우리는 위 사진처럼 상단에 프로모션 광고가 보이는 대형 PageView를 보게됩니다.

그리고 일정 시간마다 이들은 돌아가면서 다른 광고들을 순차적으로 보여줍니다. 이번 포스팅에서는 Flutter에서 PageView에서 일정 시간마다 자동으로 스크롤되는 기능을 구현해보겠습니다!

PageView 준비하기

당연하겠지만 우선 PageView가 있어야겠죠? 여기에 대한 코드를 준비해줍니다.

PageView.builder(
                        pageSnapping: true,
                        controller: _PageController,
                        itemCount: itemList.length,
                        onPageChanged: (value) {
                         
                        },
                        itemBuilder: (context, index) {
                          return Container(
                            child: Image.asset(
                                bannerPNG[index],
                                width: screenWidth,
                                height: screenWidth * (140/360),
                                fit: BoxFit.cover),
                          );
                        },
                      ),

위 PageView.builder에서 우리가 주목해야할 부분은 두 가지 입니다.

controller
onPageChanged

자동 스크롤 기능 넣기

이제 initState() 메서드 내에 자동 스크롤 기능을 넣겠습니다.

int currentPage = 0;
PageController _PageController = PageController(
    initialPage: 0,
  );
  
@override
  void initState() {
    super.initState();

    Timer.periodic(Duration(seconds: 5), (Timer timer) {
      if (currentPage < 2) {
        currentPage++;
      } else {
        currentPage = 0;
      }

      _PageController.animateToPage(
        currentPage,
        duration: Duration(milliseconds: 350),
        curve: Curves.easeIn,
      );
    });
  }

필요한 변수는 다음과 같습니다.

currentPage
_PageController

저와 변수명이 같다는 가정하에 initState내에 저 코드만 그대로 넣어주시면 자동 스크롤 기능 구현 끝입니다! 만약 넘겨지는 시간을 조정하고 싶다면 Timer.periodic 내 Duration 값을 수정해주시면 됩니다.

실행시키면 다음과 같은 결과가 나옵니다

[머신러닝 순한맛] LSTM의 모든 것

Box형 — Sun, 1 Aug 2021 02:33:14 +0900

아무리 어려워도 한번 시작한 일은 끝까지 해라

- 안드레아 정 (에어본 회장) -

저번 포스팅에서 우리는 RNN을 이용하여 주어진 Time-Series 데이터를 이용하여 미래를 예측하는 forecasting에 대해 공부해보았습니다. 하지만 이전에 우리가 다뤘던 데이터들의 길이는 상대적으로 짧은 축에 속했습니다.

몇달이 아닌 몇 년 치의 데이터에도 RNN은 좋은 성능을 보일까요?

긴 시퀀스(상대적으로 많은 타임 스텝을 가지는 Time-Series Data)로 훈련하려면 많은 타임 스텝에 걸쳐 실행해야 하므로 RNN은 그만큼 매우 깊은 네트워크가 됩니다. 보통 이렇게 깊어진 RNN은 다음과 같은 문제가 발생할 수 있습니다.

깊어진만큼 Gradient Vanishing 문제나 Exploding 문제가 발생할 수 있습니다.
길어진 데이터를 처리하면서 Input data의 초기 타임 스텝을 점점 잊어버릴 것입니다.

이번 포스팅에서는 RNN으로 긴 시퀀스 데이터를 다루기 위해서 어떤 점을 보완해야하는지 알아보겠습니다. 그리고 더 나아가서 LSTM과 GRU까지 모든 것을 파헤쳐보겠습니다.

이번 포스팅은 RNN을 공부하고 정독하시면 더욱 효과적입니다.

[AI/Hands-On Machine Learning 2판] - [ 머신러닝 순한 맛 ] 시계열 데이터의 모든 것, RNN 정복하기!

[ 머신러닝 순한 맛 ] 시계열 데이터의 모든 것, RNN 정복하기!

사는 데 더 나은 방법을 찾아라 - 엘빈 토플러 - 코로나로 인해 가장 크게 떠오른 분야가 무엇이냐고 한다면, 저는 주식만한게 없다고 생각합니다. 우린 결국 돈을 벌고 싶고, 미래를 예측하여

box-world.tistory.com

RNN으로 긴 시퀀스 다루기

앞서 간단하게 언급한대로, Gradient Vanishing/Exploding 문제때문에 있는 그대로의 RNN을 바로 긴 시퀀스에 적용하는 것은 어렵다는 것을 알았습니다.

이전에 우리가 공부한 Neural Network에서도 깊을 경우 이러한 Gradient 문제가 존재했고, 이를 위해 Gradient Initialization / Fast Optimization / DropOut 등 다양한 해결 방법이 있었습니다.

이러한 방법은 RNN에도 똑같이 적용될 수 있는데, 딱 하나 Relu(수렴되지 않는 activation 함수)와 같은 방법은 도움이 되지 않고 되려 더 불안하게 만들 수 있습니다.

예를 들어 이유를 설명드리겠습니다. Gradient Descent 알고리즘에 의해 첫번째 타임 스텝에서 Output을 조금 증가시키는 방향으로 Gradient Update가 이뤄졌다고 가정해보겠습니다. 그런데 이러한 방향의 Update가 두번째에도, 세 번째에도 계속 반복된다면 Gradient Exploding 문제가 일어나게 됩니다.

즉 RNN에서는 Relu와 같은 함수가 Gradient 문제를 해결하는데 도움이 되지 않습니다. 작은 Learning Rate를 사용하면 이런 위험을 감소시킬 수 있지만, 간단하게 tanh 함수와 같이 '수렴하는' activation 함수를 사용할 수 있습니다.

Batch Normalization은 RNN에서 그다지 효율적이지 않습니다. 정확하게 말하자면 타임 스텝을 넘어갈 때 사용할 수는 없고 하나의 타임 스텝을 처리하는 Layer들 사이에만 적용할 수 있습니다. 그렇지만 크게 기대할만큼 좋은 성능을 내지 못합니다.

그럼 RNN에 잘 맞는 Normalization은 뭘까요? 그것은 바로 층 정규화(Layer Normalization)입니다. 2016년에 소개된 이 개념은 Batch Normalization와 비슷하지만, Batch 차원이 아닌 Feature 차원에 대해 정규화가 이뤄집니다.

말로만 하면 잘 감이 안오실텐데 위 그림을 보면서 다시 생각해보겠습니다. feature 1, 2로 이루어진 50개의 데이터가 있다고 했을 때, 기존 BN(Batch Normalization)은 50개의 데이터를 Batch라는 단위로 몇개 그룹으로 분할하여 각 그룹의 평균과 분산을 구하여 정규화를 진행합니다.

반대로 LN(Layer Normalization)은 Batch 단위가 아니라, 50개 데이터에 존재하는 feature 1의 값을 모조리 모아 정규화를 진행하고, feature 2를 모아 모조리 정규화하는 방식입니다.

이렇게 전체 데이터를 feature를 기준으로 정규화를 하면, 내가 뽑는 batch에 따라 통계값이 달라지지 않고, 데이터에 독립적으로 필요한 통계값을 계산할 수 있기 때문에 Training과 Test에서 동일한 방식으로 작동하게 됩니다.

LN도 BN과 마찬가지로 Input마다 하나의 Scale과 Shift 파라미터를 학습합니다.

LSTM(Long, Short-Term Memory)

RNN을 거치면서 데이터의 길이가 길 수록 초기 타임 스텝의 정보는 사라지게 됩니다. 이는 중요한 문제이고 이를 해결하기 위해 소실되지 않게 장기적인 메모리를 가진 여러 종류의 셀이 연구되었습니다. 이 중 현재 가장 많이 쓰이는게 LSTM입니다.

LSTM은 훈련이 빠르게 수렴하고 데이터 내 장기간의 dependancy를 감지할 수 있습니다. 코드 상에선 기존에 사용하던 SimpleRNN 대신 LSTM을 사용해주면 되겠습니다.

model = keras.models.Sequential([
    keras.layers.LSTM(20, return_sequences=True, input_shape=[None, 1]),
    keras.layers.LSTM(20, return_sequences=True),
    keras.layers.TimeDistributed(keras.layers.Dense(10))
])

그렇다면 LSTM은 어떻게 작동할까요? 다음은 LSTM의 구조입니다.

셀 내부를 들여다보지 않는다면, LSTM 셀은 기존 한개의 셀에서 두개의 셀 $h_{(t)}$와 $c_{(t)}$을 받는다는 점 빼고는 정확히 일반 셀처럼 보입니다. 여기서 $h_{(t)}$는 단기 상태, $c_{(t)}$는 장기 상태를 의미합니다.

본격적으로 박스 내부를 하나하나 살펴보겠습니다. 핵심은 장기 상태 $c_{(t)}$에 저장할 것, 버릴 것, 그리고 읽어들일 것을 학습하는 것입니다.

장기 기억 $c_{(t-1)}$은 타임 스텝에 따라 네트워크를 지나면서 '삭제 게이트'를 지나 일부 기억을 잃고, 그 다음 덧셈 연산으로 '입력 게이트'에서 선택한 기억을 추가합니다. 그렇게 해서 만들어진 $c_{(t)}$는 별도의 변환없이 바로 출력으로 보내집니다.

$c_(t-1)$은 삭제 게이트를 지나 덧셈연산 후 복사되어(두 갈래로 나뉩니다) $tanh$ 함수로 전달되는데, 이는 '출력 게이트'에 의해 걸러집니다. 이것이 단기 상태 $h_{(t)}$입니다.(셀의 출력 $y_{(t)}$와 동일합니다.)

이제 현재 타임 스텝의 입력 벡터 $x_{(i)}$와 이전 단기 상태 $h_{(t-1)}$가 주입되는 네 개의 다른 FC Layer에 대해 사렾보겠습니다.

네 개 중 $g_{(i)}$를 출력하는 Layer는 input 벡터와 단기 상태를 분석하는 일반적이면서 Major한 Layer입니다. 기본 셀에서는 이 layer 외에 다른 것 없이 바로 $y_{(t)}$와 $h_{(t)}$를 출력했었습니다. 하지만 LSTM에서는 바로 출력되지 않고, 장기 상태에 가장 중요한 부분만 저장되고 나머지는 버립니다.
나머지 세 개의 layer는 Gate controller입니다. 이들은 logistic 함수를 사용하여 Output range가 0~1 사이입니다. 그림에서 보듯이 이들의 출력은 곱셉 연산으로 주입되어 0을 출력하면 게이트를 닫고, 1을 출력하며 게이트를 엽니다.
삭제 게이트 ($f_{(t)}$)는 장기 상태 $c_(t-1)$의 어느 부분이 삭제되어야하는지 제어합니다.
입력 게이트 ($i_{(t)}$)는 $g_{(t)}$의 어느 부분이 장기 상태 $c_{(t)}$에 더해져야 하는지 제어합니다.
출력 게이트 ($o_{(i)}$)는 장기 상태의 어느 부분을 읽어 현재 타임스텝의 $h_{(i)}$와 $y_{(i)}$로 출력해야 하는지 제어합니다.

꽤나 복잡해보이지만 간단하게 얘기하면 LSTM은 중요한 Input을 인식하고(입력게이트), 이 Input을 필요한 기간만큼 장기 상태에 저장하고(삭제게이트), 그리고 필요할때마다 이를 추출하기 위해 학습합니다.

다음은 하나의 샘플에 대해 타임 스텝마다 장기, 단기 상태와 게이트 출력값을 계산하는 법입니다.

핍홉 연결

일반적인 LSTM은 하나의 셀에서 입력 $x_{(t)}$와 이전 단기 상태 $h_{(t)}$를 받아들입니다.

그런데 게이트 제어기에 이 둘 외에도 '장기 상태'도 조금 노출 시키면 좀 더 많은 context(문맥)을 감지할 수 있지 않을까요?

그래서 제안된 것이 2000년대 핍홀 연결(peephole connection)이라 부르는 추가적인 연결이 있는 LSTM 변종입니다. 이것은 이전 장기 기억 상태 $c_{(t-1)}$이 삭제와 입력 게이트 $f_{(t)}$와 $i_{(t)}$에 입력으로 추가됩니다.

이는 성능을 향상하는 경우가 많지만, 매번 그렇지는 않기 때문에 직접 확인 후에 적용을 해야합니다.

GRU

GRU(Gated Recurrent Unit)은 2014년에 제안된 LSTM의 간소화된 버전입니다. 어떤 차이점이 있는지 살펴보겠습니다.

기존 LSTM의 장기 상태 $c_{(t)}$와 단기 상태 $h_{(t-1)}$가 $h_{(t-1)}$로 합쳐졌습니다.
하나의 게이트 제어기 $z_{(t)}$가 삭제와 입력 게이트 모두를 제어합니다. 이것이 1을 출력하면 삭제가 열리고 입력이 닫힙니다. 반대로 0을 출력하면 반대가 됩니다.
출력 게이트는 존재하지 않기 때문에 $h_{(t-1)}$가 매 타임 스텝마다 출력됩니다. 그러나 이전 상태의 어느 부분이 Major 층 ($g_{(t)}$)에 노출될지 제어하는 $r_{(t)}$가 있습니다.

다음은 계산 식입니다.

LSTM과 GRU는 RNN을 보편화하는데 매우 큰 역할들을 하였습니다. 그러나 100 타임 스텝 이상의 시퀀스에서 이들 역시 장기 패턴을 학습하는데 어려움이 있습니다. 이를 해결하기 위해 몇가지 방법들을 시도해볼 수 있습니다.

1D ConvolutionalLayer를 사용해 시퀀스 처리하기

Convolutional Layer라고 하면 본래 CNN에서 이미지가 입력으로 들어왔을 때 이미지의 주요한 특징을 잡아내기 위해 3x3과 같은 필터(커널)을 이용해 슬라이딩하면서 2D feature feature map을 뽑아내는 과정에서 쓰이는 용어였습니다.

특히 일반적인 구조라면 이 Conv Layer를 거치면서 중요한 특성만 뽑아내기 때문에 점점 네트워크를 통과하면서 기존 이미지보다 사이즈가 작아집니다. 바로 여기서도 이러한 원리를 이용합니다.

일반적으로 Time-Series는 이미지처럼 사각형이 아니라 지렁이처럼 하나의 긴줄로 들어오기 때문에 1D에서 존재합니다. 결국 LSTM이나 GRU가 일정 타임 스텝 이상의 시퀀스를 다루기 어렵기 때문에 매우 긴 시퀀스가 들어왔을 때, 여기에 필터를 슬라이딩시켜 중요한 특징을 가진 1D feature map을 추출하여 데이터의 크기를 줄이자는게 핵심이 되겠습니다.

만약 10개의 필터를 사용하면 해당 layer의 출력은 10개의 1D 시퀀스로 구성됩니다. 이것을 10차원 시퀀스로 볼 수 있겠죠. 이 말은 즉 RNN의 Recurrent Layer(우리가 지금까지 RNN에서 보던 SimpleRNN Layer)와 1D Conv Layer 심지어 1D Pooling 층까지 섞어서 Neural Network를 구성할 수 있다는 뜻이 됩니다.

코드를 통해 구현을 살펴보겠습니다. stride = 1과 "same" 패딩으로 1D conv Layer를 사용하면 input과 output의 길이는 같습니다. 그러나 "valid" 패딩과 1보다 큰 스트라이드를 사용하면 output 시퀀스의 길이는 input보다 짧아지게 됩니다.

다음은 stride = 2를 사용해 입력 시퀀스를 두 배로 Down-Sampling(반으로 줄이는) 1D Conv Layer를 사용합니다. 이렇게 길이를 줄이면 GRU 층이 더 긴 패턴을 감지하는데 도움이 됩니다.

model = keras.models.Sequential([
    keras.layers.Conv1D(filters=20, kernel_size=4, strides=2, padding="valid",
                        input_shape=[None, 1]),
    keras.layers.GRU(20, return_sequences=True),
    keras.layers.GRU(20, return_sequences=True),
    keras.layers.TimeDistributed(keras.layers.Dense(10))
])

model.compile(loss="mse", optimizer="adam", metrics=[last_time_step_mse])
history = model.fit(X_train, Y_train[:, 3::2], epochs=20,
                    validation_data=(X_valid, Y_valid[:, 3::2]))

2) WAVENET

2016년도에 등장한 WAVENET은 앞서 살펴본 1D Conv Layer의 개념을 이용합니다. 이 네트워크는 Layer마다 팽창 비율(dilation rate)을 두 배로 늘리는 1D Conv Layer를 쌓습니다.

여기서 dilation rate를 설명하기 전 receptive field에 대해 상기해보자면, 하나의 뉴런이 받아들이는 이미지 내 local한 영역입니다. dilation rate는 계산량 증가 없이 이 receptive field를 효과적으로 높이기 위해 아래처럼 필터 내부에 zero padding을 추가해 강제로 receptive field를 늘립니다.

위 그림에서 파란색이 Input이고, 초록색이 feature map입니다. 여기서 Input의 진한 파랑 부분에만 weight가 있고, 나머지는 0으로 채워넣습니다.

이것이 등장한 이유는 필터의 크기를 크게하면 receptive field도 커져 이미지의 일반적인 feature를 잡기에 용이하지만 연산의 양이 늘어나고, Overfitting의 우려가 있습니다. 보통의 CNN에서는 이를 해결하기 위해 Pooling을 사용합니다.

그러나 Pooling을 사용하면 기존 정보의 손실이 일어납니다. 따라서 이러한 dilation rate를 활용한 dilated Conv는 pooling없이 receptive field의 크기를 크게 가져갈 수 있다는 점에서 이점을 가집니다.

그래서 결국 이 dilation rate가 커질 수록 filter의 크기가 커지면서 아래처럼 0으로 채워지는 부분이 많아집니다.

아래는 WAVENET의 구조인데, Input과 가까운 하위 층은 dilation rate가 적으므로, 필터의 크기가 작기 때문에 일반적인 것보단 단기 패턴을 학습하고, 점점 dilation rate가 높아지는 상위층으로 갈수록 일반적인 장기 패턴을 학습하게 됩니다. 이러한 원리로 dilation rate를 두 배씩 늘리는 형태의 네트워크로 아주 긴 시퀀스도 효율적으로 처리합니다.

다음은 WaveNet의 구현입니다.

model = keras.models.Sequential()
model.add(keras.layers.InputLayer(input_shape=[None, 1]))
for rate in (1, 2, 4, 8) * 2:
    model.add(keras.layers.Conv1D(filters=20, kernel_size=2, padding="causal",
                                  activation="relu", dilation_rate=rate))
model.add(keras.layers.Conv1D(filters=10, kernel_size=1))
model.compile(loss="mse", optimizer="adam", metrics=[last_time_step_mse])
history = model.fit(X_train, Y_train, epochs=20,
                    validation_data=(X_valid, Y_valid))

다음 포스팅에서는 RNN과 Attention 기법을 이용한 NLP에 대해 공부해보겠습니다. 오늘도 읽어주셔서 감사합니다. 행복한 하루 보내시길 바랍니다 :)

[ 머신러닝 순한 맛 ] 시계열 데이터의 모든 것, RNN 정복하기!

Box형 — Wed, 28 Jul 2021 23:13:41 +0900

사는 데 더 나은 방법을 찾아라

- 엘빈 토플러 -

코로나로 인해 가장 크게 떠오른 분야가 무엇이냐고 한다면, 저는 주식만한게 없다고 생각합니다. 우린 결국 돈을 벌고 싶고, 미래를 예측하여 주식 가격을 예측할 수 있다면 더할 나위가 없겠죠^^

이미 월가를 비롯해 주식시장의 최전방에 위치해있는 기업들은 실제로 다양한 기술을 이용하여 주식 가격의 미래를 예측하여 이를 실제로 수익과 연결시킵니다. 이번 포스팅에서는 순환 신경망 RNN(Recurrent Neural Network)에 대해 알아보겠습니다.

이 RNN은 우리가 그동안 봐왔던 대부분의 네트워크처럼 고정된 길이의 Input이 아닌 임의의 길이를 가진 시퀀스를 다룰 수 있습니다. 시퀀스의 예로는 문장, 문서, 오디오 샘플 등 가변적인 길이가 가진 것들을 예시로 들 수 있고, 이것은 자동 번역, Speech to Text 같은 자연어 처리(NLP)에 매우 유용합니다.

Recurrent Neuron and Recureent Layer

지금까지 우리가 봐온 네트워크들에서 Input이라 하면, 출력층을 향해서 한 방향으로만 흘러가는 Feed-Forward Network였습니다. 그러나 지금부터 우리가 볼 RNN은 출력으로 나온 Output이 다시 입력으로 순환하여 들어가는 연결이 있다는 점에서 기존과 차이점을 보입니다.

위 그림의 가장 왼쪽에 있는 것은 입력 $x$를 받아서 출력 $y$를 내보내고 이것을 다시 자기 자신에게 입력으로 보내는 가장 간단한 RNN입니다. 이것은 각 타임 스텝 $t$(하나의 단위 데이터가 들어올 때마다)마다 $x_{(t)}$와 이전 타임 스텝의 출력인 $y_{(t-1)}$을 입력으로 받습니다. 이때 가장 첫번째 타임 스텝에서는 이전 출력이 없기 때문에 $y_{(t-1)}$를 0으로 잡습니다.

왼쪽의 가장 간단한 RNN이 매 타임스텝마다 $x$와 $y_{(t-1)}$를 받아 $y_{(t)}$를 내보내는 과정을 시간을 축으로 하여 위 그림의 오른쪽처럼 표현할 수 있습니다. 이를 시간에 따라 네트워크를 펼쳤다라고 말합니다.(즉 동일 뉴런을 타임 스텝마다 하나로 표현한 것입니다.)

이러한 하나의 순환 뉴런 여러개가 모여 구성된 층(Layer)는 쉽게 만들 수 있습니다.

뉴런이 여러개라는 건 입력이 여러 개라는 것이기 때문에 이제 입력은 스칼라가 아닌 벡터 $x_(t)$가 되고, 이전 타임 스텝의 출력 $y_{(t)}$ 또한 벡터가 됩니다. (하나의 뉴런의 출력은 스칼라입니다)

각 순환 뉴런은 두 개의 가중치 벡터를 가집니다. 하나는 입력 벡터 $x_(t)$, 다른 하나는 이전 타임 스텝의 출력 $y_{(t)}$을 위한 것입니다. 이것들을 각각 $W_x$, $W_y$라고 하겠습니다. 그렇다면 순환 뉴런의 출력 $y_{(t)}$는 다음 식으로 계산될 수 있습니다.

$∅$는 Relu와 같은 활성화 함수입니다. 보통 RNN에서는 Relu보단 tanh 함수를 선호합니다.

여기에 더 나아가서 이번엔 입력이 벡터 단위가 아니라, 미니 배치로써 여러 벡터가 들어온다고 하면 이를 행렬 $X_{(t)}$로 만들어 출력을 한번에 계산할 수 있습니다.

$Y_{(t)}$는 $X_{(t)}$와 $Y_{(t-1)}$을 입력으로 받는 함수이고, $Y_{(t-1)}$는 $X_{(t-1)}$와 $Y_{(t-2)}$을 입력으로 받고, 다시 $Y_{(t-2)}$는 $X_{(t-2)}$와 $Y_{(t-3)}$을 입력으로 받게됩니다. 여기서 알 수 있는 점은 $Y_{(t)}$는 맨 처음 $t=0$에서부터 모든 입력을 받은 뉴런의 출력값이라는 점입니다.

Memory Cell

타임 스텝 $t$에서 뉴런의 출력은 이전 타임 스텝의 모든 입력에 대한 함수이므로 이를 일종의 메모리 형태라고 할 수 있습니다. 그래서 타임 스텝에 걸쳐 형성된 어떤 상태를 보존하는 RNN의 구성 요소를 메모리 셀 간단하게 셀이라고 부릅니다. -

하나의 순환 뉴런 Layer는 일반적으로 10 타임 스텝 내외를 학습할 수 있는 기본적인 셀이지만, 뒤에서 더욱 긴 패턴을 학습할 수 있는 강력한 셀에 대해 공부하게 됩니다.

일반적으로 타임 스텝 $t$에서의 셀의 상태 $h_{(t)}$는 $t$에서의 Input과 이전 타임 스텝의 셀 $h_{(t-1)}$에 대한 함수입니다. 타임 스텝 $t$에서의 출력 $y_{(t)}$도 이전 $h$와 현재 Input에 대한 함수이므로, 기본적인 셀의 경우 출력 $y_{(t)}$와 $h_{(t)}$는 같다고 할 수 있습니다. 하지만 모든 종류의 셀에서 그런 것은 아닙니다.

Input Sequence and Output Sequence

RNN에는 다양한 네트워크 구조가 있습니다. 크게 <(입력)-투-(출력) 네트워크>에서 입출력의 형태가 시퀀스냐, 벡터냐에 따라 구조의 이름이 결정됩니다. 시퀀스와 벡터를 나누는 기준은 간단합니다. 벡터가 여러개가 들어가거나 여러개가 나가면 시퀀스, 하나의 벡터만 들어가거나 나오면 벡터입니다.

- 시퀀스-투-시퀀스 네트워크(좌측 상단) ex) 주식가격 같은 시계열 데이터를 예측하는데 유용합니다. 최근 $0~N$ 일치의 주식 가격을 주입하면 네트워크는 하루 앞선 가격 즉 $1~N+1$일치 주식 가격을 출력해야 합니다.

- 시퀀스-투-벡터 네트워크(우측 상단) : 마지막 출력($Y_{(3)}$)을 제외한 나머지 출력을 모두 무시하는 네트워크 입니다. ex) 한 문장의 영화 리뷰가 있다고 할때, 문장을 구성하는 단어를 하나의 입력 벡터라고 생각할 수 있습니다. 이때 이 리뷰의 평점을 계산한다 할때, 각 단어(입력 벡터)가 들어갈 때마다 평점이 계산되어 나오는 것이 아니라, 모든 단어(시퀀스)가 들어간 후에 최종적인 한번의 평점(벡터)이 출력되는 것입니다.

- 벡터-투-시퀀스 네트워크 ex) 하나의 이미지(입력 벡터)를 넣어주면 이미지에 대한 설명문(문장은 단어로 구성된 시퀀스이다)으로 출력할 수 있습니다.

- (우측 하단) : 마지막은 인코더라 부르는 시퀀스-투-벡터 네트워크 뒤에 디코더라 부르는 벡터-투-시퀀스 네트워크를 연결한 구조입니다. ex) 한국말을 영어로 번역하는데 사용될 수 있습니다. 즉 한국어 문장으 주입하면 인코더는 이를 하나의 벡터 표현으로 변환하고 디코더가 이 벡터를 영어 문장으로 디코딩합니다.

이러한 인코더-디코더 모델은 시퀀스-투-시퀀스 RNN을 사용하여 한 단어씩 번역하는 것보다 훨씬 더 잘 작동합니다. 왜냐하면 RNN의 경우엔 문장의 마지막 단어가 번역의 첫번째 단어에 영향을 줄 수 있기 때문입니다. 따라서 하나의 단어가 들어올때 마다 번역해서 단어를 뽑아내는 것(RNN의 방식)이 아닌 전체 문장이 주입될 때까지 기다렸다 번역해야 더 좋은 성능을 낼 수 있습니다.(인코더-디코더 모델)

RNN 훈련하기

RNN 훈련 방식으로 타임 스텝으로 네트워크를 펼치고, 보통의 역전파(Back Propagation)을 사용하는 것인데 이를 BPTT(Backpropagation through time)이라고 합니다. 본격적으로 훈련 방식을 차례대로 살펴보겠습니다.

위 그림을 살펴보면서 이해해보겠습니다. 우선 회색 점선 화살표 방향으로 네트워크를 통과하면서 비용 함수 $C(Y_{(0)}, Y_{(1)} ... Y_{(T)})$(T는 최대 타임 스텝)을 사용하여 출력 시퀀스를 평가됩니다. 이때 비용 함수는 Y_{(0)}, Y_{(1)}과 같은 일부 출력을 무시할 수 있습니다.

그 다음 비용함수의 Gradient는 짙은 회색선의 방향으로 전파되면서 모델 파라미터는 업데이트 됩니다. 이때 Gradient는 마지막 출력 $Y_{(4)}$에만 전달되어 노란색 박스 간의 수평방향으로 전달되는 것이 아니라, 비용 함수에 사용된 Y_{(2)}, Y_{(3)}, Y_{(4)}에 모두 각각 전달됩니다. 또한 각 타임 스텝마다 같은 매개변수 $W$와 $b$가 사용되기 때문에 역전파가 진행되면 모든 타임 스텝에 걸쳐 합산될 것입니다.

Time-Series Forecasting

어떤 웹사이트에서 1) 시간당 접속 사용자의 수, 2) 도시의 날짜별 온도, 3) 여러 feature를 사용하여 기업의 분기별 재정 안정성 등을 연구한다고 가정해보겠습니다. 이 경우 들어오는 Input Data는 타임 스텝마다 하나 이상의 값을 가지는 시퀀스이며 이를 Time-Series Data라고 부릅니다.

[1) 시간당 접속 사용자의 수, 2) 도시의 날짜별 온도]는 타임 스텝마다 하나의 feature를 가지므로 단변량 시계열 (univariate time series)이고, 3)기업의 분기별 재정 안정성은 회사의 수입, 부채 등의 여러 feature를 이용하므로 다변량 시계열(multiivariate time series)입니다.

이런 Time-Series Data를 가지고 할 수 있는 몇가지 Task가 있는데 첫번째가 미래 예측(Forecasting)입니다. 또 하나는 기존 데이터에서 비어 있는 값을 채우는 Imputation입니다.

다음은 앞서 예시로 든 데이터와 별개의 3개의 단변량 시계열입니다. 각 타임 스텝은 50개이며, 목표는 51번째 타임 스텝의 값을 예측 하는 것입니다.

다음 코드에서 간단하게 $sin$ 곡선과 약간의 잡음으로 이뤄진 시계열 데이터를 생성해보겠습니다.

def generate_time_series(batch_size, n_steps):
    freq1, freq2, offsets1, offsets2 = np.random.rand(4, batch_size, 1)
    time = np.linspace(0, 1, n_steps)
    series = 0.5 * np.sin((time - offsets1) * (freq1 * 10 + 10))  #   wave 1
    series += 0.2 * np.sin((time - offsets2) * (freq2 * 20 + 20)) # + wave 2
    series += 0.1 * (np.random.rand(batch_size, n_steps) - 0.5)   # + noise
    return series[..., np.newaxis].astype(np.float32)

이 함수는 n_steps 길이의 시계열을 batch_size만큼 만들어냅니다. 각 시계열의 타임 스텝에는 하나의 값이 존재 즉 단변량이며 [배치 크기, 타임 스텝 수, 1]크기의 넘파이 배열을 반환합니다. 이러한 리턴 타입은 일반적으로 임의 길이의 time-series 데이터를 다룰 때 사용하며, 단변량은 dimensionallity가 1이고, 다변량은 1이상입니다.

이제 이 함수를 사용해 데이터를 train, validation, test set으로 나누겠습니다.

np.random.seed(42)

n_steps = 50
series = generate_time_series(10000, n_steps + 1)
X_train, y_train = series[:7000, :n_steps], series[:7000, -1]
X_valid, y_valid = series[7000:9000, :n_steps], series[7000:9000, -1]
X_test, y_test = series[9000:, :n_steps], series[9000:, -1]

기준 성능

본격적으로 RNN을 구현하기 전, 우리가 구현할 RNN이 잘 작동하는지 판단하기 위해서는 기준이 되는 무언가가 필요합니다. 가장 간단한건 각 시계열의 마지막 값을 그대로 예측하는 것입니다. 이를 naive forecasting이라고 부르는데 이 성능을 뛰어넘는 것이 매우 어렵스빈다. 이 경우 MSE가 0.020이 나오네요

y_pred = X_valid[:, -1]
np.mean(keras.losses.mean_squared_error(y_valid, y_pred))

>> 0.020211367

또 다른 방법은 Fully Connected Network를 사용하는 것입니다. 이 네트워크는 입력마다 1차원 feature 배열을 기대하므로 Flatten Layer를 추가해줘야 합니다.

model = keras.models.Sequential([
    keras.layers.Flatten(input_shape=[50, 1]),
    keras.layers.Dense(1)
])

model.compile(loss="mse", optimizer="adam")
history = model.fit(X_train, y_train, epochs=20,
                    validation_data=(X_valid, y_valid))
                    
model.evaluate(X_valid, y_valid)

>>0.004168086685240269

0.004의 MSE의 값을 얻었는데 naive한 forecasting보다 훨씬 낫습니다.

간단한 RNN 구현하기

이제 간단한 RNN을 사용해 방금 구현한 네트워크들을 앞설 수 있는지 확인해보겠습니다.

model = keras.models.Sequential([
    keras.layers.SimpleRNN(1, input_shape=[None, 1])
])

optimizer = keras.optimizers.Adam(lr=0.005)
model.compile(loss="mse", optimizer=optimizer)
history = model.fit(X_train, y_train, epochs=20,
                    validation_data=(X_valid, y_valid))

위 코드가 가장 간단하게 만들 수 있는 RNN으로 하나의 뉴런을 가지는 하나의 layer로 이루어져 있습니다. 코드에서 input_shape에 None이 들어있는 이유는 RNN은 어떤 길이의 타임 스텝도 처리할 수 있기 때문에 길이를 지정해 줄 필요가 없습니다.

기본적으로 SimepleRNN Layers는 tanh를 activation function으로 사용합니다. 작동방식은 앞서 이론에서 살펴보았던 것과 완전히 동일합니다.

model.evaluate(X_valid, y_valid)
>> 0.010881561785936356

우리가 구현한 RNN을 통해 얻은 0.014의 MSE는 naive forecasting보단 낫지만, 간단한 FC Layer 기반 선형 모델을 앞지르지 못합니다. 이는 선형 모델에서는 전체 타임스텝이 50개라 했을 때, 50개의 뉴런이 준비되어 각 입력을 받고 하나의 입력마다 하나의 파라미터를 가지고 편향까지 존재합니다. 최종적으로 51개의 파라미터가 있는 셈이죠.

반면 기본 RNN의 순환 뉴런은 Input과 셀 h의 차원마다 하나의 파라미터를 가지고 편향이 있습니다. 그러니 3개의 파라미터가 있는 셈인데, 선형 모델보다 파라미터 갯수가 월등히 적기 때문에 성능도 그만큼 덜 나오는 것입니다.

트렌드와 계절성

가중 이동 평균(weighted moving average)이나 자동 회귀 누적 이동 평균(ARIMA)같이 Time-Series Data를 forecasting하는 방법은 많습니다. 그런데 올바른 forecasting을 위해서 일부는 트렌드(Trend)나 계절성(Seasonality)를 제거해야 합니다. 트렌드라 하면 전체적인 데이터가 상승하거나 내려가거나 하는 추세를 의미합니다. 예를 들어 매달 10% 성장하는 추세의 웹사이트의 접속 사용자 수를 조사한다면, 시계열에서 트렌드를 삭제하고 예측한 후 최종 결과에 다시 이 트렌드를 더해야합니다.

비슷하게 매달 선크림 판매량 예측 시 여름에 특히 더 잘 팔리는 계절성을 관찰할 수 있습니다. 따라서 마찬가지로 최종 예측 후 이러한 계절성을 더해줘야합니다.

하지만 RNN을 사용하면 이런 작업이 필요 없습니다. 그만큼 RNN은 좋은 성능을 내기에 단순합니다. 더 많은 Layer를 추가하면 됩니다!

심층 RNN

RNN은 셀을 여러 층으로 쌓는 것이 일반적입니다. 이렇게 만든 것을 심층 RNN (Deep RNN)이라 부릅니다.

구현은 그저 SimpleRNN을 쌓아주면 됩니다.

model = keras.models.Sequential([
    keras.layers.SimpleRNN(20, return_sequences=True, input_shape=[None, 1]),
    keras.layers.SimpleRNN(20, return_sequences=True),
    keras.layers.SimpleRNN(1)
])

이 모델의 MSE는 0.003으로 드디어 선형 모델을 이기게 되었습니다! 그러나 마지막 층을 좀 더 손볼 필요가 있어 보입니다. 단변량 시계열을 예측한다는 건 하나의 유닛이 필요하고 이는 타임 스텝마다 하나의 출력을 만들어야 한다는 뜻입니다. 하나의 유닛을 가진다는 건 h가 스칼라 값이라는 것입니다.

그런데 마지막 Layer의 h는 그리 필요하지 않습니다. 게다가 SimpleRNN Layer는 tanh 함수를 사용하여 forecasting 값이 -1과 1 사이의 범위에 놓입니다. 따라서 보통은 이런 이유로 출력층을 Dense 층으로 바꾸는데, 이를 통해 빠르면서 정확도는 거의 비슷합니다. 다만 이렇게 바꾸려면 두 번째 순환 층에 return_sequences=True를 제거해줘야합니다.

model = keras.models.Sequential([
    keras.layers.SimpleRNN(20, return_sequences=True, input_shape=[None, 1]),
    keras.layers.SimpleRNN(20),
    keras.layers.Dense(10)
])

여러 타임 스텝 앞을 예측하기

지금까지는 다음 타임 스텝의 값만 예측했지만, 1스텝 앞이 아니라, 10스텝 앞의 값으로 타깃을 바꾸어 10 스텝 앞을 예측하는 것도 그리 어려운 일이 아닙니다. 하지만 1개의 값이 아니라 한번에 10개를 예측하고 싶다면 어떻게 해야할까요?

첫 번째 방법은 pre-trained model을 사용하여 다음 스텝의 값을 예측한 후 이 값을 다시 입력으로 추가해나가며 10개를 예측하는 것입니다. 코드는 다음과 같습니다.

series = generate_time_series(1, n_steps + 10)
X_new, Y_new = series[:, :n_steps], series[:, n_steps:]
X = X_new
for step_ahead in range(10):
    y_pred_one = model.predict(X[:, step_ahead:])[:, np.newaxis, :]
    X = np.concatenate([X, y_pred_one], axis=1)

Y_pred = X[:, n_steps:]

당연하지만 다음 스텝에 대한 예측이 훨씬 더 미래의 예측보다 정확합니다. 훨씬 더 미래의 예측은 오차가 누적될 수 있기 때문입니다. 어쨌든 위 방식을 적용하면 약 0.029의 MSE를 얻습니다. 성능은 비슷할지라도 task가 훨씬 어렵기 때문에 단순 비교는 어렵습니다.

두 번째 방법은 RNN을 훈련하여 다음 값 10개를 한번에 예측하는 것입니다. 시퀀스-투-벡터 모델을 사용하지만, 1개가 아닌 값 10개를 출력합니다.

series = generate_time_series(10000, n_steps + 10)
X_train, Y_train = series[:7000, :n_steps], series[:7000, -10:, 0]
X_valid, Y_valid = series[7000:9000, :n_steps], series[7000:9000, -10:, 0]
X_test, Y_test = series[9000:, :n_steps], series[9000:, -10:, 0]

model = keras.models.Sequential([
    keras.layers.SimpleRNN(20, return_sequences=True, input_shape=[None, 1]),
    keras.layers.SimpleRNN(20),
    keras.layers.Dense(10)
])

이 모델의 다음 10개 스텝에 대한 MSE는 약 0.008로 선형 모델보다 훨씬 좋습니다. 다만 개선할 여지가 있는데, 마지막 타임스텝에서만 10개를 예측하도록 훈련하는게 아니라, 모든 타임 스텝에서 다음 10개를 예측하도록 모델을 훈련할 수 있습니다. 즉 시퀀스-투-벡터에서 시퀀스-투-시퀀스로 바꿀 수 있는 것입니다.(타임 스텝 0에서는 타임 스텝 1~10까지 예측을 담은 벡터를, 타임 스텝 1에서는 2~11까지의 예측을 담는 벡터를 출력합니다.)

이것의 장점은 모든 타임 스텝에서 forecasting을 진행하며 이것들에 대한 출력이 loss에 포함되면서 더 많은 오차 그레디언트가 모델로 흐르게 되고 결과적으로 안정적인 훈련과 함께 훈련 속도를 높이게 됩니다. 다음은 구현 코드입니다.

model = keras.models.Sequential([
    keras.layers.SimpleRNN(20, return_sequences=True, input_shape=[None, 1]),
    keras.layers.SimpleRNN(20, return_sequences=True),
    keras.layers.TimeDistributed(keras.layers.Dense(10))
])

시퀀스-투-시퀀스 모델로 바꾸려면 우선 모든 SimpleRNN 층의 return_sequences=True로 지정합니다. 그 다음 모든 타임 스텝 층에 Dense 층을 적용해야하는데 이를 위해 바로 TimeDistributed Layer를 사용합니다.

TimeDistributed Layer는 각 타임 스텝을 별개의 샘플처럼 다루도록 입력의 크기를 바꿉니다. ([배치 크기, 타임 스텝 수, 입력 차원] -> [배치 크기 x 타임 스텝 수, 입력 차원]) 그 다음 Dense Layer에 적용하고 마지막으로 출력 크기를 시퀀스로 되돌립니다. ([배치 크기 x 타임 스텝 수, 입력 차원] -> [배치 크기, 타임 스텝 수, 입력 차원])

def last_time_step_mse(Y_true, Y_pred):
    return keras.metrics.mean_squared_error(Y_true[:, -1], Y_pred[:, -1])

model.compile(loss="mse", optimizer=keras.optimizers.Adam(lr=0.01), metrics=[last_time_step_mse])
history = model.fit(X_train, Y_train, epochs=20,
                    validation_data=(X_valid, Y_valid))

검증 MSE로 0.006을 얻었는데, 이는 이전 모델보다 25%나 향상된 것입니다.

다음 시간에는 좀 더 긴 시퀀스의 예측 시 사용하는 LSTM과 경량화된 모델인 GRU에 대해 공부해보겠습니다. 오늘도 읽어주셔서 감사합니다. 행복한 하루 보내시길 바랍니다 :)

[ 머신러닝 순한맛 ] Regularization in 딥러닝의 모든 것

Box형 — Mon, 5 Jul 2021 03:04:33 +0900

"나는 네 개의 파라미터가 있으면 코끼리 모양을 학습시킬 수 있고,

다섯 개가 있으면 코를 꿈틀거리게 할 수 있다."

- 존 폰 노이만 -

Neural Network는 수만 개에서 수백만 개까지 파라미터를 가집니다. 그만큼 크고 복잡한 데이터셋을 학습할 수 있을만큼 네트워크의 자유도가 높다는 것을 의미합니다.

그러나 이러한 자유도가 높을 수록 네트워크는 Training set에 과대적합(Overfitting)되기 쉬워집니다. 이번 포스팅에서는 Neural Network에서 Overfitting을 막기 위해 사용하는 다양한 규제(Regularization) 방법들에 대해 알아보겠습니다.

이번 포스팅은 다음 포스팅을 읽은 후 공부하시면 더욱 효과적입니다.

[AI/Coursera ( Machine Learning )] - [ 핸즈온 머신러닝 2판 ] Linear Regression 속 Regularization이란?

[ 핸즈온 머신러닝 2판 ] Linear Regression 속 Regularization이란?

"이끌거나, 따르거나, 비켜서라." - Ted Turner (CNN 설립자) - 4.5 선형 모델(Linear Model)에서의 규제(Regularization) Regularization은 모델이 Overfit되었을 때, 이를 감소시키는 대표적인 방법입니다...

box-world.tistory.com

L1, L2 규제

우리가 이전에 Linear Regression을 공부한다면, 자연스럽게 Overfitting을 막기 위해 별도의 규제 항을 추가하였던 것을 기억할 것입니다.

Neural Network에서도 가중치를 제한하기 위해 L2 규제를 사용하거나, Sparse한(많은 가중치가 0인) 모델을 만들기 위해 L1 규제를 사용할 수 있습니다.

다음은 규제 강도를 0.01을 사용하여 L2 규제를 적용하는 방법을 보여줍니다.

layer = keras.layers.Dense(100, activation="elu",
                           kernel_initializer="he_normal",
                           kernel_regularizer=keras.regularizers.l2(0.01))

L2() 함수는 각 스텝마다 규제 Loss가 들어있는 객체를 반환하고, 이것은 최종 Loss에 반영됩니다. L1 규제를 사용하고 싶다면 keras.regularizaers.l1()을 사용하면 되고, L1, L2 두가지가 모두 필요하면 keras.regularizers.l1_l2()를 사용하면 됩니다.

일반적으로 네트워크를 구성하는 Hidden Layer들에는 동일한 activation 함수, Initialization 전략을 사용하거나, 동일한 규제를 적용하여 동일한 파라미터 값을 반복하는 경우가 많습니다.

model = keras.models.Sequential([
    keras.layers.Flatten(input_shape=[28, 28]),
    keras.layers.Dense(300, activation="elu",
                       kernel_initializer="he_normal",
                       kernel_regularizer=keras.regularizers.l2(0.01)),
    keras.layers.Dense(100, activation="elu",
                       kernel_initializer="he_normal",
                       kernel_regularizer=keras.regularizers.l2(0.01)),
    keras.layers.Dense(10, activation="softmax",
                       kernel_regularizer=keras.regularizers.l2(0.01))
])

위 코드는 보다시피 매 Layer마다 반복되는 파라미터가 존재합니다. 이 경우 매번 입력하는 대신 파이썬의 functools.partial() 함수를 사용하여 동일하게 사용하는 기본적인 매개변수 값을 사용하게 할 수 있습니다.

RegularizedDense = partial(keras.layers.Dense,
                           activation="elu",
                           kernel_initializer="he_normal",
                           kernel_regularizer=keras.regularizers.l2(0.01))

model = keras.models.Sequential([
    keras.layers.Flatten(input_shape=[28, 28]),
    RegularizedDense(300),
    RegularizedDense(100),
    RegularizedDense(10, activation="softmax")
])

Dropout

드롭아웃은 Neural Network에서 가장 인기 있는 규제 기법중 하나입니다. 최고 성능을 내는 네트워크도 드롭아웃 적용 후 정확도를 1~2% 높였습니다. 이러한 1~2%의 상승은 오차율이 거의 40% 줄어드는 것을 의미합니다.

드롭아웃의 알고리즘은 간단합니다. 매 Training 스텝에서 네트워크를 구성하는 각 뉴런은 임시적으로 드롭아웃될 확률 $p$를 가집니다.(입력 뉴런은 포함되고, 출력 뉴런은 제외됩니다.) 다시 말해서 드롭아웃된 뉴런은 완전히 없는 셈치고 학습을 진행하는 것입니다.

다만 무시됐던 뉴런은 다음 훈련 스텝에서는 드롭아웃 확률에 따라 다시 활성화될 수 있습니다. 드롭아웃 확률 $p$는 하이퍼파라미터로 보통 10~30% 사이를 지정합니다.

훈련이 끝난 후, Test set에서는 드롭아웃을 적용하지 않습니다. 그렇다면 이러한 드롭아웃이 성능을 높이는 이유는 무엇일까요?

매 훈련 스텝마다 일정 드롭아웃 확률 $p$에 따라 각 뉴런들은 비활성화되거나 활성화됩니다. 다시 말해 매 훈련 스텝마다 네트워크의 모양은 다릅니다. 그러니까 우린 매 훈련 스텝마다 서로 다른 Neural Network를 사용한 셈이 되는 것입니다.

그래서 예를들어 10000번의 훈련 스텝을 진행했다면 10000개의 서로 다른 Neural Network를 앙상블해서 훈련시킨 효과를 가지게 되는 것입니다.

다만 한가지 사소하지만 유의해야할 사항이 있습니다. $p=50%$로 하면 Test시 하나의 뉴런은 훈련 때보다 평균적으로 두배 더 많은 입력 뉴런과 연결됩니다. 이런 점을 보상하기 위해 훈련 후 각 뉴런의 연결 가중치에 0.5를 곱하여 늘어난 입력 뉴런을 상쇄시켜야합니다.

다시 말해 훈련이 끝나면 각 입력의 연결 가중치에 보존 확률$(1-p)$을 곱해줘야합니다.

케라스의 keras.layers.Dropout은 훈련 동안 일부 Input을 랜덤하게 버립니다. 그리고 남은 입력을 보존 확률로 나눕니다. 우리가 착각하면 안될 것이 dropout이라든지, 보존 확률로 입력을 나눈다든지 이런 프로세싱은 훈련 단계에서 일어나는 일이지 Test 단계에서는 그냥 입력을 다음 층으로 전달합니다.

다음은 드롭아웃 비율 0.2를 사용하여 구성한 model입니다.

model = keras.models.Sequential([
    keras.layers.Flatten(input_shape=[28, 28]),
    keras.layers.Dropout(rate=0.2),
    keras.layers.Dense(300, activation="elu", kernel_initializer="he_normal"),
    keras.layers.Dropout(rate=0.2),
    keras.layers.Dense(100, activation="elu", kernel_initializer="he_normal"),
    keras.layers.Dropout(rate=0.2),
    keras.layers.Dense(10, activation="softmax")
])

Max-Norm 규제

마지막으로 우리가 살펴볼 규제는 Max-Norm 규제입니다. 이 방식은 각 뉴런에 대해 입력의 연결 가중치 $w$가 다음과 같도록 제한합니다.

Max-Norm 규제는 전체 Loss 함수에 규제 항을 추가하지 않습니다. 대신 매 훈련 스텝이 끝날때마다 $w$의 norm을 계산하여 다음고 같이 스케일을 조정합니다.

$r$은 하이퍼 파라미터이며, r을 줄이면 줄일 수록 w에 더 작은 값이 곱해지니 가중치가 작아질 것이고 그렇게 되면 Overfitting을 감소시키는데 도움이 될 것입니다.

다음은 keras에서 구현한 코드입니다.

layer = keras.layers.Dense(100, activation="selu", kernel_initializer="lecun_normal",
                           kernel_constraint=keras.constraints.max_norm(1.))

다음 포스팅에서는 텐서플로우에 대해 다뤄보겠습니다. 오늘도 읽어주셔서 감사합니다. 행복한 하루 보내세요 :)

[머신러닝 순한맛] 학습률 스케줄링의 모든 것

Box형 — Sat, 3 Jul 2021 22:37:04 +0900

"경쟁자의 성공을 탐하지 마라"

- 제럴딘 레이본느 (옥시전 미디어 회장 겸 ceo) -

저번 포스팅에서 우리는 가중치 파라미터의 최적화를 속도, 그리고 리소스 효율성의 측면에서 바라보았습니다. 이번 포스팅에서는 최적화의 속도에 관여하는 또 하나의 하이퍼파라미터인 학습률(Learning Rate) 스케줄링을 통해 파라미터 최적화의 성능을 방법에 대해서 알아보겠습니다.

학습률 스케줄링

가중치를 최적화하는데 있어서 '좋은 학습률'을 찾는 것은 중요한데 이유는 다음과 같습니다. 우리가 가장 Loss가 적은 Local minimum까지 걸어간다고 할때, 학습률은 걸음의 보폭이라고 할 수 있습니다. 학습률이 너무 크면 Local minimum을 지나치거나 수렴하기 어렵습니다. 반대로 너무 작아도 Local minimum까지 도달할 순 있어도 그 시간이 매우 오래 걸릴 것입니다.

이제 학습률의 중요성을 알았으니 본격적으로 다양한 학습률 스케줄링 방식에 대해 하나하나 살펴보겠습니다.

1) 거듭제곱 기반 스케줄링(Power Scheduling)

- $t$ : Training epoch(반복 횟수)

- $n_0$ : 초기 학습률

- $c$ : 상수

- $s$ : 스텝 횟수 (우리가 지정해야하는 하이퍼 파라미터로써 스텝은 우리가 지정한 데이터의 크기만큼을 한번 훑으면 1번의 스텝으로 여기므로 전체 데이터셋을 한번 훑었을때 1번으로 여기는 epoch와는 다른 개념입니다.)

위 수식을 쉽게 해석해보면 $s$, $c$, $n_0$은 고정된 값이고, $t$는 학습이 진행될 수록 늘어나는 값이다. 그런데 이 늘어나는 $t$가 늘어날수록 분모가 늘어나면서 $n(t)$는 감소하게 됩니다. 즉 학습이 진행될수록 학습률은 감소하게됩니다.

처음엔 Local Minimum이 멀리있을테니 긴 보폭으로 다가가다가 거의 다왔을때는 보폭을 줄여 Local minimum에게 세심하게 가까이 가려는 건 당연한 순리겠죠.

다만 초기 학습률 $n_0$과 $s$는 우리가 지정해줘야하는 하이퍼 파라미터에 속합니다.

2) 지수 기반 스케줄링 (Exponential Scheduling)

- $t$ : Training epoch(반복 횟수)

- $s$ : 스텝 횟수

$t=s$일땐 $(0.1)^1$, $t=2s$일땐 $(0.1)^2$ 이런 식으로 t가 늘어날 때마다 학습률이 감소되는 스케줄링 방식입니다. 다만 1)과 달리 s번의 스텝마다 고정적으로 10배씩 감소한다는 점에서 차이를 두고 있습니다.

3) 구간별 고정 스케줄링 (Piecewise Constant Scheduling)

일정 횟수의 에포크 동안 일정한 학습률을 사용하고, 그 다음 또 다른 횟수의 에포크 동안은 더 작은 학습률을 사용하는 식입니다. 예를 들어 초기 5 에포크 동안에 $n_0= 0.1$, 그 다음 50에포크 동안에 $n_0=0.001$ 이런식으로 우리가 직접 지정하여 스케줄링하는 방식입니다. 다만 성능을 높이기 위한 최적의 조합은 우리가 직접 찾아야합니다.

4) 성능 기반 스케줄링 (Perfomance Scheduling)

매 $N$번의 스텝마다 Validation Loss를 측정하고, 이것이 줄어들지 않으면 $i$배만큼 학습률을 감소시킵니다.

5) 1 사이클 스케줄링 (1cycle Scheduling)

이 방식은 다른 방식과 조금 다른 방식을 지닙니다. 1 사이클은 훈련 절반 동안 초기에 지정한 학습률 $n_0$을 선형적으로 $n_1$까지 증가시킵니다. 그 다음 나머지 절반 동안은 증가되었던 $n_1$을 $n_0$으로 선형적으로 되돌립니다. 그리고 마지막 몇 번의 에포크 동안의 학습률은 소수점 몇 째자리까지 선형적으로 줄입니다.

최대 학습률 $n_1$은 우리가 직접 지정해야하며, 초기 학습률 $n_0$은 보통 10배 정도 낮은 값을 선택합니다. 모멘텀 사용시(모멘텀은 마찰을 의미합니다. 모멘텀이 높을 수록 마찰이 심해질수록, 높은 학습률을 가지더라도 앞으로 멀리가기 힘들어진다고 이해하면 됩니다.), 처음에는 높은 모멘텀으로 시작하여 학습률을 제어시켰다가 최대 학습률에 되는 절반 지점까지 점점 모멘텀을 줄입니다. 그리고 나머지 절반동안 학습률이 다시 초기 학습률 $n_0$로 돌아가는 동안 점진적으로 모멘텀을 높입니다.

이 방식은 여러 연구를 통해 충분히 검증된 훌륭한 방식입니다.

2013년도 논문에 따르면 모멘텀 최적화를 사용한 음성 인식용 Neural Network를 훈련할 때 가장 널리 알려진 학습률 스케줄링의 성능을 비교했습니다. 저자들은 성능 기반 스케줄링과 지수 기반 스케줄링이 둘다 잘 작동했지만, 튜닝이 쉽고 Local minimum에 조금 더 빨리 수렴하는 지수 기반 스케줄링이 선호된다고 결론을 내었습니다.

다음은 거듭제곱 기반 스케줄링을 keras에서 구현한 것입니다. 여기서 decay는 우리가 앞서 보았던 스텝 수 $s$의 역수입니다. (keras는 이를 1로 가정합니다.)

optimizer = keras.optimizers.SGD(lr=0.01, decay=le-4)

다음은 지수 기반 스케줄링입니다.

def exponential_decay_fn(epoch):
	return 0.01 * 0.1**(epoch / 20)

하지만 위와 같이 하면 $n_0$와 $s$가 바뀔때마다 새로 함수를 정의해야하므로, 이 둘을 매개변수로 추가하여 LearningRateScheduler 콜백을 만들어보겠습니다.

def exponential_decay(lr0, s):
	def exponential_decay_fn(epoch):
    	return lr0 * 0.1 ** (epoch / s)
    return exponential_decay_fn
exponential_decay_fn = exponential_decay(lr0=0.01, s=20)

lr_scheduler = keras.callbacks.LearningRateScheduler(exponential_decay_fn)
history = model.fit(X_train_scaled, y_train, [...], callbacks=[lr_scheduler])

구간별 고정 스케줄링 방식도 별도의 함수를 LearningRateScheduler 콜백을 만들어 fit() 메서드에 전달합니다. 다음은 다섯 번의 에포크 동안 향상되지 않을때마다 학습률에 0.5를 곱합니다.

def piecewise_constant_fn(epoch):
    if epoch < 5:
        return 0.01
    elif epoch < 15:
        return 0.005
    else:
        return 0.001
        
lr_scheduler = keras.callbacks.LearningRateScheduler(piecewise_constant_fn)

마지막으로 tf.keras에서는 keras.optimizers.schedules에 있는 스케줄 중에 하나를 사용해 학습률을 정의하고 이것을 옵티마이저에 전달하는데 이렇게 하면 에포크가 아니라 매 스텝마다 학습률을 업데이트합니다. 다음은 이를 이용해 지수 기반 스케줄링을 구현하는 방법입니다.

s = 20 * len(X_train) // 32 # number of steps in 20 epochs (batch size = 32)
learning_rate = keras.optimizers.schedules.ExponentialDecay(0.01, s, 0.1)
optimizer = keras.optimizers.SGD(learning_rate)

다음 포스팅에서는 Regularization을 이용해 Overfitting을 피하는 방법에 대해 알아보겠습니다. 오늘도 읽어주셔서 감사합니다. 행복한 하루 보내세요 :)

[ 머신러닝 순한 맛 ] Adam, RMSProp, AdaGrad, 모멘텀 최적화, NAG의 모든 것

Box형 — Mon, 21 Jun 2021 11:25:13 +0900

시련은 있어도, 실패란 없다

- 정주영 ( 현대 그룹 창업자 )

지금까지 우리는 모델을 훈련할 때, 표준적인 경사하강법(Gradient Descent Algorithm)만 써왔습니다. 하지만 이러한 훈련과정의 속도를 높이는 방법에 대해 초기화 / activation function / Batch-Normalization / 전이 학습 4가지를 공부했습니다.

이번 포스팅에서 공부할 것은 훈련 속도를 높이기 위해 경사 하강법 대신에 쓸 수 잇는 고속 옵티마이저에 대해서 공부해보겠습니다.

다음 포스팅을 먼저 정독하시고 이번 포스팅을 보시면 더욱 쉽게 이해하실 수 있습니다 :)

[AI/Hands-On Machine Learning 2판] - [머신러닝 순한맛] 그레디언트 소실(Vanishing) / 폭주(Exploding)이란?

[머신러닝 순한맛] 그레디언트 소실(Vanishing) / 폭주(Exploding)이란?

잘못된 전략이라도 제대로 실행만 하면 반드시 성공할 수 있다. 반대로 뛰어난 전략이라도 제대로 실행하지 못하면 반드시 실패한다. - 선 마이크로시스템즈 CEO, 스콧 맥닐리 - Deep Neural Network,

box-world.tistory.com

모멘텀 최적화(Momentum Optimization)

우리가 기존에 배웠던 경사 하강법은 경사면을 따라 일정한 크기의 스텝으로 조금씩 내려갑니다. 반대로 모멘텀 최적화는 경사를 굴러가는 볼링공과 같습니다. 즉 처음에는 느리게 출발하지만, 시간이 지날수록 빠르게 가속되어 결과적으로 더 빠릅니다.

경사 하강법은 다음과 같이 loss 그레디언트 * 학습률을 기존 가중치에 뺌으로써 갱신이 이뤄집니다. 이러한 방식이 이전 그레디언트가 얼마였는지 고려하지 않습니다. 그렇기 때문에 부분적으로 그레디언트가 작으면 매우 느려집니다.

모멘텀 최적화는 경사 하강법과 반대로 이전 그레디언트가 얼마였는지가 중요합니다. 여기서는 매 반복에서 그레디언트 * 학습률를 구하여 이를 모멘텀 벡터 $m$에 더한 값을 빼서 가중치를 갱신하게 됩니다. 쉽게 생각해서 이 모멘텀 벡터에 이전 그레디언트에 대한 정보가 담겨있다고 생각하면 됩니다.

그런데 여기서 볼링공이 너무 빠르게 내려가지 않도록 일종의 마찰 저항을 주기 위해 새로운 하이퍼 파라미터 $β$가 등장합니다. 이 값이 커질수록 마찰 저항이 없어지는데 보통은 $0.9$로 설정합니다. 이렇게 설정하면 경사 하강법보다 10배 정도 빠르게 최적화를 진행할 수 있습니다.

어떤 입력 데이터의 스케일이 다르면, 비용 함수는 길쭉한 타원형의 모양을 가지게 됩니다. 경사 하강법은 이러한 경우에 매우 느립니다. 그러나 모멘텀 최적화는 굉장히 빠르게 minimum loss에 도달할 수 있습니다.

이러한 모멘텀 최적화는 Batch-Normalization을 사용하지 않아서 스케일이 다른 입력이 들어오는 Neural Network에 적용하면 좋습니다. 다음은 Keras에서 모멘텀 최적화를 구현하는 코드입니다.

optimizer = keras.optimizers.SGD(lr=0.001, momentum=0.9)

네스테로프 가속 경사

NAG라 부르는 네스테로프 가속 경사는 모멘텀 최적화의 변종으로 기존보다 거의 항상 빠릅니다. 기존에는 현재 위치에서 그레디언트를 계산했었다면, 모멘텀의 방향으로 즉 볼링공이 흘러가는 방향으로 조금 앞선 위치에서 그레디언트를 계산합니다.

아래 그래프를 보면 알 수 있듯이 NAG가 minimum loss에 좀더 가깝습니다. 이러한 작은 개선이 쌓여서 NAG가 기존 모멘텀 회적화보다 확연히 빨라지게 됩니다. 게다가 기존 모멘텀 업데이트는 방향이 정해져 있기 때문에 의도와 달리 minimum loss쪽으로 가중치가 흘러가지 않을 수 있습니다. 그러나 NAG의 경우는 minimum loss쪽으로 가중치를 끌어당겨 진동을 감소시키고 수렴을 빠르게 합니다.

다음은 NAG를 Keras에서 사용한 코드입니다.

optimizer = keras.optimizers.SGD(lr=0.001, momentum=0.9, nesterov=True)

AdaGrad

방금 우리가 NAG와 경사 하강법의 최적화를 비교했던 바로 위 그래프를 다시 보겠습니다. 경사하강법은 가장 가파른 경사를 빠르게 내려가기 시작하여 골짜기 아래로 느리게 이동합니다. 만약 알고리즘이 이를 빠르게 감지하여 global minimum 쪽으로 정확한 방향을 잡아줬다면 좋았을 것입니다. 이를 위해 그레디언트 벡터의 스케일을 감소시켜 해결하고자 하는게 AdaGrad 알고리즘입니다.

첫번째 단계는 그레디언트의 제곱을 벡터 x에 누적합니다. 만약 비용함수가 i번째 차원을 따라 가파르다면, 기울기가 클 것이므로 $s_i$또한 반복이 진행됨에 따라 점점 커지게 됩니다.

두번째 단계는 경사 하강법과 거의 같습니다. 다만 한 가지 차이는 그레디언트 벡터를 루트값으로 나누어 스케일을 조정합니다.

AdaGrad는 학습률을 감소시키지만, 경사가 완만한 차원보다 가파른 차원에 대해 더 빠르게 감소됩니다. 이를 적응적 학습률이라 부르며 global minimum 방향으로 곧장 가도록 갱신하는데 도움을 줍니다.

AdaGrad는 간단한 2차 방정식 문제에 대해서는 잘 작동하지만, 학습률이 너무 감소되어서 global minimum이 도착하기 전 알고리즘이 멈추는 경우도 있습니다. 따라서 간단한 작업에서만 사용하고, Neural Network같이 복잡한 작업에서는 사용하지 않는 것이 좋습니다.

RMSProp

AdaGrad이 global minimum에 잘 도달할 수 있는 이유는 빠르게 내려가는 학습률이 방향 전환을 쉽게 해주기 때문입니다. 그러나 너무 빨리 느려져 global minimum에 도달하지 못할 수 있다는 위험도 내재되어있습니다.

RMSProp은 전체가 아닌 최근 반복에서 비롯된 그레디언트만 누적하여 이 문제를 해결했습니다. 이를 위해 알고리즘의 첫번째 단계로 지수 감소(Exponential Decay)를 사용합니다.

보통 감쇠율 $β$는 0.9로 설정합니다. 다음은 Keras로 구현한 코드입니다.

optimizer = keras.optimizers.RMSprop(lr=0.001, rho=0.9)

Adma과 Nadam

adaptive moment estimation의 줄임말인 Adam은 모멘텀 최적화와 RMSProp의 아이디어를 합친 것입니다. 모멘텀 최적화처럼 지난 그레디언트의 지수 감소 평균을 따르고, RMSProp처럼 지난 그레디언트 제곱의 지수 감소 평균을 따릅니다.

단계 1,2,5를 보면 Adam이 모멘텀 최적화, RMSProp과 아주 비슷하다는 것을 알 수 있습니다. 차이점은 단계 1에서 지수 감소 합 대신 지수 감소 평균을 계산하는 것이지만, 사실 상수 배인 것을 제외하면 동일합니다.

$m$,$s$는 초기화로 인해 훈련 초기에 0쪽으로 치우치게 될 것입니다. 그래서 이 두 단계가 훈련 초기에 $m$과$s$를 증폭시키는데 도움을 줄 것입니다.

다음은 Keras에서 적용한 코드입니다.

optimizer = keras.optimizers.Adam(lr=0.001, beta_1=0.9, beta_2=0.999)

Adam 또한 적응적 학습률 알고리즘이기 때문에, 학습률 하이퍼파라미터를 튜닝해주지 않아도 됩니다.

이제 지금껏 나온 옵티마이저를 비교해보겠습니다.

다음 포스팅에서는 학습률 스케줄링에 대해 공부해보겠습니다. 오늘도 함께해주셔서 감사합니다. 행복한 하루 보내세요 :)

[ 머신러닝 순한 맛] 전이학습은 어떻게 이뤄질까? with Code

Box형 — Tue, 11 May 2021 01:38:10 +0900

큰 야망을 품었을 때
커다란 결실을 얻을 수 있다.
- 힐러리 클린턴미국 상원의원 -

이 글을 읽는 여러분의 AI 공부를 어렵게 하는 것은 무엇인가요? 어려운 개념이나 수식도 한몫하겠지만, 저는 높은 연산량을 감당하기 위해, 값비싼 GPU가 필요하다는 것입니다.

이런 맥락에서 대부분의 AI를 초기에 공부하는 우리들이 아주 큰 규모의 DNN을 처음부터 훈련시킨다는 건 매우 어려운 일입니다. 이럴 경우 생각해볼 수 있는 방법이 비슷한 유형의 문제를 처리한 신경망이 있는지 찾아보고 이를 이용하는 전이 학습입니다.

우리는 이를 통해 훈련 속도도 크게 높일 수 있으며 필요한 훈련 데이터도 크게 줄어듭니다. 이번 포스팅에서는 실무에서도 많이 쓰이는 전이학습에 대해 공부해보겠습니다.

사전 훈련된 층 재사용하기

여기 동물, 식물, 자동차 등 100개의 구분된 이미지를 분류하도록 훈련된 DNN이 있다고 가정하겠습니다. 그리고 우리는 지금부터 구체적인 자동차의 종류를 분류하는 DNN을 훈련시키고자 합니다. 바로 이때 이렇게 두 DNN에 대해서 비슷한 점이 많고, 일부 겹치는 부분이 있을 때 신경망을 재사용하는 것을 고려해봐야합니다.

그렇다면 이제부터 어떤 기준을 가지고 기존 신경망을 재사용해야할지 알아보겠습니다.

첫번째로 해야할 일은 재사용하려는 모델의 출력층을 바꿔줘야 합니다. 물건을 구분하던 기존 신경망과 자동차의 종류를 구분하고자 하는 우리의 신경망은 그 출력이 다를 것이기 때문에 바꿔주는게 당연히 맞을 것입니다.

비슷한 맥락에서 재사용하려는 신경망의 상위 은닉층(출력층에 가까운 층들)은 하위 은닉층보다 덜 유용합니다. 왜냐하면 상위 은닉층이라 하면 구체적이고 세부적이고 지엽적인 특성을 학습하고 있기 때문에 이런 특성들은 도움되지 않을것입니다. 쉽게 말해서 우리는 이야기의 대략적인 개요나 줄거리 정도가 필요하지, 그 안에 등장인물의 이름이나 생김새와 같은 정보는 필요하지 않습니다.

그렇다면 우리가 방금 단계에서 재사용할 층의 개수까지 정하고 나면 무엇을 해야할까요? 우선은 재사용하는 층의 가중치는 모두 동결합니다. 즉 이들은 경사 하강법으로 가중치가 바뀌지 않습니다. 그 다음 모델을 훈련하고 평가합니다.

이후에 맨 위에 있는 가장 깊은 층부터 동결을 해제하면서 역전파 알고리즘을 이용하여 가중치를 조정하여 성능을 확인합니다. 이때 데이터가 많을 수록 더 많은 층을 동결 해제할 수 있습니다.

한 가지 주의할 점은 가중치를 세밀하게 튜닝하기 위해 학습률은 줄이는게 좋습니다. 만약 여전히 좋은 성능을 내지 못한다면 상위 은닉층을 제거하거나 추가하면서 재사용할 층의 개수를 적절히 찾아야 합니다.

Keras를 이용한 전이 학습

이번엔 직접 코드와 함께 전이 학습을 살펴보겠습니다. 우리가 여기서 활용한 데이터셋은 8개의 클래스로 나뉜 Fashion MNIST 데이터셋입니다. 누군가 이 데이터의 클래스를 90%이상의 정확도로 분류시키는 모델 'A'를 생성했다고 하겠습니다.

우리가 하고자하는 작업은 Fashion MNIST 데이터셋에는 없는 '샌들'과 '셔츠' 이미지를 구분하는 Binary Classifier를 구현하고자 합니다(True = 셔츠, False = 샌들). 레이블된 이미지는 200개 정도로 매우 적습니다. 그래서 우리는 모델 A와 구조가 매우 비슷한 모델 B를 만들었고 97.2%의 좋은 성능을 냈습니다.

하지만 클래스가 두개인 쉬운 문제이기 때문에 이 정확도를 더 높이고 싶고, 이를 위해 전이 학습을 하고자 합니다. 과연 도움이 될까요?

우선 모델 A를 로드하여 출력층을 제외하고 모든 층을 재사용해보겠습니다.

model_A = keras.models.load_model("my_model_A.h5")
model_B_on_A = keras.models.Sequential(model_A.layers[:-1])
model_B_on_A.add(keras.layers.Dense(1, activation="sigmoid"))

model_A와 model_B_on_A는 일부 층을 공유합니다. 즉 model_B_on_A가 훈련할 때 model_A도 함께 학습됩니다. 이를 원하지 않는다면, 훈련 전 클론시켜놔야합니다. 이를 위해 clone_model() 메서드를 사용하여 모델 A의 구조를 복제한 후 가중치를 복사합니다.

model_A_clone = keras.models.clone_model(model_A)
model_A_clone.set_weights(model_A.get_weights())

이제 재사용할 층과 가중치까지 가져왔기 때문에 훈련만 하면 됩니다. 그렇지만 바로 훈련으로 들어간다면 새로운 출력층이 랜덤하게 초기화되어있어 큰 오차를 만들 것이고 이로 인한 큰 오차 그레디언트는 최적화를 방해할 것입니다.

이를 피하기 위해 처음 몇번의 에포크 동안에는 재사용된 층을 동결하고 새로운 층에게 적절한 가중치를 학습할 시간을 줘야합니다. 이를 위해 모든 층의 trainable 속성을 False로 지정하겠습니다.

for layer in model_B_on_A.layers[:-1]:
    layer.trainable = False

model_B_on_A.compile(loss="binary_crossentropy",
                     optimizer=keras.optimizers.SGD(lr=1e-3),
                     metrics=["accuracy"])

이제 몇번의 에포크 동안 훈련을 하고 나면 동결을 해제하고 작업 B에 맞게 이 재사용된 층들을 세밀하게 튜닝해야합니다. 이때 학습률을 낮춰 가중치가 망가지는 것을 막아야합니다.

history = model_B_on_A.fit(X_train_B, y_train_B, epochs=4,
                           validation_data=(X_valid_B, y_valid_B))

for layer in model_B_on_A.layers[:-1]:
    layer.trainable = True

model_B_on_A.compile(loss="binary_crossentropy",
                     optimizer=keras.optimizers.SGD(lr=1e-3),
                     metrics=["accuracy"])
history = model_B_on_A.fit(X_train_B, y_train_B, epochs=16,
                           validation_data=(X_valid_B, y_valid_B))

최종점수를 확인해보면 그 정확도는 99.25%로 오차율을 2.8%에서 0.7%로 네 배나 낮췄습니다,

model_B.evaluate(X_test_B, y_test_B)
>> [0.1408407837152481, 0.9704999923706055]

전이 학습은 작은 규모의 Fully-Connected 네트워크에서는 잘 동작하지 않습니다. 작은 규모는 패턴 수를 적게 학습한다는 뜻이고, Fully-Connected 라는 것은 특정 패턴을 학습하기 때문일 것입니다. 실제로 이러한 특정 패턴이 다른 작업에서도 유용하게 쓰일 확률은 적다고 봐야합니다.

반대로 규모가 어느정도 있는 심층 합성곱 신경망은 일반적인 특성을 훨씬 잘 파악하기 때문에 잘 동작할 것입니다.

다음 포스팅에서는 최적화를 위해 일반적으로 우리가 사용하는 고속 옵티마이저의 종류에 대해서 알아보겠습니다. 오늘도 읽어주셔서 감사합니다. 행복한 하루 보내세요 :)

[머신러닝 순한맛] 그레디언트 소실(Vanishing) / 폭주(Exploding)이란?

Box형 — Sun, 2 May 2021 17:45:38 +0900

잘못된 전략이라도 제대로 실행만 하면 반드시 성공할 수 있다.

반대로 뛰어난 전략이라도 제대로 실행하지 못하면 반드시 실패한다.

- 선 마이크로시스템즈 CEO, 스콧 맥닐리 -

Deep Neural Network, 줄여서 DNN이라고 부르는 심층 신경망은 그 구조에 따라 수백 개에서 수 만개에 이르는 노드들이 엮어있는 구조를 지닙니다. 구조가 복잡한 것만큼 이것을 훈련하는 것 또한 쉽지 않습니다. 예를 들어

신경망의 아래쪽으로 갈 수록 그레디언트가 작아지거나 커지는 그레디언트 소실/폭주(Gradient Vanishing/Exploding) 문제가 발생할 수 있습니다.
훈련을 위한 데이터가 충분하지 않거나 데이터에 레이블을 붙이는데 많은 Cost가 들어갈 수 있습니다.
과대적합(Overfitting)의 위험이 있습니다.

이번 포스팅에서는 우리가 신경망을 훈련시키면서 발생할 수 있는 다양한 문제들에 대해 알아보고, 이들을 어떻게 해결할 수 있는지에 대해 알아보겠습니다.

그레디언트 소실/폭주

신경망을 훈련시킨다는 것은 Back Propagation 알고리즘으로 Output Layer에서 Input Layer로 loss에 대한 그레디언트를 전파하고, 경사 하강법을 통해 이 그레디언트로 loss가 가장 적도록 파라미터를 수정하는 것을 의미합니다.

그런데 알고리즘이 하위층으로 진행될수록 그레디언트가 더 작아지는 경우가 있는데, 이것을 그레디언트 소실이라고 합니다. 반대로 그레디언트가 비정상적으로 커지는 문제를 그레디언트 폭주라고 합니다. 이러한 불안정한 그레디언트는 Layer마다 상이한 학습 속도를 유발할 수 있기 때문에 좋지 않은 현상입니다.

이런 부정적인 현상이 오랫동안 관측되었지만 그 원인이 명확하게 규명되지 않았습니다. 그러다 2010년의 한 논문에 의해 우리가 많이 사용하는 logistic sigmoid 활성화 함수와 당시 가장 인기 있던 가중치 초기화 방법(표준정규분포를 이용한 초기화)의 조합 때문이라는 것이 밝혀졌습니다.

이 활성화 함수와 초기화 방식을 조합하여 사용했을 때, 신경망의 각 Layer에서 출력의 분산이 입력의 분산보다 더 크다는 것이 밝혀졌습니다. 이로 인해 신경망의 더 깊은 층으로 들어갈 수록 분산이 계속 커져 양 옆으로 퍼지면서 활성화 함수가 0이나 1로 수렴하게 되는 것이었습니다.

게다가 logistic 함수의 평균이 0.5라는 사실 때문에 더 나빠졌습니다 (하이퍼볼릭 탄젠트 함수는 평균이 0이라 그나마 나았습니다) 다시 돌아와서 로지스틱 함수의 이러한 수렴이 문제가 되는 이유는 0이나 1로 수렴시 기울기가 0에 가깝기 때문에 깊어질수록 훈련을 위한 아무런 정보도 도달하게 되지 않게 되는 것입니다.

글로럿과 He 초기화

결국 우리가 지향하고자 하는 이상적인 상황은 예측 시엔 정방향으로, 훈련 시엔 역방향으로 양방향 신호가 적절하게 흘러가야 하는데, 이때 신호가 죽거나 폭주 혹은 소멸하지 않는 것입니다.

이에 대해 한 논문에선 이렇게 적절한 신호가 흐르기 위해서는 정방향의 경우, 각 층의 출력에 대한 분산이 입력에 대한 분산과 같아야하고. 역방향에선 층을 통과하기 전과 후의 그레디언트 분산이 동일해야 한다고 주장합니다.

근본적으로 Layer의 Input과 Output의 연결 개수(fan in과 fan out)이 같지 않다면 위 두 가지를 보장할 수 없습니다. 그러나 저자들은 실전에서 매우 잘 작동한다고 입증된 대안을 제안하였는데, 바로 각 Layer들을 연결하는 가중치를 다음과 같이 무작위로 초기화하는 것입니다. 이를 글로럿 초기화(Glorot initialization)이라고 합니다.

여기서 $fan_{avg}$를 $fan_{in}$으록 바꾸면 르쿤 초기화가 됩니다. 어쨌든 글로럿 초기화는 훈련 속도를 상당히 높이는데 기여하였습니다. 다음 표는 다른 논문들에서 로지스틱외에 다른 활성화함수를 사용하여 제안한 다양한 초기화 전략들입니다. 보다시피 분산의 스케일링이나 $fan_{avg}$이나 $fan_{in}$을 쓰는 것이 다릅니다. He 초기화나 SELU에 대한 내용은 이따 다시 설명하겠습니다.

케라스는 기본적으로 균등분포의 글로럿 초기화를 사용합니다. 여기서 kernel_inializer = "he_uniform"이나 kernel_inializer = "he_normal"로 바꾸어 He 초기화를 사용할 수 있습니다.

keras.layers.Dense(10, activation="relu", kernel_initializer="he_normal")

$fan_{in}$ 대신 $fan_{out}$ 기반의 균등분포 He 초기화를 사용하고 싶다면 Variance Scaling을 다음과 같이 사용하면 됩니다.

init = keras.initializers.VarianceScaling(scale=2., mode='fan_avg',
                                          distribution='uniform')
keras.layers.Dense(10, activation="relu", kernel_initializer=init)

수렴하지 않는 활성화 함수

결국 우린 활성화 함수를 잘 선택해야 그레디언트 소실이나 폭주로 이어지지 않을 수 있습니다. 기존에 logistic 활성화 함수가 최선일거라고 생각하였지만, 특정 양수값에 수렴하지 않고 계산도 빠른 Relu 함수가 있었습니다.

하지만 Relu도 완벽하지 않습니다. 왜냐하면 큰 학습률(learning rate)를 사용 시 신경망 속 노드들의 절반이 죽어 있는 경우가 있었기 때문입니다.(노드가 0이외의 값을 출력하지 않을때 죽었다고 합니다)

Relu함수 이용시 노드가 죽는 이유는 모든 Input data에 대한 가중치의 합이 음수가 되면 아래 그래프에서 볼 수 있듯이그레디언트가 0이기 때문에 경사 하강법이 더 이상 작동하지 않게 됩니다.

이러한 문제 해결을 위해 LeakyReLU와 같은 변종을 사용합니다.

하이퍼 파라미터 $α$는 이 함수가 새는 정도를 결정합니다. 즉 샌다는 것은 음수 영역에서의 함수의 기울기를 의미하며 보통 $0.01$로 설정합니다. 바로 이 작은 기울기가 LeakyRelu가 절대 죽지 않게 해주는 것입니다. 실제로 성능도 훨씬 좋습니다. 다음은 LeakyRelu 사용법입니다. 적용하려는 층 뒤에 붙여주면 됩니다.

model = keras.models.Sequential([
    keras.layers.Flatten(input_shape=[28, 28]),
    keras.layers.Dense(300, kernel_initializer="he_normal"),
    keras.layers.LeakyReLU(),
    keras.layers.Dense(100, kernel_initializer="he_normal"),
    keras.layers.LeakyReLU(),
    keras.layers.Dense(10, activation="softmax")
])

이외에 $α$를 무작위로 선택하여 테스트 시에는 $α$들의 평균을 사용하는 RRelu나 $α$가 훈련하는 동안 학습되는 PReLU가 있습니다. 마지막으로 볼 활성화 함수는 다른 모든 ReLU 변종들의 성능을 앞서는 ELU입니다.

이 함수는 몇가지를 제외하고 ReLU와 유사한 특성을 지닙니다.

$z < 0$일때 음수값을 내보내므로, 활성화함수의 평균 출력이 0에 가까워지고 이는 그레디언트 소실 문제를 완화해줍니다. 여기서의 알파값은 ELU가 수렴할 값을 정의하는데 보통 1로 설정합니다.
$z<0$이어도 그레디언트가 0이 아니기 때문에 죽은 뉴런을 만들지 않습니다.
알파가 1일 때, $z=0$에서 급격한 변동이 일어나지 않는 즉 모든 구간에서 매끄럽기때문에 최적화의 속도를 높이는데 기여합니다.

ELU의 주요한 단점은 계산이 느리다는 것입니다. 물론 수렴 속도가 빨라 상쇄가 되지만, 테스트의 경우엔 ReLU를 이용한 네트워크보단 느릴 것입니다.

ELU의 변종인 SELU를 살펴보겠습니다. 저자들은 네트워크가 Fully-Connected한 상태에서 활성화함수로 SELU를 사용하면 자기 정규화(각 층의 출력의 평균이 0이고, 표준편차가 1이 유지됨)된다는 것을 보였습니다. 다음은 자기 정규화를 위한 몇가지 조건입니다.

Input은 반드시 표준화(평균 0, 표준편차 1)이어야 합니다.
hidden layer의 가중치는 르쿤 정규분포로 초기화되어 있어야 합니다.
순환 신경망이나, skip connection과 같은 순차적이지 않은 구조를 사용시 자기 정규화를 보장하지 않습니다.

다음은 일반적으로 우선순위시 되는 활성화 함수입니다.

네트워크가 자기 정규화 되지 못한다면 SELU보단 ELU
실행 속도가 중요하다면 LeakyReLU
신경망이 Overfitting되었다면 RReLU
그러나 대부분의 라이브러리와 하드웨어 가속기들은 ReLU에 특화되어있으므로, 속도를 위한다면 Relu

배치 정규화(Batch Normalization)

우리가 앞서 살펴본 초기화 방법들은 훈련 초기 단계에서 그레디언트 소실이나 폭주를 방지하는 방법입니다. 하지만 훈련 도중에 이러한 현상들이 다시 발생하지 않으리라는 보장은 없습니다. 이에 따라 제시된 해결책이 배치 정규화입니다.

이 기법은 활성화 함수 통과 전이나 후에 입력을 정규화한 후, 결과값의 스케일을 조정하고 이동시킵니다. 대부분의 경우 신경망의 첫번째 층에 배치 정규화를 추가하면 training set을 표준화할 필요가 없습니다.

우리가 고등학교때 배웠지만, input data를 정규화하기 위해서는 평균과 표준편차가 필요하기 때문에 이를 추정해야합니다. 다음은 이 추정을 위해 mini-batch에서 Input의 입력과 표준편차를 추정하는 알고리즘입니다.

하지만 테스트 시엔 데이터가 하나씩 들어오기 때문에, 전체 test data에 대한 평균과 표준편차를 계산할 방법이 없습니다. 이에 한가지 방법은 훈련이 끝난 후 test data가 포함된 전체 training set을 신경망에 통과시켜 각 input에 대한 평균과 표준편차를 계산하여 이를 예측에 활용하는 것입니다.

이러한 배치 정규화는 그레디언트 소실 / 폭주 문제 해결이나 학습 속도 향상에 크게 기여하였습니다. 그러나 배치 정규화는 층마다 추가되는 계산으로 인하여 복잡도와 실행 시간을 높입니다.

다행히 훈련이 끝난 후에 이전 층과 배치 정규화 층을 합쳐 실행 속도 저하를 피합니다. 즉 이전 층의 가중치를 바꾸어 바로 스케일이 조정되고 이동된 출력을 만듭니다. 다음은 이를 케라스로 구현한 코드입니다.

model = keras.models.Sequential([
    keras.layers.Flatten(input_shape=[28, 28]),
    keras.layers.BatchNormalization(),
    keras.layers.Dense(300, activation="relu"),
    keras.layers.BatchNormalization(),
    keras.layers.Dense(100, activation="relu"),
    keras.layers.BatchNormalization(),
    keras.layers.Dense(10, activation="softmax")
])

그레디언트 클리핑

그레디언트 문제 그 중에서도 폭주 문제를 완화하는 인기 있는 방법은 역전파 시 일정 임곗값을 넘어가지 않도록 그레디언트를 잘라내는 것입니다. 이를 그레디언트 클리핑이라고 합니다.

이 방법은 앞서 우리가 배치 정규화를 적용하기 어렵다고 한 순환 신경망같은 구조에서 사용합니다. 다음은 이를 keras에서 구현한 것입니다.

optimizer = keras.optimizers.SGD(clipvalue=1.0)

이 옵티마이저는 그레디언트 벡터의 모든 원소를 $-1.0$에서 $1.0$ 사이로 클리핑합니다. 즉 loss에 대한 모든 편미분 값을 이 사이로 잘라내는 것입니다. 예를 들어 원래 그레디언트 벡터가 $[0.9, 100.0]$이었다면 이를 클리핑 시 $[0.9, 1.0]$가 되는 것입니다.

다음 포스팅에서는 신경망 학습에서 많이 활용되는 전이 학습에 대해 알아보겠습니다. 오늘도 읽어주셔서 감사합니다. 행복한 하루 보내세요 :)

[ Flutter ] TextField 내 hinttext 가운데로 정렬하기

Box형 — Sun, 28 Feb 2021 15:41:05 +0900

TextField 내 'textAlign: TextAlign.center'를 삽입해주면 쉽게 해결된다.

Container(
                          width: screenWidth*(300/360),
                          child: TextField(
                            controller: textfieldController_OpenChatLink,
                            textInputAction: TextInputAction.done,
                            // textAlign: TextAlign.center,
                            decoration: InputDecoration(
                              hintText: 'https://open.kakao.com/12345679',
                              hintStyle: TextStyle(
                                fontSize: screenWidth*(16/360),
                                color: hexToColor('#D2D2D2'),
                                fontWeight: FontWeight.bold,
                              )
                            ),
                          ),
                        )

Container(
                          width: screenWidth*(300/360),
                          child: TextField(
                            controller: textfieldController_OpenChatLink,
                            textInputAction: TextInputAction.done,
                             textAlign: TextAlign.center,
                            decoration: InputDecoration(
                              hintText: 'https://open.kakao.com/12345679',
                              hintStyle: TextStyle(
                                fontSize: screenWidth*(16/360),
                                color: hexToColor('#D2D2D2'),
                                fontWeight: FontWeight.bold,
                              )
                            ),
                          ),
                        )

[ Flutter ] Google Map 현재 위치로 이동하는 버튼 만들기

Box형 — Fri, 26 Feb 2021 03:23:05 +0900

이번 포스팅에서는 Flutter에서 Google map을 사용할 때 현재 자신의 위치로 camera position을 이동시키는 버튼을 구현해보겠습니다.

사실 다음과 같이 myLocationButtonEnabled: true로 주셔도 버튼이 생성되는데, 이 경우에 버튼이 오른쪽 상단에 생기는데 위치를 변경하지 못하는 문제점이 발생합니다.

GoogleMap(
            mapType: _googleMapType,
            initialCameraPosition: _initialCameraPostion,
            onMapCreated: (GoogleMapController controller) async {
             //
            },
            myLocationEnabled: true,
            #################################################
            myLocationButtonEnabled: true,
            #################################################
            zoomControlsEnabled: false,
            markers: _markers,

          ),

그래서 직접 구현해보고자 합니다!

우선 location package를 설치해주세요.

pub.dev/packages/location

location | Flutter Package

A Flutter plugin to easily handle realtime location in iOS and Android. Provides settings for optimizing performance or battery.

pub.dev

그 후 다음과 같이 눌렀을 때 현재 위치로 이동할 버튼과 onTap 이벤트 발생 시 현재 위치로 이동하게 해주는 _currentLocation함수를 정의한 후 코드에 적용해주시면 끝입니다!

GestureDetector(
            onTap: (){
              _currentLocation();
            },
            child: Container(
              width: screenWidth*(40/360),
              height: screenWidth*(40/360),
              decoration: BoxDecoration(
                borderRadius: BorderRadius.circular(8.0),
                color: Colors.white,
              ),
              child: Padding(
                padding:  EdgeInsets.all(screenWidth*(6/360)),
                child: SvgPicture.asset(
                  GreyMyLocationIcon,
                  width: screenWidth*(28/360),
                  height: screenWidth*(28/360),
                ),
              ),
            ),
          ),
          
          
void _currentLocation() async {
    final GoogleMapController controller = await _controller.future;
    LocationData currentLocation;
    var location = new Location();
    try {
      currentLocation = await location.getLocation();
    } on Exception {
      currentLocation = null;
    }

    controller.animateCamera(CameraUpdate.newCameraPosition(
      CameraPosition(
        bearing: 0,
        target: LatLng(currentLocation.latitude, currentLocation.longitude),
        zoom: 14.0,
      ),
    ));
  }

[ Flutter ] TextField의 prefixIcon 사이즈 내맘대로 조절하기

Box형 — Thu, 25 Feb 2021 09:57:29 +0900

위와 같은 디자인을 구현하기 위해서는 TextField를 이용하는데, 돋보기를 사이즈에 맞게 넣으려는데 애를 먹었다. 다음과 같이 prefixIcon에 Svg나 Png를 넣어주면 TextField 앞에 아이콘이 자리잡게 된다.

Container(
                        height: screenHeight*0.05,
                        width: screenWidth*0.836111,
                        child: TextField(
                          textAlign: TextAlign.left,
                          controller: textfieldControllerSearchLocation,
                          decoration: InputDecoration(
                            hintText: '지역별 검색',
                            hintStyle: TextStyle(
                                fontSize: screenWidth*(12/360),
                                color: hexToColor('#888888')
                            ),
                            ############################
                            prefixIcon: SvgPicture.asset(
                              GreyMagnifyingGlass,
                              width: screenWidth*(16/360),
                            ),
                            ############################
                            fillColor: hexToColor("#EEEEEE"),
                            filled: true,
                            border: OutlineInputBorder(),
                            isDense: true,
                            contentPadding: EdgeInsets.symmetric(vertical: screenHeight*(8/640)),
                            focusedBorder: OutlineInputBorder(
                              borderRadius: BorderRadius.all(Radius.circular(8)),
                              borderSide: BorderSide(width: 1,color: kPrimaryColor),
                            ),
                            enabledBorder: OutlineInputBorder(
                              borderRadius: BorderRadius.all(Radius.circular(8)),
                              borderSide: BorderSide(width: 1,color: hexToColor(("#EEEEEE"))),
                            ),
                          ),
                          onChanged: (value) {

                          },
                        ),
                      )

그런데 아무런 옵션 없이 넣게되면 다음과 같이 아무리 width나 height를 바꿔도 사이즈가 고정된다.

이럴 경우 다음과 같이 Padding을 위아래로 주게되면 내가 원하는 크기로 줄일 수 있다.

Container(
                        height: screenHeight*0.05,
                        width: screenWidth*0.836111,
                        child: TextField(
                          textAlign: TextAlign.left,
                          controller: textfieldControllerSearchLocation,
                          decoration: InputDecoration(
                            hintText: '지역별 검색',
                            hintStyle: TextStyle(
                                fontSize: screenWidth*(12/360),
                                color: hexToColor('#888888')
                            ),
                            ##############################
                            prefixIcon: Padding(
                              padding: EdgeInsets.symmetric(vertical: screenHeight*(8/640)),
                              child: SvgPicture.asset(
                                GreyMagnifyingGlass,
                                width: screenWidth*(16/360),
                              ),
                            ),
                             ##############################
                            fillColor: hexToColor("#EEEEEE"),
                            filled: true,
                            border: OutlineInputBorder(),
                            isDense: true,
                            contentPadding: EdgeInsets.symmetric(vertical: screenHeight*(8/640)),
                            focusedBorder: OutlineInputBorder(
                              borderRadius: BorderRadius.all(Radius.circular(8)),
                              borderSide: BorderSide(width: 1,color: kPrimaryColor),
                            ),
                            enabledBorder: OutlineInputBorder(
                              borderRadius: BorderRadius.all(Radius.circular(8)),
                              borderSide: BorderSide(width: 1,color: hexToColor(("#EEEEEE"))),
                            ),
                          ),
                          onChanged: (value) {

                          },
                        ),
                      )

[ 핸즈 온 머신러닝 2 ] 비지도 학습의 모든 것 (K-Means)

Box형 — Mon, 8 Feb 2021 16:37:02 +0900

약해지지 말자.
- 래리 페이지 (구글 공동창립자) -

시작하며

이전 포스팅에서는 대부분 레이블($y$)이 존재하는 데이터에 대해 다뤄봤습니다. 하지만 우리가 사용하는 대부분의 데이터는 레이블이 없습니다.

그렇다면 레이블이 없다면 붙이면 되지 않을까요? 예를 들어 제품 결함을 감지하는 시스템을 만들어야 한다고 가정해보겠습니다. 시스템을 학습시키기 위해 수천장의 제품 사진 데이터를 마련하는 건 쉬울지 몰라도 이것들에 각각 결함과 정상을 판단하여 레이블링을 하는 것은 높은 cost를 요합니다.

물론 최근에는 데이터에 대한 중요성이 대두되면서 정부 차원에서 이러한 데이터 생성 및 가공에 힘을 쓰고 있지만, 이번 포스팅에선 사람의 도움없이 알고리즘이 레이블이 없는 데이터를 바로 사용하는 비지도 학습에 대해 살펴보겠습니다.

9.1 군집 (Clustering)

길을 걷다보면 많은 꽃들을 보게 됩니다. 이들이 모두 동일하지는 않지만, 외형적인 모습의 유사성을 통해 비슷한 종류의 꽃들끼리 그룹을 짓는건 굳이 전문가가 필요한 일이 아닙니다. 우리는 이러한 비슷한 특성을 가지는 데이터들끼리 묶는 것을 군집(clustering)이라고 합니다. 그리고 이때 만들어진 그룹을 Cluster라고 합니다.

Clustering은 결국 각각의 데이터를 하나의 Cluster에 할당하는 작업입니다. 다음 그림은 동일한 붓꽃 데이터셋에 대해서 한쪽은 레이블링이 되어있고, 다른 한쪽은 그렇지 않은 데이터를 시각화한 것입니다.

왼족은 레이블링 되어있는 덕분에 Logistic Regression, SVM 등의 Classification 알고리즘이 잘 맞습니다. 그러나 오른쪽은 레이블링이 없기 때문에 Clustering 알고리즘이 필요합니다.

이제 본격적으로 Clustering 알고리즘에 대해 알아보겠습니다.

9.1.1 k-평균

아래 보이는 데이터셋은 레이블이 없고, 육안으로 볼때 샘플 덩어리 5개가 잘 구분되어있는 것을 확인할 수 있습니다. 우리가 배울 첫번째 Clustering 알고리즘인 k-means 알고리즘은 몇번의 반복으로 이런 종류의 데이터셋을 효율적으로 클러스터로 묶을 수 있습니다.

우선 구체적인 작동 원리를 살펴보기 전 sklearn의 코드를 살펴보겠습니다.

from sklearn.cluster import KMeans

k = 5
kmeans = KMeans(n_clusters=k, random_state=42)
y_pred = kmeans.fit_predict(X)

첫번째로는 알고리즘이 찾을 클러스터 개수 $k$를 지정해야 합니다. 지금은 육안으로 보고 $5$라고 설정하였지만, 실제로는 이런 방식으로 정하지 못하는데 이 부분은 조금 이따가 살펴보겠습니다.

어쨌든 $k=5$라고 할당이 되었다면, 각각의 데이터는 5개의 클러스터 중 하나에 할당되는데, 바로 할당되는 클러스터의 index가 데이터의 레이블이 됩니다.(Classification의 클래스 레이블과는 분명히 다릅니다.)

다음 코드처럼 labels_ 변수를 이용하면 훈련된 데이터의 레이블을 확인할 수 있습니다.

y_pred
>>
array([0, 4, 1, ..., 2, 1, 4], dtype=int32)

y_pred is kmeans.labels_
>>
True

다음 코드에서는 알고리즘이 찾은 다섯 개의 센트로이드를 나열합니다. 이때 센트로이드는 하나의 클러스터 내 데이터들의 중심이 되는 점입니다.

kmeans.cluster_centers_

>>
array([[-2.80037642,  1.30082566],
       [ 0.20876306,  2.25551336],
       [-2.79290307,  2.79641063],
       [-1.46679593,  2.28585348],
       [-2.80389616,  1.80117999]])

만약 새로운 데이터가 들어온다면, 다음과 같이 해당 위치에서 가장 가까운 센트로이드가 속해있는 클러스터에 할당할 수 있습니다.

X_new = np.array([[0, 2], [3, 2], [-3, 3], [-3, 2.5]])
kmeans.predict(X_new)

>>
array([1, 1, 2, 2], dtype=int32)

그리고 클러스터의 결정 경계를 그리면 다음과 같은 다이어그램을 얻을 수 있습니다. 이때 센트로이드는 $X$로 표시되어있습니다. 대부분의 데이터는 잘 할당이 되어있는데, 클러스터의 경계 부근 특히 핑크색과 노란색 클러스터 사이의 데이터 몇개는 잘못된 레이블이 부여되어있습니다.

여기서 알 수 있는건 K-Means 알고리즘은 데이터에서 센트로이드까지의 거리를 고려하는 것이 전부이기 때문에, 클러스터 간의 크기가 많이 다르면 성능이 좋지 못합니다.

이렇게 각각의 데이터를 하나의 Cluster에 할당하는 방식을 Hard Clustering이라고 합니다. 그리고 각각의 데이터마다 모든 클러스터마다 점수를 부여해 이중 하나를 선택하는 방식은 Soft Clustering이라고 합니다.

이때 점수를 매기는 방식은 거리가 될 수도 있고, Gaussian RBF Kernel함수를 이용한 유사도 점수가 될 수도 있습니다. 다음은 transform() 메서드를 통해 데이터와 센트로이드 사이의 거리를 반환합니다.

만약 고차원 데이터셋을 이런 방식으로 변환하면, 클러스터 개수가 k일때 k-차원 데이터셋으로 변환하여 효과적인 차원 축소(Dimension Reduction)을 수행할 수 있습니다.

kmeans.transform(X_new)

>>
array([[2.88633901, 0.32995317, 2.9042344 , 1.49439034, 2.81093633],
       [5.84236351, 2.80290755, 5.84739223, 4.4759332 , 5.80730058],
       [1.71086031, 3.29399768, 0.29040966, 1.69136631, 1.21475352],
       [1.21567622, 3.21806371, 0.36159148, 1.54808703, 0.72581411]])

K-Means 알고리즘의 작동 방법

이제 본격적으로 K-Means 알고리즘의 작동 방법에 대해 알아보겠습니다. 센트로이드가 주어진다면, 각 데이터별로 가장 가까운 센트로이드의 클러스터에 할당하면 됩니다. 반대로 샘플의 레이블이 주어져있다면, 평균을 계산하여 모든 센트로이드를 구할 수도 있습니다.

그러나 둘다 주어지지 않는다면 어떻게 해야할까요? 처음에는 무작위로 k개의 데이터를 골라 그 위치를 센트로이드로 지정합니다. 그리고 지정된 이 센트로이드에 따라 각 데이터별로 레이블링을 하고 센트로이드를 다시 업데이트합니다. 이 과정을 센트로이드에 변화가 없을 때까지 계속 하는데, 이 알고리즘은 제한된 횟수안에 수렴함을 보장합니다.

다음은 세 번의 반복으로 최적의 클러스터링을 만들어내는 과정입니다.

알고리즘의 수렴성은 보장되지만, 그것이 반드시 최적의 솔루션인 것은 아닙니다. 이것의 성공 여부는 센트로이드의 초기화에 달려있기 때문입니다.

센트로이드 초기화 방법

센트로이드 초기화 방법에는 몇가지가 있는데, 어떻게 센트로이드를 초기화하느냐에 따라 알고리즘의 성능에 큰 영향을 미칩니다. 첫번째 방법은 n_init = 1로 설정하고, 하나의 numpy 배열로 센트로이드 리스트를 초기화하는 것입니다.

good_init = np.array([[-3, 3], [-3, 2], [-3, 1], [-1, 2], [0, 2]])
kmeans = KMeans(n_clusters=5, init=good_init, n_init=1)

두 번째 방법은 매번 다른 랜덤 초기화를 하여 여러 번 알고리즘을 실행하고, 이중 가장 좋은 솔루션을 채택하는 것입니다. n_init이 바로 랜덤 초기화 횟수를 지정하는 변수이며 기본 값은 10입니다.

그렇다면 가장 좋은 솔루션이라고 판단하는 성능 지표는 무엇일까요? 그것은 각 데이터와 센트로이드 사이의 평균 제곱 거리로 도출한 모델의 이너셔(inertia)입니다.

다음 그림에서 왼쪽 솔루션의 이너셔는 223.3, 오른쪽은 237.5입니다. KMeans 클래스는 n_init번 실행하여 이너셔가 가장 낮은 모델을 리턴합니다.

그리고 inertia_ 변수로 해당 모델의 이너셔를 확인할 수 있습니다.

kmeans.inertia_

>>
211.62337889822362

score() 메서드는 이너셔의 음숫값을 반환합니다. 이것은 "큰 값이 좋은 것이다"라는 sklearn의 규칙을 따르기 위해 더 좋은 모델이 높은 값을 갖도록 하기 위함입니다.

kmeans.score(X)

>>
-211.62337889822362

K-Means++ 알고리즘

이 개선된 알고리즘은 센트로이드 초기화 단계에서 다른 센트로이드와 거리가 먼 센트로이드를 선택하는 방식으로 기존 알고리즘의 성능을 높이고 최적이 아닌 솔루션으로 수렴할 가능성을 크게 낮췄습니다.

게다가 최적의 솔루션을 찾기 위한 반복 횟수도 크게 줄이기 때문에 충분한 가치가 있는데, 작동 원리는 다음과 같습니다.

sklearn에서는 원래 이 초기화 방법을 사용하는데, 앞서 배웠던 방식을 사용하고 싶다면 init = "random"으로 설정하면 됩니다.

K-Means 속도 개선과 mini-batch

2013년도에 한 논문을 통해 불필요한 거리 계산을 피함으로써 알고리즘의 속도를 상당히 높이는 방법이 제안되었습니다. 여기서 사용된 것은 삼각 부등식을 사용하였고, 데이터와 센트로이드 사이의 거리를 위한 하한선과 상한선을 두었습니다.

또 다른 논문에서는 전체 데이터셋을 사용해 반복하는 것이 아닌, 각 반복마다 mini-batch를 사용해 센트로이드를 조금씩 이동합니다. 이는 알고리즘의 속도를 3~4배 정도 높이며 큰 데이터셋을 다룰 때 용이합니다. 다음은 코드입니다.

from sklearn.cluster import MiniBatchKMeans

minibatch_kmeans = MiniBatchKMeans(n_clusters=5, random_state=42)
minibatch_kmeans.fit(X)

mini-batch K-Means 알고리즘은 속도는 빠르나 이너셔는 조금 더 나쁩니다. 특히 클러스터의 개수가 증가할 때 그렇습니다. 다음 그림에서 왼쪽 그래프는 클러스터 개수 $k$에 따른 mini-batch k-means와 k-means의 이너셔를 비교한 것입니다.

왼쪽 그래프의 경우 곡선의 차이가 일정하게 유지되는 듯 보이지만, 클러스터의 개수가 늘어날 수록 이너셔가 점점 줄어들기 때문에, 차이가 차지하는 비율은 점점 커집니다. 그러나 오른쪽 그래프를 보면 mini-batch K-Means가 일반적인 알고리즘보다 훨씬 빠르다는 것을 확인할 수 있습니다.

최적의 클러스터 개수 찾기

클러스터의 개수는 K-Means 알고리즘의 성능을 결정짓는 매우 중요한 요소입니다. 다음과 같이 클러스터의 개수가 너무 적다면 여러 클러스터가 합쳐지고, 그렇다고 너무 많다면 하나의 클러스터가 여러 개로 나눠질 수도 있습니다.

그렇다면 가장 적은 이너셔를 가진 모델을 선택하면 되는걸까요? 다음 그림을 보면 $k=3$일 때 이너셔는 $653.2$이고, $k$가 늘어날 수록 이너셔는 점점 작아지기 때문에 이너셔가 그다지 좋은 성능 지표가 아니라는 걸 알 수 있습니다.

어차피 클러스터가 늘어날 수록 각각의 데이터는 가까운 센트로이드에 가까워지기 때문에 이너셔가 작아지는 건 당연한 결과입니다.

위 그림에서 보듯이 $k = 4$까지는 빠르게 이너셔가 감소하는걸 확인할 수 있습니다. 이 지점을 Elbow라 칭하는데, 보통 이 지점을 넘어서면 이너셔가 줄어드는 속도가 매우 줄어들기 때문에 $4$를 넘어선 클러스터의 개수는 크게 도움이 되지 않습니다. 따라서 보통 이 Elbow를 최적의 클러스터 개수로 고르게 됩니다.

그러나 방금과 같은 방법은 조금은 엉성하게 느껴지기도 합니다. 더 정확한 방법은 실루엣 점수(silghouette score)입니다. 이 점수는 모든 데이터에 대한 실루엣 계수의 평균입니다. 각 데이터의 실루엣 계수는 다음과 같습니다.

$a$는 동일한 클러스터 내 다른 데이터와 자기 자신 데이터와의 평균 거리입니다(클러스터 내부의 평균 거리). $b$는 자기가 속한 클러스터를 제외하고 가장 가까운 클러스터의 데이터까지 평균 거리입니다. 계수는 $-1$에서 $1$까지 바뀔 수 있습니다.

$+1$에 가까우면 $b$ 즉 다른 클러스터와 멀면서, $a$ 자기가 속한 클러스터 내 데이터들과 가깝고 잘 뭉쳐져있다는 뜻이고, $-1$에 가깝다면, 반대이기 때문에 잘못된 클러스터에 할당되었다는 의미입니다.

실루엣 점수를 계산하려면 sklearn의 silhouette_score() 함수를 사용합니다.

from sklearn.metrics import silhouette_score

silhouette_score(X, kmeans.labels_)
>>
0.655517642572828

클러스터의 개수에 따라 상이한 실루엣 점수를 살펴보겠습니다. 클수록 잘 클러스터링된 것입니다.

모든 데이터의 실루엣 계수를 할당된 클러스터와 계수값으로 정렬하여 그리면 더 많은 정보가 있는 그래프를 얻을 수 있습니다. 이를 실루엣 다이어그램이라고 합니다.

클러스터마다 칼 모양이 그려지는 이 그래프의 높이는 클러스터가 포함하고 있는 데이터의 개수를 의미하고, 너비는 클러스터 내 데이터의 정렬된 실루엣 계수를 나타냅니다.(넓을 수록 좋습니다.)

빨간색으로 표시된 수직 파선은 해당 클러스터 개수에 따른 실루엣 점수를 나타냅니다. 특정 클러스터의 데이터 대부분이 이 점수보다 낮은 계수를 가지면(파선의 왼쪽에 있다면) 나쁜 클러스터입니다.

위 그림의 경우 $k = 4$와 $k=5$일 때 클러스터가 상당히 좋아보이는데, 특히 $k = 5$일 때, 모든 클러스터의 크기가 비슷하기 때문에 이것을 선택하는게 좀 더 좋습니다.

9.1.2 K-Means의 한계

K-Means 알고리즘는 몇 가지 단점이 있습니다.

최적의 솔루션을 도출하기 위해 여러번 알고리즘을 실행해야 합니다.
클러스터 개수를 지정해야 합니다.
클러스터의 크기나 밀집도가 서로 다르거나, 원형이 아닐 경우 잘 작동하지 않습니다.

위 단점들 중 세 번째에 대해 좀 더 살펴보겠습니다. 다음 그림은 크기, 밀집도, 방향이 다른 세 개의 타원형 클러스터를 가진 데이터에 대해 K-Means를 적용한 결과입니다.

보다시피 둘 다 좋은 솔루션은 아닙니다. 즉 우리는 데이터의 형태에 따라 K-Means가 아닌 다른 알고리즘들도 고려해야할 시점이 온 것입니다. 이 경우 잘 작동하는 것은 가우시안 혼합 모델(Gaussian Mixture Model)입니다.(이 부분은 다음 포스팅에서 다룹니다.)

k-Means에선 input feature의 스케일을 맞추는 것이 중요합니다. 그렇지 않는다면 클러스터가 길쭉해지고, 좋지 않은 결과를 유발할 수 있습니다.

9.1.3 클러스터링을 활용한 Image Segmentation

Image Segmentation은 이미지를 여러 Segment로 분할하는 작업입니다. 여기서 말하는 Segment란 사람, 자동차 등의 Object입니다. 이러한 Segmentation에서 최고 수준의 성능을 내려면 Neural network를 사용해야하는데, 여기선 훨씬 쉬운 작업인 Color Segmentation을 수행해보겠습니다.

우선 이미지를 읽어옵니다.

images_path = os.path.join(PROJECT_ROOT_DIR, "images", "unsupervised_learning")
os.makedirs(images_path, exist_ok=True)
DOWNLOAD_ROOT = "https://raw.githubusercontent.com/rickiepark/handson-ml2/master/"
filename = "ladybug.png"
print("Downloading", filename)
url = DOWNLOAD_ROOT + "images/unsupervised_learning/" + filename
urllib.request.urlretrieve(url, os.path.join(images_path, filename))

from matplotlib.image import imread
image = imread(os.path.join(images_path, filename))
image.shape

이미지는 3차원 배열로 표현됩니다(height, width, number of color channel). 이 경우엔 RGB로 표현된 3차원 벡터가 color channel입니다. 다만 흑백 이미지의 경우는 채널이 하나이고 투명도를 조절하는 경우 사용하는 알파 채널의 경우는 훨씬 더 많은 채널을 가집니다.

다음은 color channel은 RGB 색상의 긴 리스트로 변환 다음 K-Means를 사용해 각각의 색상을 클러스터로 모읍니다.

X = image.reshape(-1, 3)
kmeans = KMeans(n_clusters=8, random_state=42).fit(X)
segmented_img = kmeans.cluster_centers_[kmeans.labels_]
segmented_img = segmented_img.reshape(image.shape)

예를 들어 모든 초록색을 하나의 컬러 클러스터로 만들 수 있습니다. 그 후 해당 클러스터의 평균 컬러를 찾고, 모든 초록색을 해당 평균 컬러로 바꿀 수도 있습니다. 그 후 이 긴 Color 리스트를 원본 이미지와 동일한 크기로 바꿉니다.

그 결과는 다음과 같습니다. 8개보다 클러스터 개수를 작게 하면 무당벌레의 화려한 빨간색이 독자적인 클러스터를 만들지 못하고 주위 색에 합쳐집니다. 나눌 수 있는 클러스터의 개수가 적어진다는 건 표현할 수 있는 색깔의 종류도 줄어든다는 의미이기 때문입니다.

9.1.4 클러스터링을 사용한 전처리

클러스터링은 Supervised Learning을 위한 전처리 단계로 사용할 수 있습니다. 차원 축소에 클러스터링을 사용하는 예시를 위해 MNIST 데이터셋을 다뤄보겠습니다. 우선 데이터를 받아옵니다.

from sklearn.datasets import load_digits

X_digits, y_digits = load_digits(return_X_y=True)

이를 Training과 Test set으로 나눕니다.

from sklearn.model_selection import train_test_split


X_train, X_test, y_train, y_test = train_test_split(X_digits, y_digits, random_state=42)

그 후 Logistic Regression 모델을 훈련합니다.

from sklearn.linear_model import LogisticRegression

log_reg = LogisticRegression(multi_class="ovr", solver="lbfgs", max_iter=5000, random_state=42)
log_reg.fit(X_train, y_train)

Test set에서 정확도를 평가해보겠습니다. 우선 별도의 전처리 없이 $96.9%$ 정확도를 얻었습니다.

log_reg.score(X_test, y_test)
>>
0.9688888888888889

이제 K-Means를 전처리로 사용하여 성능이 더 좋아지는지 확인해보겠습니다. 우선 Training set을 50개의 클러스터로 나누고, 이미지를 50개 클러스터까지 거리로 바꿉니다.

from sklearn.pipeline import Pipeline


pipeline = Pipeline([
    ("kmeans", KMeans(n_clusters=50, random_state=42)),
    ("log_reg", LogisticRegression(multi_class="ovr", solver="lbfgs", max_iter=5000, random_state=42)),
])
pipeline.fit(X_train, y_train)

정확도도 상당히 개선된 것을 확인할 수 있습니다.

pipeline.score(X_test, y_test)
>>
0.98

클러스터링은 데이터셋의 Dimension을 64에서 50으로 감소시켰지만, 성능이 향상된 이유는 원본보다 변환된 데이터셋이 더 잘 구분할 수 있기 때문입니다.

이번엔 GridSearchCV를 사용해 최적의 클러스터 개수를 찾은 후 다시 적용해보겠습니다.

from sklearn.model_selection import GridSearchCV

param_grid = dict(kmeans__n_clusters=range(2, 100))
grid_clf = GridSearchCV(pipeline, param_grid, cv=3, verbose=2)
grid_clf.fit(X_train, y_train)

이제 최선의 $k$값과 파이프라인의 성능을 확인해보겠습니다. $k = 99$일 때 정확도가 크게 향상되고, Test set에서 98.22%를 달성했습니다.

grid_clf.best_params_
>>
{'kmeans__n_clusters': 57}


grid_clf.score(X_test, y_test)
>>
0.98

9.1.5 클러스터링을 사용한 Semi-Supervised Learning

준지도학습(Semi-Supervised Learning)은 레이블이 없는 데이터가 많고, 레이블이 있는 데이터는 적을 때 사용합니다. MNIST 데이터셋에서 레이블된 50개의 데이터에 50개 데이터에 Logistic Regression을 훈련시켜보겠습니다.

n_labeled = 50
log_reg = LogisticRegression(multi_class="ovr", solver="lbfgs", random_state=42)
log_reg.fit(X_train[:n_labeled], y_train[:n_labeled])
log_reg.score(X_test, y_test)

>>
0.8333333333333334

겨우 83.3%의 정확도입니다. 전체 데이터셋이 아닌 일부만 사용했기에 나온 당연한 결과입니다. 이제 이를 개선해보겠습니다. 우선 Training set을 50개의 클러스터로 모은 후, 각 클러스터에서 센트로이드에 가장 가까운 이미지를 찾습니다. 우리는 이를 대표 이미지라고 부르겠습니다.

k = 50
kmeans = KMeans(n_clusters=k, random_state=42)
X_digits_dist = kmeans.fit_transform(X_train)
representative_digit_idx = np.argmin(X_digits_dist, axis=0)
X_representative_digits = X_train[representative_digit_idx]

다음이 바로 50개의 대표 이미지들입니다.

이미지를 보고 수동으로 레이블을 할당해보겠습니다.

y_representative_digits = np.array([
    0, 1, 3, 2, 7, 6, 4, 6, 9, 5,
    1, 2, 9, 5, 2, 7, 8, 1, 8, 6,
    3, 1, 5, 4, 5, 4, 0, 3, 2, 6,
    1, 7, 7, 9, 1, 8, 6, 5, 4, 8,
    5, 3, 3, 6, 7, 9, 7, 8, 4, 9])

이제 레이블된 50개의 또다른 데이터셋이 준비되었습니다. 다만 무작위가 아니라 각 클러스터들을 대표하는 이미지입니다.

log_reg = LogisticRegression(multi_class="ovr", solver="lbfgs", max_iter=5000, random_state=42)
log_reg.fit(X_representative_digits, y_representative_digits)
log_reg.score(X_test, y_test)
>>
0.9244444444444444

성능은 분명 좋아졌습니다. 문제는 각 클러스터 내 데이터들은 해당 클러스터의 대표 이미지의 레이블이 부여되어있습니다. 이렇게 되면 클러스터 경계에 가깝게 위치한 데이터가 포함되어 있고, 잘못 레이블이 부여되어있을 확률이 농후합니다.

따라서 모든 데이터가 아닌 각 클러스터에서 센트로이드에 가까운 20%의 데이터에만 대표 이미지의 레이블을 부여해보겠습니다.

percentile_closest = 20

X_cluster_dist = X_digits_dist[np.arange(len(X_train)), kmeans.labels_]
for i in range(k):
    in_cluster = (kmeans.labels_ == i)
    cluster_dist = X_cluster_dist[in_cluster]
    cutoff_distance = np.percentile(cluster_dist, percentile_closest)
    above_cutoff = (X_cluster_dist > cutoff_distance)
    X_cluster_dist[in_cluster & above_cutoff] = -1
    
partially_propagated = (X_cluster_dist != -1)
X_train_partially_propagated = X_train[partially_propagated]
y_train_partially_propagated = y_train_propagated[partially_propagated]

이제 이 데이터셋을 모델에 훈련시켜보겠습니다.

log_reg = LogisticRegression(multi_class="ovr", solver="lbfgs", max_iter=5000, random_state=42)
log_reg.fit(X_train_partially_propagated, y_train_partially_propagated)
log_reg.score(X_test, y_test)

>>
0.9222222222222223

레이블된 데이터 50개만으로 92%의 정확도를 얻었습니다. 이는 그만큼 잘 레이블된 데이터를 사용했기 때문입니다.

9.1.6 DBSCAN

이 알고리즘은 모여있는 연속된 작은 지역들을 하나의 클러스터로 묶습니다. 작동 방식은 다음과 같습니다.

우선 알고리즘이 각 데이터마다 매우 작은 거리인 $\varepsilon$ 내에 몇개의 다른 데이터가 함께 있는지 셉니다. 이 지역을 데이터의 핵심 샘플($\varepsilon$-neighborhood)라고 부릅니다. (입실론은 보통 매우 작은 수를 말하므로 neighborhood라는건 데이터들끼리 매우 가까이 있다는 뜻입니다.)
(자기 자신을 포함해) 핵심 샘플 내에 적어도 min_samples개 데이터가 있다면 neighborhood라 칭하는 이 밀집된 지역을 Core-instance로 간주합니다.
이렇게 전체 데이터셋에 핵심 샘플들을 파악했으면, 이젠 데이터가 아닌 핵심 샘플끼리 $varepsilon$ 내에 위치한다면 서로 이웃으로 판단하여 하나의 클러스터를 형성합니다.
이렇게 데이터가 모여 핵심 샘플이 되고, 핵심 샘플이 모여 하나의 클러스터를 형성합니다. 그런데 핵심 샘플에도, neighborhood도 아닌 데이터는 이상치(Anomally data)로 판단합니다.

이 알고리즘은 각 클러스터가 충분히 밀집되어 있고, 이것이 밀집되어있지 않은 지역과 잘 구분될 때 사용하면 좋습니다. 다음은 반달 모양 데이터셋에 sklearn의 DBSCAN을 적용한 코드입니다.

from sklearn.datasets import make_moons
from sklearn.cluster import DBSCAN

X, y = make_moons(n_samples=1000, noise=0.05, random_state=42)
dbscan = DBSCAN(eps=0.05, min_samples=5)
dbscan.fit(X)

모든 데이터의 레이블은 labels_ 변수에 저장되어 있습니다.

dbscan.labels_[:10]
>>
array([ 0,  2, -1, -1,  1,  0,  0,  0,  2,  5])

데이터의 레이블이 $-1$이란 것은 이상치라는 뜻입니다. 핵심 샘플의 인덱스는 core_sample_indices에서 확인할 수 있으며, 핵심 샘플 자체는 components_에 저장되어 있습니다.

len(dbscan.core_sample_indices_)
>> 
808

dbscan.core_sample_indices_[:10]
>>
array([ 0,  4,  5,  6,  7,  8, 10, 11, 12, 13])

dbscan.components_[:3]
>>
array([[-0.02137124,  0.40618608],
       [-0.84192557,  0.53058695],
       [ 0.58930337, -0.32137599]])

다음 클러스터링 결과입니다. 왼쪽의 경우 클러스터를 7개 만들었고, 많은 데이터를 이상치로 판단했습니다. $X$는 이상치를 의미하는데 상당히 많습니다. 그러나 eps = 0.2로 설정하여 데이터의 neighborhood 범위를 넓히면 오른쪽처럼 완벽한 클러스터링을 얻습니다.

한 가지 유의할 점이 있습니다. DBSCAN 클래스는 predict() 메서드가 아닌 fit_predict() 메서드를 제공합니다. 즉 이 알고리즘은 새로운 데이터에 대한 클러스터를 예측할 수 없습니다. 이러한 일은 다른 알고리즘이 더 잘 수행할 수 있기 때문입니다. 그러므로 별도의 예측기를 정의해야합니다. 여기선 KNeiborsClassifier를 사용합니다.

from sklearn.neighbors import KNeighborsClassifier


knn = KNeighborsClassifier(n_neighbors=50)
knn.fit(dbscan.components_, dbscan.labels_[dbscan.core_sample_indices_])

이제 데이터 몇개를 전달하여 어떤 클러스터에 속할 가능성이 높은지 예측하고 각 클러스터에 대한 확률을 추정해보겠습니다.

X_new = np.array([[-0.5, 0], [0, 0.5], [1, -0.1], [2, 1]])
knn.predict(X_new)
>>
array([1, 0, 1, 0])

knn.predict_proba(X_new)
>>
array([[0.18, 0.82],
       [1.  , 0.  ],
       [0.12, 0.88],
       [1.  , 0.  ]])

위 Classifier는 핵심 샘플만 훈련했지만, 모든 데이터 혹은 이상치를 제외한 데이터만을 훈련시킬 수도 있습니다. 다음은 이상치를 제외한 데이터를 훈련시켜 만든 결정 경계입니다.

이상치가 없기 때문에 Classifier는 무조건 하나의 클러스터를 선택합니다. knn.kneighbors() 메서드에 데이터를 전달하면 가장 가까운 k개 이웃의 거리와 인덱스를 반환합니다.

y_dist, y_pred_idx = knn.kneighbors(X_new, n_neighbors=1)
y_pred = dbscan.labels_[dbscan.core_sample_indices_][y_pred_idx]
y_pred[y_dist > 0.2] = -1
y_pred.ravel()
>>
array([-1,  0,  1, -1])

DBSCAN은 매우 간단하고 강력합니다. 또한 클러스터의 모양이나 개수에 상관없이 감지할 수 있는 능력이 있으며 이상치에 안정적이고 하이퍼파라미터도 적습니다.

그러나 클러스터 간 밀집도가 크게 다르면 모든 클러스터를 올바르게 잡아내는 것이 불가능합니다.

다음 시간에는 이어서 Gaussian mixture model에 대해서 알아보겠습니다. 긴 글 읽어주셔서 감사합니다. 행복한 하루 보내세요 :)

[ 핸즈 온 머신러닝 2 ] 차원 축소란? (Dimension Reduction)

Box형 — Sat, 6 Feb 2021 02:56:22 +0900

사람은 어려움 속에서 성장한다

- 제임스 캐시 페니 (J.C 페니 백화점 창립자) -

시작하며

특성(feature)은 얼핏 보면 데이터의 다양한 측면을 보여주기 때문에 많을 수록 좋은 것 같습니다. 실제로 우리가 마주하는 머신러닝 문제에서는 Training set의 feature가 수백만 개까지 가지고 있는 경우가 있습니다.

그러나 이런 많은 특성은 훈련을 느리게 하기도 하고, 때론 좋은 솔루션을 찾는데 방해하기도 합니다. 우리는 이를 차원의 저주(curse of dimensionality)라고 합니다.

8.1 차원의 저주

우리가 살고 있는 세계는 3차원으로, 4차원 이상으로만 가도 직관적으로 상상하기 어렵습니다. 게다가 고차원 공간에선 우리의 상식과 다르게 작동하는 것들이 많습니다.

예를 들어 1*1 사각형(2차원)이 있을 때, 이 안에 있는 임의의 점을 선택할 건데 이 점이 사각형의 경계선과 0.001 이내로 가까울 확률은 0.4%밖에 되지 않습니다.

그런데 만약에 10000차원의 단위 면적을 가지는 초입방체에서는 이러한 가능성이 99.99999%로 커집니다. 간단하게 생각해보면 차원이 하나 늘어날 때마다 뭔가 경계선들이 늘어나니까 10000차원으로 가면 경계선들이 엄청나게 많기 때문에 어떤 점을 선택하든 경계선과 매우 가까울 확률이 높은 것입니다.

또 다른 예시로 2차원 단위 면적에서 임의의 두 점을 선택했을 때 두 점 사이의 거리는 평균적으로 0.52인데, 1000000차원에서는 이것이 408.25까지 늘어납니다. 고차원은 훨씬 더 많은 공간을 가지고 있기 때문에 그럴거라는 짐작은 들지만 역시나 직관적이진 않습니다.

어쨌든 이로 인해 고차원의 데이터셋은 보통 데이터들끼리 멀리 떨어져 가능성이 높다는 걸 유추해볼 수 있습니다. 이러한 경우 예측을 위한 훨씬 더 많은 외삽(extrapolation : 관찰이 어려운 데이터에 대해 추측하는 것)을 요구하기 때문에 불안정해집니다. 우리는 보통 이것을 고차원일수록 Overfitting 위험이 크다고 합니다.

이를 해결하기 위한 이론적인 해결법은 고차원에서도 데이터 끼리의 거리가 가까울 수 있도록 즉 밀도가 높아질 때까지 dataset의 크기를 키우는 것입니다. 그러나 일정한 밀도에 도달하기까지 필요한 데이터 수는 차원 수가 커짐에 따라 기하급수적으로 늘어나기 때문에 현실적으로 어렵습니다.

8.2 차원 축소를 위한 접근 방법

Dimension Reduction 알고리즘을 이해하기 위해서는 투영(projection)과 매니폴드 학습 두가지 접근법을 이해해야 합니다.

8.2.1 투영

대부분 우리가 마주할 dataset은 모든 차원에 대해 균일하게 퍼져있지 않습니다. 즉 많은 feature들 중 특정 feature들끼리 강한 연관을 가지는 경우가 많습니다. 즉 모든 data들이 고차원 공간 안에서(많은 feature들이 있지만) 저차원 subspace에 놓여있습니다(특정 feature들끼리 강한 연관을 가지는 경우가 많다).

예를 들어 위와같은 3차원 데이터셋을 살펴보겠습니다. 보시다시피 모든 data들이 거의 평면 형태로 놓여있는데 이것이 바로 3차원 공간에 있는 저차원(2차원) subspace입니다.

여기서 모든 data를 2차원 subspace에 투영하면 다음과 같은 2차원 데이터셋을 얻었는데, 이것으로 우린 데이터셋의 차원을 3에서 2차원으로 줄였다고 할 수 있습니다. 그리고 이에 따라 데이터는 새로운 feature인 $z_1$과 $z_2$에 대응됩니다.

그러나 다음 그림에서 표현된 스위스 롤 데이터셋에선 투영이 그다지 좋은 방법은 아닙니다.

만약 이것을 feature $x_3$를 버리고 평면에 투영시키면, 다음 그림의 왼쪽처럼 스위스 롤의 층이 뭉개집니다. 우리가 원하는 것은 오른쪽처럼 스위스 롤을 펼친 형태의 2차원 데이터를 얻고싶은데 말이죠.

8.2.2 매니폴드 학습

스위스 롤은 2D 매니폴드의 한 가지 예시였습니다. 즉 스위스 롤을 펴게 되면 평면이기 때문에 3차원에서 휘어지고 뒤틀려있는 스위스 롤은 2D 매니폴드로 보는 것이죠.

예를 들어 위 데이터 공간에 개미가 한마리 산다고 하겠습니다. 우리는 이 롤을 그래프 밖에서 보기때문에 점과 점사이 거리를 구할 때 유클리디안 방식으로 구하게 됩니다. 그러나 개미 입장에선 점프할 수 없기 때문에 롤을 따라 바깥으로 도달하여 점과 점 사이의 거리를 구하게 됩니다.

이를 일반화하면 d차원 매니폴드는 개미 입장에서 d차원 초평면으로 보일 수 있는 n차원 공간의 일부입니다. ($d < n$)

많은 차원 축소 알고리즘은 이러한 꼬여있는 매니폴드를 풀어헤친 형태를 모델링하는 식으로 작동하는데, 이를 매니폴드 학습(manifold learning)이라고 합니다.

매니폴드 학습이 많이 활용되는 가장 큰 이유는 Classification이나 Regression같은 작업 시 저차원 매니폴드 형태로 데이터를 표현하면 훨씬 더 간단해질거라고 가정하기 때문입니다. 그러나 다음 그림을 보면 매번 간단해지는 것은 아니라는 걸 알 수 있습니다.

8.3 PCA

주성분 분석(PCA)는 가장 보편적인 차원 축소 알고리즘 중 하나인데, 데이터의 분포를 최대한 유지하려 하면서 저차원에 투영시킵니다.

8.3.1 분산 보존

저차원의 초평면에 dataset을 투영시키기 위해 가장 중요한 것은 데이터 분포를 유지하는 것 즉 분산을 보존해야합니다. 예를 들어 다음 그래프는 2차원 데이터셋을 1차원 축에 투영한 결과입니다. 딱 봐도 첫번재 실선이 분산을 가장 잘 보존하고, 세번째 점선이 분산을 매우 적게 보존한다는 걸 알 수 있습니다.

분산이 최대로 보존되는 1차원 축을 선택해야 정보가 가장 적게 손실되기 때문에 합리적인건 당연한데, 이를 다르게 말하면 투영 되기 전 데이터와 투영된 데이터 간 평균 제곱 거리를 최소화하는 축을 선택해야한다는 말과 동일합니다.

8.3.2 주성분

앞으로 남은 PCA에 대해 구체적으로 설명하기 전에 결론적으로 PCA가 하는 작업에 대해 설명 드리겠습니다.

주어진 원본 데이터에 대해서 분산을 가장 많이 보존하는 축부터 찾으면서 임의의 n개의 축을 찾습니다.
내가 투영할 저차원이 d차원이라면 분산을 가장 많이 보존하는 축부터 d개의 축을 선택한 후 이 축들로 이뤄진 d차원 공간에 원본 데이터를 투영시키면 끝입니다.

만약 그림을 통해 이 과정을 쉽게 이해하고 싶다면 다음 포스팅을 참고해주세요.

[AI/Coursera ( Machine Learning )] - [머신러닝 순한맛] PCA(Principal Component Analysis) 알고리즘이란?

[머신러닝 순한맛] PCA(Principal Component Analysis) 알고리즘이란?

″성공의 핵심 요소는 인내심이다.” -Bill Gates- 시작하며 우리 저번 포스팅에서 Data Compression 또는 Dimentianality Reduction의 기본적인 원리를 알아보았습니다. 이번 시간에는 이러한 원리를 바탕으

box-world.tistory.com

다시 돌아와서 방금 PCA는 분산을 가장 많이 보존하는 축부터 n개의 축을 찾는다고 했는데, 이때 이 축들을 주성분(PC : principal componet)라고 부릅니다.

앞에서 본 예시에선 첫번째 실선이 첫번째 PC이고, 두번째 선이 두번째 PC가 됩니다. 그리고 이 두 PC가 만들어낸 평면과 수직한 축이 세번째 PC가 됩니다.

그러면 이렇게 PC는 어떻게 찾을까요? 우리는 SVD(singular value decomposition)이라는 표준 행렬 분해 기술을 이용합니다. 쉽게 말해서 이것은 행렬 A를 다음과 같이 분해할 수 있는데 이때 분해된 $V^T$를 전치시켜 $V$를 구하면 여기에 우리가 찾고자하는 모든 PC의 단위 벡터가 담겨있습니다.

8.3.3 d차원으로 투영하기

PC를 모두 추출했다면, 이제 처음 d개의 PC로 정의한 초평면에 투영하여 데이터셋의 차원을 d차원으로 축소해야합니다. 이때의 초평면은 데이터의 분산을 최대한 보존하게 투영시킴을 보장합니다.

예를 들어 앞서 봤던 다음 그림은 데이터의 분포를 잘 유지하면서 투영된 결과입니다.

이렇게 d차원으로 축소된 데이터셋 $X^{d-proj}$을 얻고 싶다면 다음 식과 같이 기존 데이터로 이뤄진 행렬 $X$와 분산을 가장 높게 보존하는 d개의 PC의 단위벡터를 가지는 $W_d$를 행렬곱하여 얻을 수 있습니다.

다음은 sklearn에서 PCA를 적용하여 데이터셋을 2차원으로 줄이는 코드입니다.

from sklearn.decomposition import PCA

pca = PCA(n_components = 2)
X2D = pca.fit_transform(X)

8.3.5 expained_variance_ratio_ 변수

expained_variance_ratio_ 변수에는 원본 데이터셋에 대해 PC가 보존하는 분산의 비율이 들어있습니다. 다음은 가장 높게 보존하는 순으로 두가지 PC의 expained_variance_ratio_ 를 살펴보는 코드입니다.

pca.explained_variance_ratio_

>>
array([0.84248607, 0.14631839])

이것은 데이터셋 분산의 84.2%가 첫번째 PC에 놓이고, 14.6%의 데이터가 두 번째 PC를 따라 놓임을 의미합니다. $100 - (84.2 + 14.6) = 1.2$이므로 3번째 PC부터는 데이터셋 분산의 1.2% 미만의 데이터가 놓일 것입니다.

8.3.6 적절한 차원 수 선택하기

축소할 차원 수는 임의로 정하기 보다는 각 PC별로 표현하는 데이터 분산의 합이 충분할 때까지(ex. 95% 이상) 필요한 PC의 개수로 차원 수를 선택하는 것이 좋습니다. 물론 데이터 시각화를 위해 차원을 축소하는 경우는 보통 2, 3차원을 씁니다.

다음 코드에선 PCA를 계산한 후 원본 데이터셋의 분산을 95%로 유지하는데 필요한 최소한의 PC 개수 즉 차원 수를 계산합니다.

pca = PCA()
pca.fit(X_train)
cumsum = np.cumsum(pca.explained_variance_ratio_)
d = np.argmax(cumsum >= 0.95) + 1

그 후 n_components를 설정하여 PCA를 다시 실행하는 인자로 보존할 분산의 비율을 넣어주면 됩니다.

pca = PCA(n_components=0.95)
X_reduced = pca.fit_transform(X_train)

두 번째 방법은 보존되는 분산의 비율을 차원 수에 대한 함수로 그리는 것입니다. 이 그래프에는 보존되는 분산의 비율이 빠르게 성장하다 멈추는 변곡점이 있는데, 이걸로 축소할 차원 수를 결정할 수 있습니다.

8.3.7 압축을 위한 PCA

앞서 봤듯이 차원 축소는 dataset의 크기를 줄입니다. 이러한 압축은 SVM과 같은 Classification 알고리즘의 속도를 크게 높입니다.

반대로 압축된 데이터셋에 PCA 투영의 변환을 반대로 적용하여 다시 원래의 차원으로 되돌릴 수 있습니다. 다만 축소에서 일부 정보를 잃어버렸기 때문에 완벽한 원본 데이터셋을 얻을 순 없지만 매우 비슷합니다.

원본 데이터와 축소 후 다시 복원된 데이터 사이의 평균 제곱 거리를 재구성 오차(reconstruction error)라고 합니다. 다음은 차원 축소 후 다시 복원하는 코드입니다.

pca = PCA(n_components = 154)
X_reduced = pca.fit_transform(X_train)
X_recovered = pca.inverse_transform(X_reduced)

다음은 MNIST 데이터셋에 대하여 원본 데이터셋과 압축 후 복원된 결과를 비교한 그림입니다. 이미지의 품질이 손상되긴 했지만 숫자의 모양은 온전한 것을 확인할 수 있습니다.

데이터를 복원하는 공식은 다음과 같습니다.

8.3.8 랜덤 PCA

svd_solver = "randomized"로 지정하면 sklearn은 랜덤 PCA라는 확률적 알고리즘을 이용하여 축소할 d차원에 대한 d개의 PC를 '근삿값'으로 빠르게 찾습니다.

rnd_pca = PCA(n_components=154, svd_solver="randomized", random_state=42)
X_reduced = rnd_pca.fit_transform(X_train)

svd_solver의 기본값은 "auto"인데, 원본 데이터의 크기나 차원 수가 500보다 크고, 축소할 차원이 이것들의 80%보다 작으면 sklearn은 자동으로 랜덤 PCA 알고리즘을 사용합니다. 만약 이것을 방지하고 싶다면 "full"을 사용하면 됩니다.

8.3.9 점진적 PCA

PCA 구현의 문제는 SVD 알고리즘 실행을 위해 전체 데이터셋을 메모리에 올려야 한다는 점입니다. 점진적 PCA(IPCA : incremental PCA)는 dataset을 mini-batch로 나눈 뒤 하나 씩 주입하여 적용하여 이를 보완합니다.

다음 코드는 MNIST 데이터셋을 100개의 mini-batch로 나눠 차원을 축소하는 코드입니다.

from sklearn.decomposition import IncrementalPCA

n_batches = 100
inc_pca = IncrementalPCA(n_components=154)
for X_batch in np.array_split(X_train, n_batches):
    print(".", end="") # 책에는 없음
    inc_pca.partial_fit(X_batch)

X_reduced = inc_pca.transform(X_train)

8.4 커널 PCA

이전 포스팅에서 고차원 공간을 암묵적으로 매핑하여 SVM의 Classification과 Regression을 가능하게 하는 수학적 기법인 커널 트릭에 대해 이야기했습니다.

[AI/Hands-On Machine Learning 2판] - [ 핸즈온 머신러닝 2판 ] SVM이란?

[ 핸즈온 머신러닝 2판 ] SVM이란?

인내는 어떤 실력보다 강하다 - 벤 호건 (프로 골퍼) - 시작하며 SVM은 Classification, Regression 등 다양한 곳에서 활용됩니다. 특히 복잡한 데이터셋을 학습하기에 용이하다는 점도 SVM의 인기를 높이

box-world.tistory.com

우리는 같은 기법을 PCA에 적용하여 차원 축소를 위한 복잡한 비선형 투영을 할 수 있고 이를 커널 PCA(kPCA)라고 부릅니다.

from sklearn.decomposition import KernelPCA

rbf_pca = KernelPCA(n_components = 2, kernel="rbf", gamma=0.04)
X_reduced = rbf_pca.fit_transform(X)

다음은 서로 다른 커널을 사용하여 2차원으로 축소시킨 스위스 롤의 모습입니다.

8.4.1 커널 선택과 하이퍼파라미터 튜닝

kPCA는 Unsupervised Learning이므로 어떤 커널과 하이퍼파라미터를 선택해야 좋은 성능을 내는지 명확하게 알 수 있는 기준이 없습니다. 그러나 그리드 탐색을 이용하면 이를 보완할 수 있습니다.

다음 코드에서는 kPCA를 이용하여 2차원으로 축소하고 Logistic Regression으로 Classification을 진행합니다. 그 다음 가장 높은 accuracy를 얻기 위해 GridSearchCV를사용하여 kPCA에 가장 좋은 커널과 gamma 파라미터를 사용합니다.

from sklearn.model_selection import GridSearchCV
from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import Pipeline

clf = Pipeline([
        ("kpca", KernelPCA(n_components=2)),
        ("log_reg", LogisticRegression(solver="lbfgs"))
    ])

param_grid = [{
        "kpca__gamma": np.linspace(0.03, 0.05, 10),
        "kpca__kernel": ["rbf", "sigmoid"]
    }]

grid_search = GridSearchCV(clf, param_grid, cv=3)
grid_search.fit(X, y)

그리고 이러한 커널과 파라미터는 다음과 같이 확인합니다.

print(grid_search.best_params_)

>>
{'kpca__gamma': 0.043333333333333335, 'kpca__kernel': 'rbf'}

완전한 Unsupervised learning으로 가장 낮은 재구성 오차를 만드는 커널과 하이퍼파라미터를 선택하는 방법도 있습니다.

다만 재구성은 선형 PCA만큼 쉽지 않습니다. 다행히 커널 트릭을 이용하면 이러한 문제를 해결할 수 있습니다.

차원 축소된 데이터를 다시 복원하면 이때의 데이터는 원래 차원의 공간이 아닌 위 그림에서 x로 표시된 feature space에 놓이게 됩니다. 이것은 무한 차원이기 때문에 재구성 오차 등의 계산이 불가능합니다. 다행히도 재구성된 데이터의 위치와 가깝게 매핑된 원본 공간의 위치는 찾을 수 있는데 이를 재구성 원상(pre-image)라고 합니다.

원상을 얻으면 원본 데이터와의 제곱 거리를 측정하여 오차를 구할 수 있게 되고 이에 따른 최적의 커널과 하이퍼파라미터를 찾는 것도 가능해집니다.

이쯤되면 재구성을 어떻게 하는지 궁금해지는데요. 한 가지 방법은 축소된 데이터를 훈련 세트로, 원본 데이터를 타깃으로 하여 Supervised learning model training을 진행하는 것입니다. sklearn에서는 fit_inverse_transform = True로 지정하면 이를 자동으로 수행합니다.

rbf_pca = KernelPCA(n_components = 2, kernel="rbf", gamma=0.0433,
                    fit_inverse_transform=True)
X_reduced = rbf_pca.fit_transform(X)
X_preimage = rbf_pca.inverse_transform(X_reduced)

그 후 다음과 같이 pre-image error를 계산할 수 있습니다.

from sklearn.metrics import mean_squared_error

mean_squared_error(X, X_preimage)

8.5 LLE

지역 선형 임베딩이라 부르는 LLE(locally linear embedding)는 강력한 non-linear dimensionally reduction 기술로 투영이 아닌 매니폴드 학습입니다.

LLE는 각 data가 가장 가까운 이웃에 얼마나 선형적으로 연관되어 있는지 측정합니다. 그 후 앞서 언급한 개미의 시선으로 바라본 매니폴드가 가장 잘 보존될 원본 데이터의 저차원 표현을 찾습니다. 이 방법은 Noise가 많지 않다면, 꼬인 매니폴드를 펼치는데 잘 작동합니다.

from sklearn.manifold import LocallyLinearEmbedding

lle = LocallyLinearEmbedding(n_components=2, n_neighbors=10, random_state=42)
X_reduced = lle.fit_transform(X)

결과는 다음 그림에서 볼 수 있습니다. 보다시피 스위스 롤이 잘 펴졌고, 샘플 간 거리도 잘 보존되어있는 듯 하지만, 거시적으로 보면 샘플 간 거리가 잘 유지도히지 않습니다. 그렇지만 LLE는 매니폴드를 펼치는데 잘 동작합니다.

8.6 기타 차원 축소 알고리즘

1) 랜덤 투영

말 그대로 linear한 투영을 랜덤하게 하여 데이터를 저차원으로 투영합니다. 놀랍게도 이러한 랜덤 투영이 실제 거리를 잘 보존한다는 것이 수학적으로 증명되었습니다.

2) 다차원 스케일링(MDS)

데이터 간 거리를 보존하면서, 차원을 축소합니다.

3) lsomap

각 데이터를 가장 가까운 이웃과 연결하는 식으로 그래프를 만듭니다. 그 후 데이터 간 geodesic distance를 유지하면 차원을 축소합니다.

4) t-SNE

비슷한 데이터는 가까이, 그렇지 않다면 멀리 떨어지도록 하여 차원을 축소합니다. 주로 고차원 데이터를 시각화할 때 많이 쓰입니다. (ex. MNIST )

5) 선형 판별 분석(LDA)

사실 분류 알고리즘입니다. 이것은 학습 시 클래스들을 가장 잘 구분하는 축을 학습하여 이 축으로 데이터가 투영되는 초평면을 정의하는데 사용합니다. 이것의 장점은 투영을 통해 가능한 한 클래스를 멀리 떨어지게 유지 시키므로 SVM과 같은 알고리즘을 적용하기 전 차원을 축소하는데 용이합니다.

다음 포스팅에서는 Unsupervised Learning에 대해 다뤄보겠습니다. 긴 글 읽어주셔서 감사합니다. 행복한 하루 보내세요 :)

[ 핸즈 온 머신러닝 2 ] 앙상블 학습과 랜덤 포레스트란?

Box형 — Thu, 4 Feb 2021 01:10:24 +0900

매일 아침 삶의 목표를 생각하며 일어나라

- 아이제이아 토마스 (NBA 아이닉스 사장 겸 감독) -

시작하며

굉장히 복잡한 질문에 대해서 수천명의 사람들에게 대답을 모으는 것과 전문가에게 답을 듣는 것, 둘 중 어떤 것이 더 정확할까요? 대부분 전자가 더 정확하며 우리는 이를 대중의 지혜라고 합니다.

마찬가지로 머신러닝에서도 적당한 성능의 모델 여러개들로부터 예측을 수집하는 것이 가장 좋은 하나의 모델의 예측보다 더 좋은 결과를 불러옵니다.

우리는 이러한 학습 방법을 앙상블 학습(Ensemble Learning)이라고 합니다.

이번 포스팅은 Decision Tree의 이해가 바탕이 되어야 합니다. 다음 포스팅을 참고해주세요!

[AI/Hands-On Machine Learning 2판] - [ 핸즈온 머신러닝 2 ] Decision Tree란?

[ 핸즈온 머신러닝 2 ] Decision Tree란?

성공하려면 이미 했던 일을 제대로 활용하라 - 블레이크 로스 (파이어폭스 공동 개발자) - 시작하며 저번 포스팅에서는 SVM에 대해 다뤄보았습니다. 이번 포스팅에서 다룰 Decision Tree은 SVM처럼 Cl

box-world.tistory.com

7.1 투표 기반 Classifier

여기 Logistic Regression, SVM, Random Forest 등 정확도가 80%인 여러개의 Classifier가 있습니다.

그리고 앙상블 학습에서는 각 Classifier의 예측을 모아서 가장 많이 선택된 클래스를 예측합니다. 이렇게 다수결 투표로 정해지는 Classifier를 직접 투표(hard vote) 분류기라고 합니다.

주목할 점은 이 다수결 투표 Classifier가 앙상블에 포함된 각각의 Classifier들 중 가장 뛰어난 Classifier보다도 정확도가 높은 경우가 많다는 것입니다. 즉 각 Classifier의 성능은 약할지언정, 개수가 충분히 많은 앙상블이라면 성능이 높을 수 있습니다.

이것이 가능한 이유는 바로 큰수의 법칙 때문입니다. 예를 들어 앞면이 51%, 뒷면이 49%가 나오는 불균형한 동전이 있다고 가정하겠습니다.

만약 동전을 1000번 던지면 510번은 앞면, 490번은 뒷면이 나올 것인데, 이를 수학적으로 계산하면 1000번을 던질 때 앞면이 다수일 확률은 75%에 가깝다는 것을 확인할 수 있습니다. 게다가 더 많이 던질 수록 앞면이 나올 확률은 증가합니다.(10000번일 경우 97% 이상으로 올라갑니다.)

이와 비슷하게 51% 정확도를 가진 1000개의 분류기로 앙상블을 구축한고, 여기에서 가장 많이 나온 클래스를 예측으로 삼는다면 75%의 정확도를 기대할 수 있습니다. 물론 이러한 가정은 모든 Classifier가 완벽하게 독립적이고, 오차에 상관관계가 없어야 가능합니다.

앙상블 학습은 Classifier가 가능한 서로 독립적일 때 최고의 성능을 발휘합니다. 이를 위해 가장 좋은 방법은 각 Classifier를 서로 다른 알고리즘으로 학습하는 것입니다.

다음은 moons 데이터셋에 대해서 여러 Classifier를 조합한 투표 기반 분류기 VotinClassifier에 대한 코드입니다.

from sklearn.ensemble import RandomForestClassifier
from sklearn.ensemble import VotingClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC

log_clf = LogisticRegression(random_state=42)
rnd_clf = RandomForestClassifier(random_state=42)
svm_clf = SVC(random_state=42)

voting_clf = VotingClassifier(
    estimators=[('lr', log_clf), ('rf', rnd_clf), ('svc', svm_clf)],
    voting='hard')
voting_clf.fit(X_train, y_train)

앙상블 내 들어있는 Classifier의 Testset 정확도를 확인해보겠습니다. 예상대로 VotingClassifier가 개별 Classifier보다 성능이 높은걸 확인할 수 있습니다.

from sklearn.metrics import accuracy_score

for clf in (log_clf, rnd_clf, svm_clf, voting_clf):
    clf.fit(X_train, y_train)
    y_pred = clf.predict(X_test)
    print(clf.__class__.__name__, accuracy_score(y_test, y_pred))
    
>>
LogisticRegression 0.864
RandomForestClassifier 0.872
SVC 0.888
VotingClassifier 0.896

앙상블 내 모든 Classifier가 클래스의 확률을 예측할 수 있다면(predict_proba() 메서드가 있다면), 개별 Classifier의 예측을 평균 내어 확률이 가장 높은 클래스를 예측할 수 있는데, 이를 간접 투표(soft voting)이라고 합니다.

이 방식은 확률 기반이므로 직접 투표(hard voting) 방식보다 성능이 높습니다. 간접 투표 방식을 사용하기 위해선 voting="hard"를 "soft"로 바꿔주면 됩니다.

SVC(SVM Classifier)에서는 클래스 확률을 제공하지 않으므로 probability 매개변수를 True로 지정하면 됩니다.

7.2 Bagging과 Pasting

다양한 Classifier를 만드는 한 가지 방법은 각기 다른 Training 알고리즘을 사용하는 것이고, 다른 하나는 같은 알고리즘을 사용하되 Training datset의 subset을 무작위로 구성하여 Classifier마다 다른 데이터로 학습 시키는 것입니다.

이때 Training dataset에서 중복을 허용하여 subset을 나눠 학습하는 것을 배깅(Bagging), 중복을 허용하지 않는 것을 페이스팅(Pasting)이라고 합니다.

다시 말해서 하나의 Training data가 하나의 Classifier를 위해 여러 번 학습에 사용될 수 있는건 Bagging뿐입니다.

Classifier와 같은 모든 예측기가 학습을 마치면, 앙상블은 이들의 예측을 모아 새로운 data에 대한 예측을 만듭니다. 이때 최종 예측을 하는 수집함수는 Classification일 땐, Hard Voting Classifier처럼 가장 많은 예측 결과를 따르고, Regression에 대해선 평균을 계산합니다.

원본 데이터 전체이 아닌, subset을 학습한 개별 Classifier는 크게 편향이 되어있지만(Underfit), 수집 함수를 통과하면 편향과 분산이 모두 감소합니다.

그리고 앙상블의 결과는 원본 데이터로 하나의 예측기를 훈련시킬 때보다, 편향은 비슷하지만 분산은 줄어듭니다(Overfitting이 덜 된다).

7.2.1 sklearn의 Bagging과 Pasting

sklearn에서는 Bagging과 Pasting을 위해 BaggingClassifier(회귀의 경우 BaggingRegressor)를 제공합니다. 다음은 Decision Tree 500개로 구성로 구성된 앙상블을 훈련시키는 코드입니다. 각 Classifier는 Bagging으로 훈련됩니다.

Pasting을 사용하려면 bootstrap = False로 지정합니다.
n_jobs는 sklearn에서 훈련과 예측에 사용할 CPU 코어 수를 지정하는데, -1로 설정 시 가용한 모든 코어를 사용합니다.
BaggingClassifier는 앙상블에 사용되는 Classifier가 Decision Tree처럼 클래스 확률을 추정할 수 있다면, Soft Voting 방식을 사용합니다.

from sklearn.ensemble import BaggingClassifier
from sklearn.tree import DecisionTreeClassifier

bag_clf = BaggingClassifier(
    DecisionTreeClassifier(random_state=42), n_estimators=500,
    max_samples=100, bootstrap=True, n_jobs=-1, random_state=42)
bag_clf.fit(X_train, y_train)
y_pred = bag_clf.predict(X_test)

다음은 하나의 Decision Tree의 결정 경계와 앞서 본 코드로 학습한 Bagging 앙상블의 결정 경계를 비교한 것입니다. Training set의 오차 수는 서로 비슷할지 모르나, 경계가 덜 불규칙한 앙상블의 예측이 훨씬 더 일반화를 잘할 것이라고 생각할 수 있습니다.

Bootstrapping 즉 Bagging을 중복을 허용하는 특성 상 subset에 다양성을 증가시키므로 편향이 좀 더 높습니다.(More Underfitting) 그러나 다양성을 추가한다는 것은 예측기 간 상관관계를 줄이므로 앙상블의 분산을 감소시킵니다.(Less Overfitting)

이러한 탓에 일반적으로는 Bagging을 더 많이 선호합니다. 편향, 분산 그리고 Overfit과 Underfit에 대한 개념이 궁금하신 분들은 다음 포스팅을 참고해주세요.

[AI/Coursera ( Machine Learning )] - [머신러닝] 모델의 과적합(Overfitting)을 피하기 위한 방법

[머신러닝] 모델의 과적합(Overfitting)을 피하기 위한 방법

시작하며 우리는 지금까지 Linear Regression 그리고 Logistic Regression 두가지에 중점을 두어 Supervised Learning을 공부하였습니다. 이번 포스팅에서는 모델 학습 과정에서 발생할 수 있는 'Overfitting' 이..

box-world.tistory.com

7.2.2 oob 평가

Bagging을 사용하면 어떤 데이터는 여러 번 사용되고, 어떤 것은 전혀 선택되지 않을 수 있습니다. 앞서 사용한 BaggingClassifier는 평균적으로 각 에측기에 Training dataset의 63% 정도만 사용하는데, 이때 사용되지 않은 나머지 data를 oob(out of bag) 데이터라고 합니다.

이렇게 남겨진 oob data들은 별도의 Validation set 없이 각 예측기를 평가하는데 사용됩니다. 앙상블 자체의 평가는 각 예측기의 oob 평가를 평균하여 얻습니다.

sklearn에서는 oob_score=True로 지정하면, 자동으로 oob 평가를 수행합니다.

bag_clf = BaggingClassifier(
    DecisionTreeClassifier(random_state=42), n_estimators=500,
    bootstrap=True, n_jobs=-1, oob_score=True, random_state=40)
bag_clf.fit(X_train, y_train)

print('oob score :', bag_clf.oob_score_)

>> 
oob score : 0.9013333333333333

oob 데이터 그리고 Test 데이터 이 둘은 모두 BaggingClassifier가 보지 못했던 데이터들이기 때문에 oob score와 Test set의 accuracy의 정확도는 매우 유사할 것으로 보입니다.

그리고 oob_decision_function을 이용하면, 각 Training data의 클래스 확률을 반환합니다.

bag_clf.oob_decision_function_[:5]

>>
array([[0.31746032, 0.68253968],
       [0.34117647, 0.65882353],
       [1.        , 0.        ],
       [0.        , 1.        ],
       [0.        , 1.        ]])

7.3 랜덤 패치와 랜덤 서브스페이스

BaggingClassifier에서는 각 예측기를 학습하는데 일부 데이터만 쓰는 기능도 있지만, 일부 feature만 반영시키는 기능도 지원합니다. 예를 들어 데이터가 10개의 feature를 가지고 있는데, 5개의 feature만 학습에 사용하는 방식입니다.

이러한 기법은 매우 고차원의 데이터셋을 다룰 때 유용합니다. feature와 데이터를 모두 일부만 사용하는 것을 랜덤 패치 방식(Random Patches Method)라고 합니다. 그리고 데이터는 모두 사용하고, feature만 일부를 사용하는 방식을 랜덤 서브스페이스 방식(Random Subspace Method)라고 합니다.

7.4 Random Forest

랜덤 포레스트(Random Forest)는 Bagging 혹은 Pasting을 적용한 Decision Tree의 앙상블입니다. 일부만 사용할 Training set의 크기는 max_samples로 지정합니다.

from sklearn.ensemble import RandomForestClassifier

rnd_clf = RandomForestClassifier(n_estimators=500, max_leaf_nodes=16, n_jobs=-1, random_state=42)
rnd_clf.fit(X_train, y_train)
y_pred_rf = rnd_clf.predict(X_test)

Random Forest 알고리즘은 트리의 노드를 분할할 때, 전체 feature 중 최선의 feature를 찾는 대신 무작위로 선택한 feature 후보들 중 최적의 feature를 찾음으로써 무작위성을 더 주입합니다.

이러한 무작위성은 트리를 더욱 다양하게 만들고, 이러한 다양성은 편향을 감소시키지만(More Underfitting), 분산을 낮추어(Less Overfitting) 더 훌륭한 모델을 만들어냅니다. 다음은 BaggingClassifier로 RandomForestClassifier와 거의 유사하게 만든 것입니다.

bag_clf = BaggingClassifier(
    DecisionTreeClassifier(splitter="random", max_leaf_nodes=16, random_state=42),
    n_estimators=500, max_samples=1.0, bootstrap=True, n_jobs=-1, random_state=42)
bag_clf.fit(X_train, y_train)
y_pred = bag_clf.predict(X_test)

7.4.1 엑스트라 트리

앞서 본 Random Forest는 각 노드의 분할을 위해 feature의 subset을 사용했습니다. 트리를 더욱 무작위하게 만들기 위해 최적의 임곗값 $t_k$를 찾는 대신 feature의 subset을 사용해 무작위로 분할 후 그중 최상의 분할을 선택합니다.

이렇게 극단적으로 무작위한 Random Forest를 Extreme random Tree 앙상블 혹은 Extra tree라고 부릅니다. 이 역시 무작위성은 다양성을 늘려 편향을 늘리는 대신 분산을 줄이게 됩니다.

기존엔 노드 분할 시 최적의 임곗값을 찾는 것이 트리 알고리즘에서 가장 많이 시간을 잡아먹는 부분이었는데 이것이 없어졌으므로 일반적인 Random Forest보다 Extra Tree가 훨씬 빠릅니다.

sklearn에서는 ExtraTreesClassifier를 사용해 이를 구현할 수 있으며 기타 메서드나 파라미터는 동일합니다.

7.4.2 특성 중요도

Random forest의 또 다른 장점은 어떤 feature가 예측에 중요한 비중을 차지하는지 상대적인 중요도를 측정하기 쉽다는 것입니다.

sklearn에서는 어떤 feature를 사용한 노드가 gini(불순도)를 감소시키는지 확인하여 feature의 중요도를 측정합니다. 더 정확히는 가중치의 평균이며 각 노드의 가중치는 연관된 Training data 수와 같습니다.

훈련이 끝난 뒤 feature마다 자동으로 이 점수를 계산하고 중요도의 전체 합이 1이 되도록 결과값을 정규화하여 이를 feature_importances_ 변수에 저장합니다.

다음은 Iris 데이터셋을 이용한 코드 적용입니다. 수치를보면 petal length와 petal width가 가장 중요한 특성들이라는 걸 알 수 있습니다.

from sklearn.datasets import load_iris

iris = load_iris()
rnd_clf = RandomForestClassifier(n_estimators=500, n_jobs=-1, random_state=42)
rnd_clf.fit(iris["data"], iris["target"])
for name, score in zip(iris["feature_names"], rnd_clf.feature_importances_):
    print(name, score)
    
 >>
sepal length (cm) 0.11249225099876374
sepal width (cm) 0.023119288282510326
petal length (cm) 0.44103046436395765
petal width (cm) 0.4233579963547681

이러한 특징은 이미지를 Classification하는데 모델이 어느 곳을 중점적으로 보는지 판단하는데 활용될 수 있습니다. 다음은 MNIST 데이터셋에서 Random Forest Classifier를 학습하고 각 픽셀의 중요도를 그래프로 나타낸 결과입니다.

7.5 Boosting

부스팅(Boosting)은 약한 학습기를 여러 개 연결하여 강한 학습기를 만드는 앙상블 방법을 말합니다. 여기에는 AdaBoost와 Gradient Boosting이 있습니다.

7.5.1 AdaBoost

AdaBoost는 이전 모델이 Underfitting했던 training data의 가중치를 더 높이며 새로운 모델을 만듭니다. 이렇게 하면 새로운 예측기는 학습하기 어려운 샘플에 점점 더 맞춰지게 됩니다.

예를 들어 AdaBoost Classifier를 만들 때 먼저 Decision tree와 같은 첫 번째 Classifier를 Training set에서 훈련시키고 예측을 만듭니다. 그 다음 알고리즘이 잘못 분류했던 Training data의 가중치를 높입니다.

이것이 반영된 두번째 Classifier에서는 업데이트된 가중치로 Training set을 학습하고 예측하고, 나머지 과정은 반복되는 식입니다.

다음은 AdaBoost방식으로 갱신되어 가는 다섯개의 연속된 예측기의 결정 경계입니다. moons 데이터셋을 사용하였고, 모델은 규제를 강하게 한 RBF 커널 SVM Classifier입니다. Classifier의 성능이 가면 갈 수록 좋아지는 것을 확인할 수 있습니다.

AdaBoost 알고리즘을 좀 더 자세히 들여다보겠습니다. 각 데이터 가중치 $w^{(i)}$는 초기에 $\cfrac{1}{m}$으로 초기화 됩니다. 이후 첫 번째 예측기가 학습되고, 가중치가 적용된 에러율 $r_1$이 계산됩니다.

두 번째 예측기의 가중치 $\alpha_j$는 다음 식으로 계산됩니다. 여기서 n처럼 생긴 저 기호는 learning rate입니다. 예측기가 정확할수록 에러율은 낮으므로 $\alpha_j$은 높아지게 되고, 성능이 매우 안좋다면 음수까지도 갈 수 있습니다.

그 다음 알고리즘은 다음 식을 사용해 잘못 예측한 경우에만 해당 데이터의 가중치를 $\alpha_j$를 이용해 갱신합니다.

그 후 모든 데이터의 가중치를 정규화하는 식으로 반복됩니다. 이 것은 정해진 예측기의 수에 도달하거나, 완벽한 예측기가 만들어지면 중지됩니다.

AdaBoost는 단순히 모든 예측기의 예측을 계산하고, 예측기 가중치 $\alpha_j$를 더해 예측 결과를 만듭니다. 그리고 가중치 합이 가장 큰 클래스가 예측 결과가 됩니다.

다음은 sklearn의 AdaBoostClassifier를 사용하여 200개의 얕은 Decision tree를 기반으로 AdaBoost Classifier를 훈련시킵니다. 이때 Decision tree의 max_depth = 1입니다.

from sklearn.ensemble import AdaBoostClassifier

ada_clf = AdaBoostClassifier(
    DecisionTreeClassifier(max_depth=1), n_estimators=200,
    algorithm="SAMME.R", learning_rate=0.5, random_state=42)
ada_clf.fit(X_train, y_train)

7.5.2 Gradient Boosting

Gradient Boosting도 이전까지의 오차를 보정한 예측기가 순차적으로 앙상블에 추가됩니다. 다만 AdaBoost처럼 데이터의 가중치를 갱신하는 대신 이전 예측기가 만든 잔여 오차(residual error)를 새로운 예측기에 학습시킵니다.

간단한 회귀 문제를 풀어보겠습니다. 이때 사용되는 모델을 Gradient tree boosting 혹은 GBRT라고 합니다. 우선 DecisionTreeRegressor에 Training set을 학습시키겠습니다.

from sklearn.tree import DecisionTreeRegressor

tree_reg1 = DecisionTreeRegressor(max_depth=2, random_state=42)
tree_reg1.fit(X, y)

이제 Residual Error를 두번째 DecisionTreeRegressor에 훈련시킵니다.

y2 = y - tree_reg1.predict(X)  # residual errors

tree_reg2 = DecisionTreeRegressor(max_depth=2, random_state=42)
tree_reg2.fit(X, y2)

이번엔 세 번째입니다.

y3 = y2 - tree_reg2.predict(X)  # residual error

tree_reg3 = DecisionTreeRegressor(max_depth=2, random_state=42)
tree_reg3.fit(X, y3)

새로운 데이터에 대한 예측은 모든 트리의 예측을 더하면 됩니다.

y_pred = sum(tree.predict(X_new) for tree in (tree_reg1, tree_reg2, tree_reg3))

다음 그림에서 왼쪽 열은 앙상블 내 세 트리의 예측이고, 오른쪽 열은 앙상블의 예측입니다.

첫번째 행은 앙상블에 하나의 트리만 있기 때문에 첫 번째 트리의 예측과 완전히 같습니다.
두번째 행의 앙상블은 첫 번째 트리의 잔여 오차를 학습하였습니다. 직관적으로 보면 앙상블의 예측이 $h_2(x_1)$와 잔여 오차를 더한 값임을 볼 수 있습니다.
트리가 앙상블에 추가될 수록 앙상블의 예측은 더욱 좋아집니다.

다음은 sklearn에서 GBRT 앙상블을 간단하게 훈련시키는 코드입니다. learning_rate 매개변수는 각 트리의 기여 정도를 조절합니다. 이것이 작을 수록 앙상블은 더욱 많은 트리를 필요로 하지만, 성능은 좋아지는데 이러한 규제 방법을 축소(shrinkage)라고 합니다.

from sklearn.ensemble import GradientBoostingRegressor

gbrt = GradientBoostingRegressor(max_depth=2, n_estimators=3, learning_rate=1, random_state=42)
gbrt.fit(X, y)

다음 그래프에서 왼쪽은 트리가 너무 적어 Underfitting된 앙상블이고, 오른쪽은 반대로 너무 많아서 Overfitting된 앙상블입니다.

다음은 최적의 트리 수를 찾기 위해 조기 종료 기법을 적용한 코드입니다.

from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error

X_train, X_val, y_train, y_val = train_test_split(X, y, random_state=49)

gbrt = GradientBoostingRegressor(max_depth=2, n_estimators=120, random_state=42)
gbrt.fit(X_train, y_train)

# 최적의 트리 개수 찾기
errors = [mean_squared_error(y_val, y_pred)
          for y_pred in gbrt.staged_predict(X_val)]
bst_n_estimators = np.argmin(errors)

# 최적의 트리개수로 그래디언트 부스팅 학습
gbrt_best = GradientBoostingRegressor(max_depth=2, n_estimators=bst_n_estimators, random_state=42)
gbrt_best.fit(X_train, y_train)

위와 같이 많은 수의 트리를 먼저 훈련시키고 최적의 수를 찾는 대신 최적의 수라고 판단 시 실제로 훈련을 중도에 중지하는 방법으로도 구현될 수 있습니다. 다음 코드는 다섯 번의 반복 동안 Validation Error가 향상되지 않으면 훈련을 종료합니다.

gbrt = GradientBoostingRegressor(max_depth=2, warm_start=True, random_state=42)

min_val_error = float("inf")
error_going_up = 0
for n_estimators in range(1, 120):
    gbrt.n_estimators = n_estimators
    gbrt.fit(X_train, y_train)
    y_pred = gbrt.predict(X_val)
    val_error = mean_squared_error(y_val, y_pred)
    if val_error < min_val_error:
        min_val_error = val_error
        error_going_up = 0
    else:
        error_going_up += 1
        if error_going_up == 5:
            break  # 조기 종료

GradientBoostingRegressor는 트리 훈련 시 사용할 Training subset의 크기를 subsample 매개변수로 지정할 수 있습니다. 이를 통해 편향은 높이고 분산은 줄일 수 있는데 이러한 기법을 확률적 그레디언트 부스팅(Stochastic gradient boosting)이라고 합니다.

최적화된 Gradient Boosting 구현으로 가장 유명한 것은 XGBoost입니다. 중요한 개념이니 꼭 한번 찾아보시길 바랍니다!!

다음 포스팅에서는 고차원 데이터셋을 다룰 때 자주 사용하는 차원 축소에 대해서 다뤄보겠습니다. 긴 글 읽어주셔서 감사합니다. 행복한 하루 보내시길 바랍니다 :)

[ 핸즈온 머신러닝 2 ] Decision Tree란?

Box형 — Tue, 2 Feb 2021 17:07:08 +0900

성공하려면 이미 했던 일을 제대로 활용하라

- 블레이크 로스 (파이어폭스 공동 개발자) -

시작하며

저번 포스팅에서는 SVM에 대해 다뤄보았습니다. 이번 포스팅에서 다룰 Decision Tree은 SVM처럼 Classification, Regression 등 폭넓게 사용이 가능하며, 복잡한 데이터셋도 학습할 수 있는 강력한 알고리즘입니다.

6.1 Decision Tree 학습과 시각화

우선 Decision Tree를 이해하기 위해 모델 하나를 생성한 후 어떻게 예측하는지 살펴보겠습니다. 데이터는 Iris(붓꽃의 종류를 클래스화한 데이터)를 사용하였습니다.

from sklearn.datasets import load_iris
from sklearn.tree import DecisionTreeClassifier

iris = load_iris()
X = iris.data[:, 2:] # 꽃잎 길이와 너비
y = iris.target

tree_clf = DecisionTreeClassifier(max_depth=2, random_state=42)
tree_clf.fit(X, y)

//output
DecisionTreeClassifier(max_depth=2, random_state=42)

export_graphviz() 함수는 Decision Tree를 시각화하여 .dot 파일의 형태로 출력합니다.

from graphviz import Source
from sklearn.tree import export_graphviz

export_graphviz(
        tree_clf,
        out_file=os.path.join(IMAGES_PATH, "iris_tree.dot"),
        feature_names=iris.feature_names[2:],
        class_names=iris.target_names,
        rounded=True,
        filled=True
    )

Source.from_file(os.path.join(IMAGES_PATH, "iris_tree.dot"))

6.2 예측하기

위 Decision Tree가 어떻게 예측을 하는지 살펴보면서 그래프를 분석해보겠습니다.

먼저 데이터가 들어오면 루트 노드(Depth = 0)를 가장 먼저 거치게 됩니다. 이 노드는 꽃잎의 길이(petal length)가 2.45cm보다 짧은지 검사합니다. 만약 그렇다면(=True)왼쪽 자식 노드(Depth = 1)로 이동합니다.

그리고 이동한 자식 노드가 리프 노드(자식 노드를 가지지 않은 노드)라면 추가적인 검사를 하지않고 해당 노드에 적힌 class인 "senota"라고 예측합니다.

이번엔 꽃잎의 길이가 2.45cm보다 긴 데이터가 들어와 루트에서 오른쪽 자식 노드로 이동했다고 가정해보겠습니다. 그러면 해당 노드는 리프 노드가 아니기 때문에 꽃잎의 길이가 1.75cm보다 작은지 검사하게 됩니다. 검사 후 데이터는 어느 리프노드로 내려가냐에 따라 "versicolor"혹은 "virginica"가 될것입니다.

NOTE_ Decision Tree의 장점 중 하나는 Data 전처리가 거의 필요하지 않다는 것입니다. 즉 feature의 Scale을 조정하구나 평균을 원점에 맞추는 작업을 요하지 않습니다.

이제 나머지 노드의 구성요소에 대해서 살펴보겠습니다.

sample 속성은 해당 노드로 얼마나 많은 데이터가 내려왔는지를 헤아린 것입니다. 예를 들어 앞서 본 Tree의 보라색 노드의 sample = 46이므로 46개의 데이터가 이 노드로 내려왔다는 것을 알 수 있습니다.

value 속성은 어떤 클래스의 데이터가 해당 노드로 내려왔는지 알려줍니다. 보라색 노드의 value = [0, 1, 45]이므로 Setosa 클래스를 가지는 데이터는 0개, Versicolor는 1개, Virginica는 45개가 해당 노드로 내려왔다고 판단하게 됩니다.

마지막으로 gini는 불순도(impurity)를 측정합니다. 보통 우리가 물에 이물질이나 흙이 많이 섞여있으면 불순도가 높다고 하는데 여기서도 비슷한 맥락을 가집니다. 예를 들어 한 노드를 지나간 데이터들이 모두 같은 클래스라면 이때의 gini = 0이라고 할 수 있습니다.

불순도를 구하는 방법에는 여러가지가 있지만 가장 보편적인 것은 '지니 불순도'입니다.

이 식을 이용하면 그래프의 초록색 노드의 불순도는 다음처럼 구할 수 있습니다.

위그림은 Decision Tree의 결정 경계를 보여줍니다. 굵은 수직선이 루트 노드의 결정 경계(꽃잎 길이 = 2.45cm)를 나타냅니다. 앞선 코드에서 max_depth를 2로 설정했었는데 만약 3으로 설정하면 점선으로 보이는 경계가 추가로 만들어집니다.

6.2 클래스 확률 추정

Decision tree는 데이터가 특정 클래스 k에 속할 확률을 추정할 수도 있습니다.

1) 데이터가 속한 리프 노드를 찾기 위해 트리를 탐색합니다.

2) 해당 노드를 지나간 데이터들 중에서 클래스 k의 비율을 반환합니다.

예를 들어 length = 5cm이고, width = 1.5cm인 꽃잎은 초록색 노드입니다. 따라서 Setosa일 확률은 0%(0/54), Versicolor는 90.7%(49/54), Virginica는 9.3%(5/54)입니다. 다음 코드에서 방금 예시로 든 데이터를 예측했을 때 Versicolor(class = 1)이 나오는 것을 확인할 수 있습니다.

tree_clf.predict_proba([[5, 1.5]])
>> array([[0.        , 0.90740741, 0.09259259]])

tree_clf.predict([[5, 1.5]])
>> array([1])

6.4 CART 훈련 알고리즘

Sklearn에서는 Decision Tree 학습을 위해 CART 알고리즘을 사용합니다. 첫번째는 Training set에서 꽃잎의 길이와 같은 하나의 feature를 고른 후, <= 2.45cm같이 노드를 가르는 임곗값 $t_k$를 사용하여 두 개의 subset으로 나눕니다.

이때의 feature는 Training set 내 클래스 비율을 고려하여 가장 순수하게 서브셋으로 나눌 수 있는 feature와 $t_k$를 찾습니다.

알고리즘이 최소화할 비용함수는 다음과 같습니다.

Training set을 성공적으로 둘로 나눈 알고리즘은 max_depth까지 도달하거나, gini(불순도)를 줄이는 분할을 찾을 수 없을 때 멈추게 됩니다.

6.5 엔드로피 불순도

sklearn에서는 criterion = "entropy"으로 지정하면 지니 불순도가 아닌 엔트로피 불순도를 사용하게 됩니다.

지니 불순도가 좀 더 계산이 빠르기 때문에 기본적으로 좋지만, 엔트로피는 좀 더 균형 잡힌 트리를 만드는데 용이하다는 장점을 가지고 있습니다.

6.7 규제 파라미터

Decision Tree는 Training data에 대한 제약이 거의 없습니다. 따라서 제한을 두지 않으면 트리는 데이터에 Overfitting되기 쉽습니다.

Decision tree는 학습 전 파라미터의 수가 결정되지 않아 비파라미터 모델(nonparameter model)이라고 부르고, 모델의 구조가 자유롭습니다. 반대로 Linear model과 같은 파라미터 모델(parameter model)은 Overfitting될 위험이 줄어듭니다.

이러한 Overfit을 막기 위해 max_depth와 같은 규제 파라미터를 사용합니다. 이 외에도 sklearn의 DecisionTreeClassifier에서는 다른 규제 파라미터가 있습니다.

- min_samples_leaf : 리프 노드가 가져야할 최소 샘플 수

- min_weight_graction_leaf : min_samples_leaf와 같지만, 가중치가 부여된 전체 데이터 수에서의 ㅂ율

- max_leaf_nodes : 리프 노드의 최대 수

- max_features : 각 노드에서 분할에 사용할 특성의 최대 수

다음은 규제 파라미터의 효과를 관찰하기 위해 moons 데이터셋에 규제가 없는 것과 min_samples_leaf = 4로 설정한 것 두개의 Decision tree입니다. 확실히 왼쪽 그래프가 Overfitting되어있는 것을 확인할 수 있습니다.

6.8 Regression

이번엔 Decision Tree를 Regression에 활용하는 법을 공부해보습니다. sklearn의 DecisiontreeRegressor를 이용해 feature가 2개인 데이터셋에 대해 max_depth = 2로 설정하고 트리를 생성하였습니다.

from sklearn.tree import DecisionTreeRegressor

tree_reg = DecisionTreeRegressor(max_depth=2, random_state=42)
tree_reg.fit(X, y)

>> DecisionTreeRegressor(max_depth=2, random_state=42)

앞서 Classification을 위해 사용된 Decision Tree와 크게 차이가 있어보이진 않습니다. 다만 Regression에서는 들어온 데이터가 어느 클래스인지를 분류하는 대신 어떤 값을 예측한다는 점에서 차이가 있습니다.

예를 들어 $x_1 = 0.6$인 데이터의 타깃값을 예측한다면, 루트 노드에서부터 value가 0.111인 리프 노드에 도달하게 됩니다. 그리고 해당 리프 노드로 도달한 110개 데이터의 평균 타깃값이 예측값이 됩니다. 이를 이용하여 MSE를 계산하면 0.015가 나오게 됩니다.

위 그래프들은 서로 다른 max_depth에 대한 Decision Tree 모델이고, 빨간색 선이 데이터를 대표하는 회귀 그래프입니다. 각 영역의 예측값 $\hat{y}$는 해당 영역에 있는 타깃값 $y$의 평균입니다.

CART 알고리즘은 불순도를 최소화하는 대신 다음과 같이 MSE를 최소화하도록 분할합니다.

Regression에서도 Decision Tree는 Overfitting되기 쉽기 때문에 규제 파라미터를 이용하면 다음과 같이 훨씬 그럴싸한 모델을 생성할 수 있습니다.

6.9 Decision Tree의 단점 : 불안정성

Decision Tree의 결정 경계는 계단 모양입니다. 이 말은 Training set의 사소한 변화에도 민감하다는 의미입니다. 예를 들어 데이터셋을 45C˚ 회전하게 되면 Decision Tree는 다음 오른쪽처럼 불필요하게 구불구불해집니다.

또 다른 예시는 앞서 본 Iris 데이터에서 Versicolor 클래스를 제거하고 훈련시켰을 때의 모델입니다. 분명 이전에 만든 Decision Tree와는 다른 모습을 보이는 문제가 있습니다.

다음 포스팅에서는 앙상블 학습과 랜덤 포레스트에 대해서 공부해보겠습니다. 긴 글 읽어주셔서 감사합니다. 오늘도 행복한 하루 보내시길 바랍니다 :)

[ 핸즈온 머신러닝 2판 ] SVM이란?

Box형 — Tue, 2 Feb 2021 01:11:53 +0900

인내는 어떤 실력보다 강하다

- 벤 호건 (프로 골퍼) -

시작하며

SVM은 Classification, Regression 등 다양한 곳에서 활용됩니다. 특히 복잡한 데이터셋을 학습하기에 용이하다는 점도 SVM의 인기를 높이는 데 한 몫 하였습니다.

5.1 선형 SVM 분류

위 데이터셋은 서로 다른 종류의 붓꽃들을 모아놓은 데이터셋입니다. 이 둘을 직선 하나만 그어서 같은 클래스의 데이터들만 모여있도록 구역을 나눌 수 있을까요?

당연히 가능합니다. 우리는 이것을 선형적으로 구분이 가능하다고 합니다. 그러나 왼쪽 그래프의 빨간색이나 자주색 선이 두 클래스를 잘 구분하는 듯 하지만 경계가 너무 데이터에 가깝기 때문에 좋은 성능을 보일거라곤 장담하지 못합니다.

결론은 오른쪽처럼 두 클래스를 나눌 때 최대한 큰 마진(margin)을 갖도록 경계를 정하면 그만큼 성능이 높아진다는 것입니다. 이렇게 마치 최대한 폭이 넓은 도로를 찾는 듯 분류하는 것이 Large Margin Classfication이라고 합니다.

도로 밖에 data를 추가하더라도 경계는 변하지 않으며, 오른쪽 그래프의 두 점선처럼 도로의 경계에 영향을 미치는 데이터를 Suppor Vector라고 합니다.

이렇게 경계를 정하여 데이터를 분류하는데 사용하는 모델을 SVM(Support Vector Machine)이라고 합니다.

SVM을 다룰 때 feature의 Scale(범위)을 조정하는 것이 중요합니다.

왼쪽 그래프는 $x_1$과 $x_0$의 Scale이 달라 Margin이 거의 없는 경계가 생성되었습니다. 반대로 이 feature들의 스케일을 조정하면 오른쪽처럼 경계가 훨씬 좋아집니다.

Margin Classification

Margin Classification에는 Hard와 Soft 두가지가 있습니다. Hard Margin Classification은 모든 데이터가 도로의 바깥쪽에 올바르게 분류되어야합니다.

그러나 이는 데이터가 선형적으로 분류가 가능해야하고, 변칙적으로 튀는 이상치(Anomaly data)에 민감합니다.(이상치마저도 완벽하게 분류하려하니 경계가 좋은 성능을 지닐 수가 없겠죠)

따라서 왼쪽 그래프처럼 이상치가 존재하는 경우 Hard하게 분류하는 것은 불가능합니다. 게다가 오른쪽처럼 분류할 수 있다하더라도 완벽하게 분류하기 위해선 margin이 거의 없는 경계를 만들어야하는 상황이 발생하게 됩니다.

그래서 우리는 분류가 조금 틀리더라도 성능 좋은 경계를 만들기 위해 Soft Margin Classification을 생각하게 되었습니다. 이는 도로의 Margin의 크기와 잘못 분류하는 Margin violation(마진 오류)에 대한 트레이드 오프 관계에서 균형을 잘 잡아야합니다.

sklearn의 SVM 모델의 하이퍼 파라미터중 하나인 $C$는 이러한 트레이드 오프를 정하는데 사용됩니다. 이 $C$가 높을 수록 모델은 Margin Violation을 허용하지 않으려 합니다. 반대로 $C$가 낮으면 Margin Violation은 높아지겠지만 일반화가 더 잘될 것입니다.

다음은 앞서 본 붓꽃 데이터셋에 대해서 feature Scale을 조정한 후, 특정 품종을 감지하기 위해 선형 SVM 모델을 훈련시키는 코드입니다.

import numpy as np
from sklearn import datasets
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.svm import LinearSVC

iris = datasets.load_iris()
X = iris["data"][:, (2, 3)]  # 꽃잎 길이, 꽃잎 너비
y = (iris["target"] == 2).astype(np.float64)  # Iris virginica

svm_clf = Pipeline([
        ("scaler", StandardScaler()),
        ("linear_svc", LinearSVC(C=1, loss="hinge", random_state=42)),
    ])

svm_clf.fit(X, y)

//output
Pipeline(steps=[('scaler', StandardScaler()),
                ('linear_svc', LinearSVC(C=1, loss='hinge', random_state=42))])

svm_clf.predict([[5.5, 1.7]])

//output(예측 결과)
array([1.])

sklearn의 SVM 모델을 최적화할 땐 보통 SGDClassifier같은 일반적인 Gradient Descent Algorithm을 이용합니다.

5.2 비선형 SVM 분류

선형 SVM 분류기가 많은 경우에 잘 작동하지만, 선형적으로 분류할 수 없는 데이터셋들 또한 많습니다. 이럴 때 Polynomial Feature과 같은 feature를 추가하는 것입니다.

왼쪽 그래프는 $x_1$이라는 하나의 feature만 가지는 데이터셋으로 선형적으로 분류가 안되지만, $x_2=(x_1)^2$라는 새로운 특성을 추가하면 오른쪽처럼 완벽하게 선형적으로 분류가 가능합니다.

sklearn에서는 다음과 같이 적용해볼 수 있습니다 사용된 데이터는 Binary Classification의 예시를 들때 자주 사용되는 moon dataset입니다.

from sklearn.datasets import make_moons
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import PolynomialFeatures

polynomial_svm_clf = Pipeline([
        ("poly_features", PolynomialFeatures(degree=3)),
        ("scaler", StandardScaler()),
        ("svm_clf", LinearSVC(C=10, loss="hinge", random_state=42))
    ])

polynomial_svm_clf.fit(X, y)

5.2.1 Polynomial Kernel(다항식 커널)

Polynomial Feature를 추가하는 건 모든 머신러닝 알고리즘에서 사용가능한 보편적입니다. 그러나 이런식으로 변형된 높은 차수의 다항식은 모델을 느리게 만듭니다.

다행히 SVM은 Kernel Trick을 이용하여 실제로는 feature를 추가하지 않으면서 feature를 많이 추가한듯한 결과를 얻을 수 있습니다.

커널 트릭에 대한 좀 더 자세한 부분은 아래의 이전 포스팅을 참고해주세요

[AI/Coursera ( Machine Learning )] - [머신러닝 순한맛] SVM(Supprot Vector Machine)이란? - 3) Kernal

[머신러닝 순한맛] SVM(Supprot Vector Machine)이란? - 3) Kernal

시작하며 저번 포스팅에서는 SVM의 Margin에 대해 다루며, 선형으로 분리되는 데이터의 Decision Boundary를 어떻게 지정할 것인가에 대해 다뤄보았습니다. 하지만 이 세상의 대부분의 데이터는 대부분

box-world.tistory.com

다음은 Polynomial Feature를 추가하여 SVM을 사용하는 코드입니다.

from sklearn.svm import SVC

poly_kernel_svm_clf = Pipeline([
        ("scaler", StandardScaler()),
        ("svm_clf", SVC(kernel="poly", degree=3, coef0=1, C=5))
    ])
poly_kernel_svm_clf.fit(X, y)

왼쪽 그래프는 3차 Polynomial Kernel을, 오른쪽은 10차를 적용하였습니다. 추가하는 feature의 차수가 높아질수록 Margin Violation이 감소되게끔 경계가 변하는 것을 볼 수 있습니다.

하이퍼파라미터 $C$는 높은 차수와 낮은 차수에 얼마나 영향을 받을지 결정합니다.

5.2.2 유사도 특성

유사도 특성은 각 data가 특정 랜드마크와 얼마나 닮았는지를 y값으로 두는 유사도 함수를 이용하는데, y값이 바로 추가된 feature가 됩니다.

예를 들어 왼쪽 그래프처럼 $x_1 = -2$와 $x_1 = 1$를 중심축으로 가지는 $γ = 3$인 Gaussian RBF를 유사도 함수로 정의합니다. 이때 $x_1 = -2$와 $x_1 = 1$가 바로 랜드마크입니다.

쉽게 설명하자면 나머지 데이터들이 정해진 랜드마크와 얼마나 닮았느냐에 대한 수치가 y축인 유사도인것입니다. 예를 들어 랜드마크 $x_1 = -2$에 대해 $x_1 = -1$과 $x_1 = 4$ 두개에 대해 -1이 -2와 더 가까우므로 유사도가 높은 것입니다.

이렇게 추가된 feature를 이용하면 오른쪽 그래프처럼 분류가 가능해집니다. 위 예시에서는 데이터들 중 2개만을 랜드마크로 지정했지만 모든 데이터를 랜드마크로 지정하면, 차원이 커지기 때문에 선형적으로 구분될 가능성이 커집니다.

다만 n개의 feature를 가지던 m개의 데이터가 m개의 feature를 가지는 m개의 데이터로 변환된다는 것이 리스크로 작용합니다.(기존에 존재하던 feature는 제외한다고 가정합니다.)

5.2.3 Gaussian RBF Kernel

앞서 우리는 유사도를 이용하여 feature를 추가하는 방법을 살펴보았습니다. 그런데 이렇게 유사도를 측정하여 feature를 추가하는 방식은 큰 연산 비용을 요구합니다. 여기서 Kernel Trick이 비용을 줄이는데 아주 중요한 작용을 합니다.

우선 다음은 Gaussian RBF Kernel을 사용한 SVM 모델을 사용하는 코드입니다.

rbf_kernel_svm_clf = Pipeline([
        ("scaler", StandardScaler()),
        ("svm_clf", SVC(kernel="rbf", gamma=5, C=0.001))
    ])
rbf_kernel_svm_clf.fit(X, y)

//output
Pipeline(steps=[('scaler', StandardScaler()),
                ('svm_clf', SVC(C=0.001, gamma=5))])

위 그래프에서 알 수 있듯이 $γ$가 커질수록 앞서 봤던 종 모양의 그래프가 좁아지면서 각 데이터의 영향 범위가 줄어드는 효과를 가져옵니다. 이에 따라 경계는 좀더 구불구불해지고 불규칙해집니다.

이 밖에 다른 커널들도 많이 존재하지만 거의 쓰이지 않습니다. 대부분은 선형 커널(LinearSVC)와 Gaussian RBF Kernel에서 문제가 해결됩니다.

5.3 SVM을 이용한 Regression

SVM은 Classification 뿐 아니라 Regression에도 이용될 수 있습니다. 원리는 간단합니다. Regression에서는 도로 경계안에 최대한 많은 데이터들을 담아 데이터를 대표하려고 하면 됩니다.

즉 일정한 Margin Violation 아래에서 가능한 많은 데이터가 도로안에 들어가도록 학습니다. 이때 도로의 폭인 Margin은 위와 같이 하이퍼파라미터로 조절 가능하다.

다음은 sklearn의 LinearSVR을 이용한 선형 SVM Regression을 적용하는 코드입니다.

from sklearn.svm import LinearSVR

svm_reg = LinearSVR(epsilon=1.5, random_state=42)
svm_reg.fit(X, y)

그리고 다음은 2차 Polynomial Kernel을 사용한 SVM Regression입니다.

from sklearn.svm import SVR

svm_poly_reg = SVR(kernel="poly", degree=2, C=100, epsilon=0.1, gamma="scale")
svm_poly_reg.fit(X, y)

다음 포스팅에서는 SVM만큼이나 보편적으로 사용되는 Decision Tree에 대해서 공부해보겠습니다. 긴글 읽어주셔서 감사합니다. 오늘도 행복한 하루 보내세요 :)

[ Flutter ] ExpansionTile로 숨김 / 드러내기 기능 구현해보기!

Box형 — Tue, 12 Jan 2021 18:56:13 +0900

안녕하세요 이번 포스팅에서는 Flutter의 ExpansionTile로 우리가 평소 여러 앱에서 보던 정보 숨기기 / 드러내기 기능을 구현해보도록 하겠습니다.

ExpansionTile

우선 코드부터 보시겠습니다.

ExpansionTile(
                  title: new Text('기본 정보',
                    style: TextStyle(
                        fontWeight: FontWeight.bold,
                        fontSize: screenWidth*(16 /360),
                        color: Colors.black
                    ),
                  ),
                  initiallyExpanded: true,
                  backgroundColor: Colors.white,
                  children: <Widget>[
                    Divider(height: 3,color: OptionDivideLineColor,),
                    Container(
                      height: screenHeight*0.05,
                      width: screenWidth,
                      child: Padding(
                        padding: EdgeInsets.symmetric(horizontal: screenWidth*0.0444444),
                        child: Row(
                          children: [
                            SizedBox(
                              width: screenWidth*0.24444,
                              child: Text('기존 월세',
                                style: TextStyle(
                                  color: hexToColor("#888888"),
                                  fontSize: screenWidth*OptionFontSize,
                                ),),
                            ),
                            Text('234만원',
                              style: TextStyle(
                                color: Colors.black,
                                fontSize:screenWidth*OptionFontSize,
                              ),),
                          ],
                        ),
                      ),
                    ),
                    Divider(height: 3,color: OptionDivideLineColor,),
                    Container(
                      height: screenHeight*0.05,
                      width: screenWidth,
                      child: Padding(
                        padding: EdgeInsets.symmetric(horizontal: screenWidth*0.0444444),
                        child: Row(
                          children: [
                            SizedBox(
                              width: screenWidth*0.24444,
                              child: Text('기존 보증금',
                                style: TextStyle(
                                  color: hexToColor("#888888"),
                                  fontSize: screenWidth*OptionFontSize,
                                ),),
                            ),
                            Text('234만원',
                              style: TextStyle(
                                color: Colors.black,
                                fontSize:screenWidth*OptionFontSize,
                              ),),
                          ],
                        ),
                      ),
                    ),
                    Divider(height: 3,color: OptionDivideLineColor,),
                    Container(
                      height: screenHeight*0.05,
                      width: screenWidth,
                      child: Padding(
                        padding: EdgeInsets.symmetric(horizontal: screenWidth*0.0444444),
                        child: Row(
                          children: [
                            SizedBox(
                              width: screenWidth*0.24444,
                              child: Text('평균 공과금',
                                style: TextStyle(
                                  color: hexToColor("#888888"),
                                  fontSize: screenWidth*OptionFontSize,
                                ),),
                            ),
                            Text('234만원',
                              style: TextStyle(
                                color: Colors.black,
                                fontSize:screenWidth*OptionFontSize,
                              ),),
                          ],
                        ),
                      ),
                    ),
                  ]
              ),

코드를 실행한 결과입니다.

Option

이제 여러 옵션에 대해 알아보겠습니다.

- backgroundColor : ExpansionTile의 기본 색깔을 결정합니다.

- children [] : 펼쳤을 때 보이는 부분입니다. Container 등 자유롭게 넣으시면 됩니다. 일반적으로는 ListView는 많이 넣습니다.

- title : ExpansionTile의 제목입니다.

- initiallyExpanded : true로 설정 시 처음 들어왔을 때, 펼쳐져있습니다.

- onExpansionChanged : 펼쳐지거나 접혀지는 이벤트가 발생 시 실행할 액션을 담습니다. onTap이나 onPressed와 같은 맥락입니다.

읽어주셔서 감사합니다. 질문이 있다면 언제든 남겨주세요 :)

[ Flutter ] File Image 렌더링하기

Box형 — Wed, 6 Jan 2021 00:38:43 +0900

이번 포스팅에서는 File 형식의 Image를 화면에 렌더링하는 코드를 소개해드리겠습니다.

File f;//File 선언

Container(
	width: 100,
	height: 100,
	decoration: BoxDecoration(
	    image: DecorationImage(
	        image: FileImage(f),//File Image를 삽입
	        fit: BoxFit.cover)),
 )

방금과 같이 File을 핸들링하면 위와 같이 정상적으로 화면에 이미지가 비춰지는 것을 보실 수 있습니다.

[ Flutter ] 갤러리 혹은 카메라에서 사진 가져오기

Box형 — Wed, 6 Jan 2021 00:30:00 +0900

이번 포스팅에서는 Flutter에서 갤러리 혹은 카메라에서 사진을 'File'형식으로 가져오는 코드를 소개해드리겠습니다.

1) 갤러리에서 가져오기

PickedFile f = await ImagePicker().getImage(source: ImageSource.gallery);//갤러리에서 사진을 가져옵니다.
File dummyFile = File(f.path);//가져온 사진의 Type을 File 형식으로 바꿔줍니다.

2) 카메라에서 가져오기

PickedFile f = await ImagePicker().getImage(source: ImageSource.camera);//갤러리에서 사진을 가져옵니다.
File dummyFile = File(f.path);//가져온 사진의 Type을 File 형식으로 바꿔줍니다.

이렇게 해서 얻은 File 형식의 사진 파일은 위와 같이 활용될 수 있습니다.

File 형식의 Image를 화면에 렌더링 하는법을 알고싶다면 다음 포스팅을 참고해주세요 :)

[Flutter] - [ Flutter ] File Image 렌더링하기

[ Flutter ] File Image 렌더링하기

이번 포스팅에서는 File 형식의 Image를 화면에 렌더링하는 코드를 소개해드리겠습니다. File f;//File 선언 Container( width: 100, height: 100, decoration: BoxDecoration( image: DecorationImage( image:..

box-world.tistory.com

[ 핸즈온 머신러닝 2판 ] 로지스틱 회귀(Logistic Regression)이란?

Box형 — Wed, 30 Sep 2020 23:24:41 +0900

"당신은 뭔가 더 대단한 것을 해낼 수 있다."

- 칼로스 M.구티에레즈미국 상무장관 -

4.6 로지스틱 회귀(Logistic Regression)

본래 회귀(Regression)은 값을 예측할 때 쓰이지만, Logistic Regression은 데이터가 어떤 클래스에 속하는지 분류하는데 사용됩니다. 다시 말해서 Logistic Regression은 어떤 데이터가 특정 클래스일 확률을 결과값으로 도출하기 때문에 회귀에 속하는 것입니다.

예를 들어 어떤 이메일이 스팸인지 아닌지를 분류할 때, 데이터를 Logistic Regression을 이용하여 추정할 때 결과값이 0.6이 나오면 해당 데이터가 스팸일 확률이 60%라는 것이고 이 경우 해당 메일을 스팸으로 분류하는 식입니다.

4.6.1 확률 추정

Logistic Regression의 작동 방식에 대해 알아보겠습니다. 우선 처음엔 데이터를 집어넣으면 각 feature의 가중치 합을 계산합니다. 여기까지가 일반적인 Linear Model의 결과값 도출방식입니다.

하지만 Logistic Regression에서는 이것을 시그모이드 함수(sigmoid function)으로 감싸서 0과 1사이의 값이 나오도록 바꿔줍니다. 왜일까요? 당연히 데이터를 특정 클래스로 분류해야하기 때문에 0~1사이의 확률값으로 변환해야하는 것입니다.

이 시그모이드 함수의 형태는 다음과 같으며, t에 대한 함수값이 0과 1 사이에서 존재하는 것을 확인할 수 있습니다.

이 함수를 거쳐나온 확률값으로 최종적으로 주어진 데이터가 어느 클래스에 속하는지 결정하게 됩니다. 보통 확률값이 0.5 이상이면 1 (양성 클래스), 이하면 0 (음성 클래스)라고 예측합니다.

4.6.2 훈련과 Cost 함수

Logistic Regression에서 훈련의 목적은 양성인 데이터 (y = 1)에 대해서는 높은 확률값을 도출하고 음성인 데이터(y=0)에 대해서는 낮은 확률값을 도출하는 것입니다.

Logistic Regression의 Cost 함수는 이러한 아이디어를 잘 반영하고 있습니다.

Cost 함수

예를 들어 데이터는 음성에 가까운데 ( 확률값인 t는 0에 가깝다 ) 이를 양성 클래스로 예측하면 - log(t)는 매우 커지므로 잘못된 예측이라는 것을 알 수 있습니다. 혹은 데이터는 양성에 가까운데 ( 확률값인 t는 1에 가깝다 ) 이를 음성 클래스로 예측하면 마찬가지로 -log(1-t)는 매우 커진다는 것을 알 수 있습니다.

반대로 데이터도 양성이고 예측도 양성이라면, -log(t)는 0에 가까워지고, 데이터도 음성이고 예측도 음성이 되면 -log(1-t)는 역시 0에 가까워집니다.

방금 우리가 한 것은 하나의 데이터에 대해 Cost를 계산하는 과정이었습니다. 전체 데이터에 대한 Cost는 모든 dataset의 Cost를 평균내는 것이고 이를 로그 손실(log loss)라고 부르며 다음과 같은 식으로 표현합니다.

위 Cost 함수는 Gradient Descent Algorithm으로 최적화가 가능합니다. 특히 Cost 함수가 볼록 함수이기 때문에 거의 Global minimum(전역 최솟값)을 찾는 것을 보장합니다.

다만 아쉽게도 Normal Equation( 정규 방정식 )과 같이 단번에 최적화하는 방법은 없습니다.

다음은 최적화에 이용하는 Cost 함수의 편도함수입니다.

4.6.3 결정 경계

이제 세 가지의 서로 다른 꽃 품종을 Logistic Regression으로 분류하는 예시를 통해 설명을 계속 이어가보겠습니다. 우리가 사용할 데이터에는 꽃의 꽃잎, 꽃받침의 너비와 길이를 담고 있습니다. 여기서는 꽃잎의 너비를 기반으로 Iris-Versicolor종을 감지하는 분류기를 만들어볼 것입니다. 우선 데이터를 로드해보겠습니다.

from sklearn import datasets
iris = datasets.load_iris()
list(iris.keys())
>> 
['data',
 'target',
 'frame',
 'target_names',
 'DESCR',
 'feature_names',
 'filename']

X = iris["data"][:, 3:]  # 꽃잎 너비
y = (iris["target"] == 2).astype(np.int)  # Iris virginica이면 1 아니면 0

Logistic Regression 모델을 훈련시킵니다.

from sklearn.linear_model import LogisticRegression
log_reg = LogisticRegression(solver="lbfgs", random_state=42)
log_reg.fit(X, y)

이제 꽃잎의 너비가 0~3cm인 꽃들에 대해 꽃잎의 너비에 따라 모델이 어떤것을 Iris-Versicolor종으로 분류하는 살펴보겠습니다.

X_new = np.linspace(0, 3, 1000).reshape(-1, 1)
y_proba = log_reg.predict_proba(X_new)
decision_boundary = X_new[y_proba[:, 1] >= 0.5][0]

plt.figure(figsize=(8, 3))
plt.plot(X[y==0], y[y==0], "bs")
plt.plot(X[y==1], y[y==1], "g^")
plt.plot([decision_boundary, decision_boundary], [-1, 2], "k:", linewidth=2)
plt.plot(X_new, y_proba[:, 1], "g-", linewidth=2, label="Iris virginica")
plt.plot(X_new, y_proba[:, 0], "b--", linewidth=2, label="Not Iris virginica")
plt.text(decision_boundary+0.02, 0.15, "Decision  boundary", fontsize=14, color="k", ha="center")
plt.arrow(decision_boundary, 0.08, -0.3, 0, head_width=0.05, head_length=0.1, fc='b', ec='b')
plt.arrow(decision_boundary, 0.92, 0.3, 0, head_width=0.05, head_length=0.1, fc='g', ec='g')
plt.xlabel("Petal width (cm)", fontsize=14)
plt.ylabel("Probability", fontsize=14)
plt.legend(loc="center left", fontsize=14)
plt.axis([0, 3, -0.02, 1.02])
save_fig("logistic_regression_plot")
plt.show()

위 그래프를 통해 알 수 있는 점은 다음과 같습니다.

1) Iris-Verginica의 꽃잎 너비는 1.4cm~2.5cm 사이입니다. 반면 다른 꽃들의 꽃잎 너비는 0.1 ~ 1.8cm 사이로 약간 중첩됩니다.
2) 꽃잎의 너비가 2cm가 넘어가면 Iris-Verginica라고 강하게 확신합니다.
3) 양쪽의 확률이 똑같이 50%가 되는 1.6cm 근방에서 결정 경계(decision boundary)가 생성됩니다. 바로 이 decision boundary를 기준으로 이것보다 꽃잎의 너비가 크면 Iris-Verginica라고 예측할 것입니다.

log_reg.predict([[1.7], [1.5]]) #1.7은 양성, 1.5는 음성으로 분류하였습니다.
>> array([1, 0])

이번에는 꽃잎의 너비에 꽃잎의 길이까지 더하여 두개의 feature를 이용해 클래스를 예측해보겠습니다.

from sklearn.linear_model import LogisticRegression

X = iris["data"][:, (2, 3)]  # petal length, petal width
y = (iris["target"] == 2).astype(np.int)

log_reg = LogisticRegression(solver="lbfgs", C=10**10, random_state=42)
log_reg.fit(X, y)

x0, x1 = np.meshgrid(
        np.linspace(2.9, 7, 500).reshape(-1, 1),
        np.linspace(0.8, 2.7, 200).reshape(-1, 1),
    )
X_new = np.c_[x0.ravel(), x1.ravel()]

y_proba = log_reg.predict_proba(X_new)

plt.figure(figsize=(10, 4))
plt.plot(X[y==0, 0], X[y==0, 1], "bs")
plt.plot(X[y==1, 0], X[y==1, 1], "g^")

zz = y_proba[:, 1].reshape(x0.shape)
contour = plt.contour(x0, x1, zz, cmap=plt.cm.brg)


left_right = np.array([2.9, 7])
boundary = -(log_reg.coef_[0][0] * left_right + log_reg.intercept_[0]) / log_reg.coef_[0][1]

plt.clabel(contour, inline=1, fontsize=12)
plt.plot(left_right, boundary, "k--", linewidth=3)
plt.text(3.5, 1.5, "Not Iris virginica", fontsize=14, color="b", ha="center")
plt.text(6.5, 2.3, "Iris virginica", fontsize=14, color="g", ha="center")
plt.xlabel("Petal length", fontsize=14)
plt.ylabel("Petal width", fontsize=14)
plt.axis([2.9, 7, 0.8, 2.7])
save_fig("logistic_regression_contour_plot")
plt.show()

위 그래프에서 decision boundary는 검은색 점선입니다. 이외에 주목할 점으로는 0.900이라고 명시된 초록색 선 위에 있는 데이터는 90% 이상의 확률로 Iris-Verginica로 분류된 데이입니다. 그리고 0.150이라고 명시된 파란색 선 아래에는 15% 미만으로 음성 클래스로 분류된 데이터들입니다.

4.6.4 소프트맥스 회귀(Softmax Regression)

우리가 앞서 봤던 Logistic Regression은 이진 분류(Binary Classification) 즉 1이냐 0이냐였습니다. Softmax Regression은 두 가지 이상의 클래스를 분류하는데 사용하는 Logistic Regression입니다.

데이터 x가 클래스 k에 대한 softmax 점수를 산출하는 식

데이터가 주어지면 Softmax Regression 모델은 해당 데이터가 각 클래스에 대한 점수를 계산하고,

softmax 함수

softmax 함수를 이용하여 이 점수를 확률값으로 바꾸게 됩니다. 그리고 가장 높은 확률값을 가진 클래스로 데이터 x를 분류하게 됩니다.

이제 모델의 훈련 방법에 대해 알아보겠습니다. 우리의 목적은 타깃(정답) 클래스에 대해서는 높은 확률을, 나머지는 낮은 확률을 추정하도록 하는것이 목표입니다. 여기에 Cross-Entropy Cost 함수를 사용합니다. 그리고 이를 최적화하기 위한 Gradient Vector는 다음과 같습니다.

다음은 sklearn에서 Softmax Regression을 적용하는 코드입니다.

X = iris["data"][:, (2, 3)]  # 꽃잎 길이, 꽃잎 너비
y = iris["target"]

softmax_reg = LogisticRegression(multi_class="multinomial",solver="lbfgs", C=10, random_state=42)
softmax_reg.fit(X, y)

그리고 꽃잎의 길이가 5cm, 너비가 2cm인 꽃의 품종이 무엇인지 모델에 물어봤더니 94.2% 확률로 Iris-Verginica라고 출력하고 있습니다.

softmax_reg.predict([[5, 2]])
>> array([2])

softmax_reg.predict_proba([[5, 2]])
>> array([[6.38014896e-07, 5.74929995e-02, 9.42506362e-01]])

앞서 우리는 세개의 품종에 대해 Iris-Verginica를 감지하는 분류기에 대해서 다뤄봤습니다. 그리고 다음에서 세 개의 클래스에 대해 decision boundary를 어떻게 형성하는지 살펴보겠습니다.

1) class 사이의 decision boundary는 선형입니다.
2) 모든 결정 경계가 만나는 지점에서는 클래스가 모두 동일하게 33%의 추정 확률을 가집니다.

다음 포스팅에서는 Logistic Regression과 함께 Classification에 사용되는 대표적인 방법인 SVM (Support Vector Machine)에 대해 공부해보겠습니다.

긴 글 읽어주셔서 감사합니다. 행복한 하루 보내시길 바랍니다 :)

[ 핸즈온 머신러닝 2판 ] Linear Regression 속 Regularization이란?

Box형 — Wed, 30 Sep 2020 01:45:38 +0900

"이끌거나, 따르거나, 비켜서라."

- Ted Turner (CNN 설립자) -

4.5 선형 모델(Linear Model)에서의 규제(Regularization)

Regularization은 모델이 Overfit되었을 때, 이를 감소시키는 대표적인 방법입니다. 다항 회귀(Polynomial Regression)에서는 단순히 차수를 감소시키는 것으로 Regularization이 가능합니다.

선형 회귀(Linear Regression)에서는 모델의 가중치를 제한하여 Regulariztion이 이뤄집니다. 여기에서 세 가지 방법이 있는데 이제부터 하나하나 살펴 보겠습니다.

4.5.1 릿지 회귀(Ridge Regularization)

Linear Regression에 Regularization 항이 추가된 것이 Ridge regression입니다. Regularization 항은 훈련하는 동안에만 Cost 함수에 존재하고, 성능을 평가할 때는 포함하지 않습니다. 위 식이 어떻게 Overfit을 억제하는 것일까요?

우선 $θ$는 가중치입니다. 기본적으로 우리는 Cost가 최소가 되길 원합니다. 그런데 Regularization으로 인해 기존보다 $θ_i^2$들이 더해졌습니다.

그러면 모델을 학습시키는 입장에서는 Cost를 최소화하기 위해 $θ_i$를 기존보다 더 작게 설정해야할 것입니다. 그렇게 하면 보통 높은 차수에 곱해지는 가중치 $θ_i$는 0에 가까워져 없어지면서 차수가 내려가게 되면서 Overfit을 막게 됩니다.

하이퍼파라미터 $α$는 모델을 얼마나 Regularization할지 결정합니다. 이것이 커지면 커질수록 추가로 더해지는 가중치의 총합은 커지기 때문에 모델 학습이 이 가중치를 더욱 낮게 설정하려 하면서 차수가 더욱 낮아질 것입니다.

반대로 $α$가 0이라면 기존에 우리가 알던 Cost함수와 동일해집니다. 다음은 $α$의 변화에 따른 Ridge Regression의 훈련 결과입니다.

from sklearn.linear_model import Ridge

def plot_model(model_class, polynomial, alphas, **model_kargs):
    for alpha, style in zip(alphas, ("b-", "g--", "r:")):
        model = model_class(alpha, **model_kargs) if alpha > 0 else LinearRegression()
        if polynomial:
            model = Pipeline([
                    ("poly_features", PolynomialFeatures(degree=10, include_bias=False)),
                    ("std_scaler", StandardScaler()),
                    ("regul_reg", model),
                ])
        model.fit(X, y)
        y_new_regul = model.predict(X_new)
        lw = 2 if alpha > 0 else 1
        plt.plot(X_new, y_new_regul, style, linewidth=lw, label=r"$\alpha = {}$".format(alpha))
    plt.plot(X, y, "b.", linewidth=3)
    plt.legend(loc="upper left", fontsize=15)
    plt.xlabel("$x_1$", fontsize=18)
    plt.axis([0, 3, 0, 4])

plt.figure(figsize=(8,4))
plt.subplot(121)
plot_model(Ridge, polynomial=False, alphas=(0, 10, 100), random_state=42)
plt.ylabel("$y$", rotation=0, fontsize=18)
plt.subplot(122)
plot_model(Ridge, polynomial=True, alphas=(0, 10**-5, 1), random_state=42)

save_fig("ridge_regression_plot")
plt.show()

아래 그래프에서 왼쪽은 일반적인 Linear model, 오른쪽은 Polynomial Regression으로 데이터를 10차로 확장한 후 Regularization을 적용하였습니다.

Ridge Regression의 최적화는 Linear Regression과 마찬가지로 경사 하강법(Gradient Descent Algorithm)과 정규 방정식(Normal Equation)이 모두 적용가능합니다. 다음은 Ridge Regression에서 Normal Equation을 적용하는 방법입니다.

다음은 sklearn에서 Normal Equation을 이용하여 Ridge Regression을 최적화하는 코드입니다.

from sklearn.linear_model import Ridge
ridge_reg = Ridge(alpha=1, solver="cholesky", random_state=42)
ridge_reg.fit(X, y)
ridge_reg.predict([[1.5]])
>> array([[1.55071465]])

다음은 SGD(확률적 경사 하강법)을 사용하여 최적화한 코드입니다.

sgd_reg = SGDRegressor(penalty="l2", max_iter=1000, tol=1e-3, random_state=42)
sgd_reg.fit(X, y.ravel())
sgd_reg.predict([[1.5]])
>> array([1.47012588])

4.5.2 라쏘 회귀(Lasso Regression)

Lasso Regression과 Ridge Regression의 차이점은 Regularization 항에서 나옵니다. 이것을 마찬가지로 Linear Regression과 Polynomial Regression에 적용해보겠습니다.

from sklearn.linear_model import Lasso

plt.figure(figsize=(8,4))
plt.subplot(121)
plot_model(Lasso, polynomial=False, alphas=(0, 0.1, 1), random_state=42)
plt.ylabel("$y$", rotation=0, fontsize=18)
plt.subplot(122)
plot_model(Lasso, polynomial=True, alphas=(0, 10**-7, 1), random_state=42)

save_fig("lasso_regression_plot")
plt.show()

Lasso Regression은 가장 큰 특징은 중요하지 않은 feature는 제거해버린다는 것입니다. 위 그래프에서 $α = 1e - 07$일 때 그래프가 거의 선형적인 이유가 바로 중요하지 않은 feature의 가중치들이 모두 0이 되었기 때문입니다.

즉 Lasso Regression은 자동으로 중요한 feature들을 선택하고 나머지 가중치들은 0으로 만들고, 선택된 feature의 가중치들도 상대적으로 적은 희소 모델(sparse model)을 만든다.

다음은 sklearn에서 Lasso Regression을 적용한 코드입니다.

from sklearn.linear_model import Lasso
lasso_reg = Lasso(alpha=0.1)
lasso_reg.fit(X, y)
lasso_reg.predict([[1.5]])
>> array([1.53788174])

4.5.3 엘라스틱넷(elastic net)

Elastic net은 Ridge와 Lasso를 섞은 모델입니다. 말 그대로 Ridge와 Lasso의 Regularization 항을 모두 더하고, 그 혼합 비율을 $r$을 사용해 조절합니다.

r = 0이면 Ridge, 1이면 Lasso와 같습니다.

지금까지 Overfit을 막기 위해 사용하는 세가지 Regularization 방법에 대해 알아보았습니다. 대부분의 경우 약간의 Regularization은 무조건 필요하기 때문에 Regularization이 없는 Linear Regression은 지양해야합니다.

보통 Regularization이라고 하면 Ridge가 기본이 되지만, 많은 feature들 중 일부 feature만 중요하게 사용된다면 Lasso나 Elastic을 사용하는 것이 좋습니다. 왜냐하면 Lasso는 앞서 말한대로 중요하지 않은 feature의 가중치는 0으로 만들기 때문입니다.

그리고 feature의 수가 data의 수보다 많거나, 특정 feature 몇개가 강하게 연관되어있다면, Lasso보다는 Elastic을 사용하는 것이 좋습니다. 다음은 sklearn에서 Elastic net을 사용한 코드입니다.

from sklearn.linear_model import ElasticNet
elastic_net = ElasticNet(alpha=0.1, l1_ratio=0.5, random_state=42)
elastic_net.fit(X, y)
elastic_net.predict([[1.5]])
>> array([1.54333232])

4.5.4 조기 종료(Early Stopping)

Gradient Descent Algorithm을 Regularizatin하는 방법은 Cost가 극솟값에 도달하면 훈련을 중지하는 것입니다.

Batch-Gradient Descent로 훈련시킨 위 모델은 Epoch가 늘어날수록(훈련이 반복될수록) Cost가 점점 줄어들다가 다시 상승합니다. 즉 다시 상승하는 이 지점이 Overfit의 분기점입니다. 따라서 이 지점에서 멈추면 훈련 과정에서 Overfit되는 것을 막을 수 있습니다. 다음은 조기 종료를 위한 구현 코드입니다.

from copy import deepcopy

poly_scaler = Pipeline([
        ("poly_features", PolynomialFeatures(degree=90, include_bias=False)),
        ("std_scaler", StandardScaler())
    ])

X_train_poly_scaled = poly_scaler.fit_transform(X_train)
X_val_poly_scaled = poly_scaler.transform(X_val)

sgd_reg = SGDRegressor(max_iter=1, tol=-np.infty, warm_start=True,
                       penalty=None, learning_rate="constant", eta0=0.0005, random_state=42)

minimum_val_error = float("inf")
best_epoch = None
best_model = None
for epoch in range(1000):
    sgd_reg.fit(X_train_poly_scaled, y_train)  # 중지된 곳에서 다시 시작합니다
    y_val_predict = sgd_reg.predict(X_val_poly_scaled)
    val_error = mean_squared_error(y_val, y_val_predict)
    if val_error < minimum_val_error:
        minimum_val_error = val_error
        best_epoch = epoch
        best_model = deepcopy(sgd_reg)

이번 포스팅은 여기서 마치겠습니다. 긴 글 읽어주셔서 감사합니다. 행복한 하루 보내시길 바랍니다 :)

[ 핸즈 온 머신러닝 2판 ] Polynomial Regression과 Learning Curve란?

Box형 — Tue, 29 Sep 2020 14:01:00 +0900

"먼저 행동으로 옮기고 나서 말하라"

- 스티븐 스필버그 -

4.3 Polynomial Regression(다항 회귀)

Polynomial Regression은 비선형(non-linear) 데이터를 학습하는데 선형 모델을 사용할 수 있게 해줍니다. 다시 말해서 모델이란 것은 데이터를 대표하는 것인데 어떻게 선형 모델이 비선형 데이터를 대표할 수 있게 되는 것일까요? 우선 간단한 이차방정식으로 데이터를 생성해보겠습니다.

m = 100
X = 6 * np.random.rand(m, 1) - 3 // rand : 0~1의 균일분포 표준 정규분포 난수를 생성
y = 0.5 * X**2 + X + 2 + np.random.randn(m, 1) // randn : 가우시안 표준정규분포 난수를 생성

생성된 데이터

선형 모델은 분명 위 데이터에 적합하지 않을 것입니다. 하지만 sklearn의 PolynomialFeatures를 사용하여 Training data를 변환시키면 적용이 가능합니다.

from sklearn.preprocessing import PolynomialFeatures
poly_features = PolynomialFeatures(degree=2, include_bias=False)
X_poly = poly_features.fit_transform(X)
X[0]
>> array([-0.75275929])
X_poly[0]
>> array([-0.75275929,  0.56664654])

그렇다면 Polynomial Regression은 어떻게 데이터를 변환하는걸까요? 앞서 우리가 생성한 데이터를 기준으로 생각해보자면, feature가 하나이므로 결과값을 예측할 때는 다음과 같은 식을 사용해볼 수 있습니다.

$$Y = AX+b (A는 가중치입니다.)$$

그런데 Polynomial Regression에서는 Input data $X$를 제곱하여 이것을 새로운 feature로 추가합니다. 즉 변환후 우리는 $X$ 그리고 $X^2$ 이렇게 두개의 feature를 지니는 셈이 되는 것이죠 그렇게 해서 우리가 학습시키게 될 모델은 다음과 같습니다.

$$Y = A_1X + A_2X^2 + b$$

앞서 Polynomial Regression을 이용하면 선형 모델에 비선형 데이터를 학습 시킬 수 있음을 언급하였습니다. 머신러닝이 어려우신 분들의 이해를 돕기 위해 쉽게 설명드리자면, 아래 식을 보시면 차수가 올라간 것을 보실 수 있는데요 바로 이 차수가 높아지면서 비선형 데이터에 선형 모델이 fit할 수 있게 되는 것입니다.

이제 확장된 Training data에 Linear regression을 적용해보겠습니다.

//Linear Regression 적용
lin_reg = LinearRegression()
lin_reg.fit(X_poly, y)
lin_reg.intercept_, lin_reg.coef_

// 데이터 시각화
X_new=np.linspace(-3, 3, 100).reshape(100, 1) // -3~3 사이 100개의 수를 가지는 매트릭스 생성
X_new_poly = poly_features.transform(X_new) // 데이터 확장
y_new = lin_reg.predict(X_new_poly)
plt.plot(X, y, "b.")
plt.plot(X_new, y_new, "r-", linewidth=2, label="Predictions")
plt.xlabel("$x_1$", fontsize=18)
plt.ylabel("$y$", rotation=0, fontsize=18)
plt.legend(loc="upper left", fontsize=14)
plt.axis([-3, 3, 0, 10])
save_fig("quadratic_predictions_plot")
plt.show()

Polynomial Regression의 또 다른 특징은 기존 데이터의 feature가 여러개일 때 feature 간의 관계를 찾을 수 있습니다. 예를 들어 두개의 feature $a$,$b$가 있고, degree = 3으로 설정하여 PolynomialFeatures를 적용하면 $a^3, a^2, b^3, b^2$뿐 아니라 $ab,a^2b,ab^2$과 같은 항들도 feature로 추가하게 됩니다.

다만 이 과정에서 feature의 수가 엄청나게 증가할 수 있기 때문에 이 점은 주의하셔야 합니다.

4.4 학습곡선(Learning Curve)

우선 Learning Curve가 무엇인지 배우기 전에, Polynomial Regression에 대한 얘기를 좀 더 해보면서 Learning Curve가 어떻게 사용될 수 있는지도 함께 배워보겠습니다.

Polynomial Regression을 통해 degree가 올라가게 되면 모델은 Training data에 더 fit해집니다. 다음 그래프는 300차와 2차 Polynomial Regression 그리고 단순 Linear Regression 모델 세 개를 비교하는데, 300차가 가장 구불구불하면서 fit한 모습을 보여주고 있습니다.

참고로 여기서 Polynomial Regression 모델이 300차라는 것은 $Y = AX+b$이던 모델을 $Y = A_1X + ... + A_300X^300 + b$으로 확장한 것을 의미합니다.

from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline

for style, width, degree in (("g-", 1, 300), ("b--", 2, 2), ("r-+", 2, 1)):
    polybig_features = PolynomialFeatures(degree=degree, include_bias=False)
    std_scaler = StandardScaler()
    lin_reg = LinearRegression()
    polynomial_regression = Pipeline([
            ("poly_features", polybig_features),
            ("std_scaler", std_scaler),
            ("lin_reg", lin_reg),
        ])
    polynomial_regression.fit(X, y)
    y_newbig = polynomial_regression.predict(X_new)
    plt.plot(X_new, y_newbig, style, label=str(degree), linewidth=width)

plt.plot(X, y, "b.", linewidth=3)
plt.legend(loc="upper left")
plt.xlabel("$x_1$", fontsize=18)
plt.ylabel("$y$", rotation=0, fontsize=18)
plt.axis([-3, 3, 0, 10])
save_fig("high_degree_polynomials_plot")
plt.show()

그리고 위 300차 모델은 Training data에 Overfit되어있습니다. 반면 1차 모델은 Underfit되어 있고, 가장 적합한 건 셋 중 2차 모델일 것입니다. 그렇다면 다른 데이터를 사용할 때 얼마나 복잡한 모델을 사용해야할지, 확장된 데이터가 Overfit 혹은 Underfit되어있는지 어떻게 알 수 있을까요? 여기서 Learning Curve가 등장합니다.

Learning Curve란 Training set 그리고 Validation set에 대한 모델의 성능을 함수로 나타냅니다. 다음은 단순한 Linear regression에 대한 Learning Curve입니다.

from sklearn.metrics import mean_squared_error
from sklearn.model_selection import train_test_split

def plot_learning_curves(model, X, y):
    X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.2, random_state=10)
    train_errors, val_errors = [], []
    for m in range(1, len(X_train)):
        model.fit(X_train[:m], y_train[:m])
        y_train_predict = model.predict(X_train[:m])
        y_val_predict = model.predict(X_val)
        train_errors.append(mean_squared_error(y_train[:m], y_train_predict))
        val_errors.append(mean_squared_error(y_val, y_val_predict))

    plt.plot(np.sqrt(train_errors), "r-+", linewidth=2, label="train")
    plt.plot(np.sqrt(val_errors), "b-", linewidth=3, label="val")
    plt.legend(loc="upper right", fontsize=14)   # 책에는 없음
    plt.xlabel("Training set size", fontsize=14) # 책에는 없음
    plt.ylabel("RMSE", fontsize=14)              # 책에는 없음

lin_reg = LinearRegression()
plot_learning_curves(lin_reg, X, y)
plt.axis([0, 80, 0, 3])                         # 책에는 없음
save_fig("underfitting_learning_curves_plot")   # 책에는 없음
plt.show()

X축은 Training set의 크기에 해당합니다. 즉 Training set의 개수가 0개일 때, 1개 일때, 2개일 때 ... 80개일때까지 반복적으로 학습하여 각 학습에 대한 Cost 값을 함수로 표현한 것입니다.

그래프를 좀 더 구체적으로 살펴보자면, Training set에 대한 성능의 경우 처음에 데이터가 한 두개일 때는 Cost가 거의 0에 가까우므로 완벽하게 모델이 작동함을 확인할 수 있습니다.

그러나 데이터가 커질 수록 Noise의 개입이나 데이터가 non-linear한 특성 때문에 모델이 Training set을 완벽하게 학습하는 것이 불가능해지면서 Cost가 점점 커지게 됩니다.

이번엔 Validation set입니다. 이 경우엔 처음 0개부터 시작할 때는 적은 데이터로 모델을 일반화할 수 없기때문에 Cost가 높습니다. 그러나 데이터가 커질 수록 점점 학습해가면서 Cost가 줄어들면서 Training set의 그래프와 가까워집니다.

이제 동일한 데이터를 10차 Polynomial Regression으로 확장한 후 이에 대한 Learning Curve를 그려보겠습니다.

from sklearn.pipeline import Pipeline

polynomial_regression = Pipeline([
        ("poly_features", PolynomialFeatures(degree=10, include_bias=False)),
        ("lin_reg", LinearRegression()),
    ])

plot_learning_curves(polynomial_regression, X, y)
plt.axis([0, 80, 0, 3])           # 책에는 없음
save_fig("learning_curves_plot")  # 책에는 없음
plt.show()                        # 책에는 없음

왼쪽은 Linear Regression, 오른쪽은 10차 Polynomial Regression

위 두 그래프의 차이점을 살펴보겠습니다. Polynomial Regression은 Training set의 Cost가 Linear Regression에 비해 현저히 낮습니다. 왜 그럴까요?

Polynomial regression은 degree가 높아지기 때문에 당연히 주어진 데이터에 더 fit 해지기 때문입니다

두번째는 Validation set과 Training set 사이에 공간이 있습니다. 이는 Training set에서의 모델 성능이 Validation set의 성능보다 낫다는 말인데, 본래 좋은 모델이라면 Training set에서 뿐아니라 Validation set에서도 동일하게 성능이 좋아야할 것입니다.

결론을 짓자면 우리가 사용한 모델은 Overfit 되어있다는 뜻이 됩니다. 이러한 Overfit을 해결하기 위해서는 더 큰 Training set을 사용하면 두 곡선이 가까워지면서 해결되게 됩니다.

다음 시간에는 regularization이 들어간 Linear Model에 대해 공부해보겠습니다.

긴 글 읽어주셔서 감사합니다. 행복한 하루 보내시길 바랍니다 :)

[Flutter] 앱 개발 입문자가 Flutter를 선택한 4가지 이유

Box형 — Sun, 27 Sep 2020 21:16:38 +0900

성공하려면 귀는 열고, 입은 닫아라

- 존 데이비슨 록펠러 -

안녕하세요 매번 머신러닝 관련 포스팅만 올렸지만, 이번에는 6개월 전 처음 입문하게 된 앱개발에서 제가 왜 Flutter를 선택하게 되었는지 그리고 왜 Flutter여야 했는지 입문자의 관점에서 풀어보고자 합니다.

1) Flutter는 크로스 플랫폼!

크로스 플랫폼이란 하나의 코드로 안드로이드와 ios 개발이 동시에 가능한 프레임워크를 부르는 명칭입니다. 우리에게 알려진 크로스 플랫폼으로는 React Native와 Flutter이 있습니다.

특히 크로스 플랫폼은 안드로이드와 ios개발에 투자되는 시간과 Cost를 반으로 줄일 수 있다는 점에서 많은 사람들에게 굉장히 매력적일 수 밖에 없습니다.

6개월 전 스타트업을 시작하게된 저도 최소한의 인력으로 앱 개발을 해야하는 상황에서 자연스럽게 Flutter로 눈이 갈 수 밖에 없었습니다.

2) Flutter를 향한 Google의 적극적인 푸쉬!

어떤 프로그래머든 주력이 아닌 언어를 깊게 공부한다는 것은 쉬운 일이 아닙니다. 저 역시도 2017년 출시된 Flutter가 단기적인 인기만 끌다 금방 사라질 언어는 아닐지 많은 걱정이 있었습니다.

다행인것은 현재 Flutter는 구글이 확실하게 밀어주는 가운데 Google Ads, Cloud Platform 등이 Flutter로 개발되어있는 상태입니다. 특히 중국을 중심으로 텐센트, 알리바바 등이 Flutter를 적극적으로 활용하여 앱 개발이 이뤄지고 있습니다.

이렇듯 이미 여러 곳이 Flutter를 이용하여 많은 것들을 개발하고 있고, 세계 최대의 소프트웨어 기업인 Google의 적극적인 푸쉬 아래 속에서 앞으로도 계속 성장하지 않을까 싶습니다.

3) Flutter는 웹 개발도 가능합니다.

크로스 플랫폼인 Flutter는 심지어 웹 개발도 가능합니다. 물론 베타 버전이라 그 성능이 완벽하다고 할 순 없지만, 하나의 언어로 안드로이드, ios 그리고 웹까지 동시에 개발할 수 있다는건 무척 매력적입니다.

만약 정말 전문적으로 웹을 만들어야 하는게 아니라면, 저의 개인적인 포트폴리오를 소개하는 웹페이지 정도는 간단히 Flutter로 만들어 볼 것 같습니다!

4) Flutter는 쉽습니다.

제가 처음 앱 개발을 시작할 때 접했던 언어는 Flutter가 아닌 안드로이드 자바였습니다. 당시에 Constraint Layout을 기반으로 xml파일을 만지작거렸던 기억이 있습니다. 여차저차해서 앱을 만들긴 했으나, 레퍼런스가 많았음에도 불구하고 이해하기 어려운 부분이 한두가지가 아니었습니다.

이후에 접했던 Flutter는 구조적인 측면에서나 개발적인 측면에서나 모두 더 편하다고 느껴졌습니다. Flutter는 모든 것이 위젯으로 이루어져있어서 상대적으로 구조를 이해하기 쉬웠습니다. 위젯에 대해서는 다음 포스팅에서 구체적으로 설명하겠습니다.

게다가 Flutter를 개발해보신 분들이라면 'alt + Enter'가 정말 유용하다는 생각을 많이 하셨을 것입니다. 이것 하나로 위젯을 쉽게 추가하고 지울 수 있어서 확장성 있는 코드를 써내려갈 수 있었습니다.

Flutter하면 'Hot Reload' 기능을 빼놓을 수가 없겠죠! 이 기능은 우리가 코드를 변경하였을 때 재실행을 하는 대신에 사용하게 되면 0.1초만에 그 결과를 에뮬레이터에서 바로 확인하게 해주는 기능입니다.

덕분에 코드를 한줄한줄 써내려갈 때마다 Hot Reload 기능으로 결과물을 확인하며 코딩을 했습니다. 이렇게 결과를 바로바로 확인하면서 코딩을 하다보니 내가 써내려간 코드가 바로바로 적용된걸 확인하면서 초반에 신나게 코딩을 했던 기억이 있습니다.

이번 포스팅에서는 간단하게나마 제가 Flutter를 사용하며 느꼈던 점을 말씀드렸습니다. 물론 최적화나 적용할 수 있는 오픈소스 api 등의 측면에서는 오래전부터 사용되오던 React Native가 훨씬 유리할 수 있겠지만, Flutter만이 가지고 있는 장점이 저에겐 더 매력적으로 다가오는 것 같습니다.

다음 포스팅에서는 본격적으로 Flutter가 무엇인지에 대해 알아보겠습니다. 긴 글 읽어주셔서 감사합니다. 행복한 하루 보내시길 바랍니다 :)

[ Tensorflow 2 / sklearn ] Linear Regression과 Gradient Descent Algorithm의 종류

Box형 — Fri, 24 Jul 2020 22:36:37 +0900

이기는 것이 중요한 것은 아니지만,

이기기를 원하는 것은 중요하다

- 에릭 슈미트(Google 전 Ceo) -

이번 포스팅에서는 머신러닝의 가장 간단한 모델 중 하나인 회귀(Regression)에 속하는 선형 회귀(Linear Regression)에 대해 알아보고, 이를 최적화하는 훈련 방식인 경사 하강 알고리즘과 Normal Equation에 대해 공부해보겠습니다.

보통 우리가 Regression에서 모델을 훈련시킨다고 하면 경사 하강 알고리즘(Gradient Descent algorithm)을 사용합니다. 좀 더 세부적으로는 Batch GD, Mini-Batch GD, SGD가 있는데, 이는 잠시 후에 다시 다뤄보겠습니다.

또 다른 훈련 방식에는 Normal Equation가 있습니다. 이 또한 Linear Regression을 다룬 후 다시 언급드리겠습니다.

4.1 Linear Regression

$$ 삶의 만족도 = θ_0+θ_1*(1인당 GDP) $$

여기 1인당 GDP를 이용하여 삶의 만족도를 예측하고자 하는 Regression 모델이 있습니다. 이 모델은 Linear model이고, $θ_0$, $θ_1$이 모델 파라미터입니다.

$$y = θ_0 + θ_1*x_1 + θ_2*x_2 + θ_3*x_3 + ... + θ_n*x_n$$

앞에서 본 것이 예시였다면 위 식은 좀 더 일반적인 Linear model을 표현한 것입니다. Linear model은 Input의 feature의 Weight 합과 bias 혹은 intercept이라 부르는 상수를 더해 최종 예측값을 만들어 냅니다.

$$y = h_θ(x) = θ*x$$

앞에서 본 일반적인 식을 벡터를 이용하여 위처럼 더욱 간단히 표현할 수 있습니다.

- $θ$는 $θ_0 ... θ_n$까지 Weight를 담은 Paraeter 벡터입니다.

- $x$는 $x_0 ... x_n$까지 Input의 feature를 담은 feature 벡터입니다. 이때 $x_0$는 항상 0입니다.

- $h_θ(x)$는 가설 함수입니다.

이제 Linear Regression 모델의 구조에 대해 알아보았으니 본격적으로 훈련을 시켜보겠습니다. 모델을 훈련시킨다는 것은 Training set에 최적화되게끔 parameter를 설정한다는 의미입니다.

그리고 이를 위해 필요한 것은 예측값과 실제값의 차이를 측정할 loss function을 정의하는 것입니다. 보통 Linear Regression 모델에서 사용하는 loss function은 MSE입니다.

4.1.1 Normal Equation

Normal Equation은 앞서 언급했듯이 model parameter를 최적화하는 하나의 방식입니다. 우리가 보통 또 하나의 방법인 Gradient Descent Algorithm을 떠올리며 Gradient를 반복적으로 계산하며 조정하는 원리를 떠올립니다.

Normal Equation은 이러한 반복적인 연산없이 공식을 이용해 한번의 최적의 parameter를 도출해냅니다.

- $θ$ : loss function을 최소화하는 즉 모델에 최적화된 parameter입니다.

- $X$ : Input입니다. 이떄 $X^T$는 $X$의 전치 행렬입니다.

- $y$는 Input data에 대한 Label을 담고 있는 벡터입니다.

우선 Normal Equation을 적용하기 위해 랜덤으로 Linear한 데이터를 생성해보겠습니다.

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

X = 2 * np.random.rand(100,1)
y = 4+ 3*X + np.random.randn(100,1)

plt.plot(X, y, "b.")
plt.xlabel("$x_1$", fontsize=18)
plt.ylabel("$y$", rotation=0, fontsize=18)
plt.axis([0, 2, 0, 15])

plt.show()

이제 여기에서 생성된 $x_1$과 $y$를 Normal Equation에 대입하여 최적화된 $θ$를 구해보겠습니다.

아래 코드는 첫번째 줄에서 모든 데이터에 $x_0 = 1$을 추가한 후 np.linalg의 inv() 함수를 이용하여 역행렬(Inverse Matrix)를 만들고, dot() 메서드를 이용하여 Matrix 곱셈을 진행하였습니다.

X_b = np.c_[np.ones((100,1)), X] # np.c_ : 배열 붙이기, np.ones : array 생성 함수
theta_best = np.linalg.inv(X_b.T.dot(X_b)).dot(X_b.T).dot(y) #dot() : 행렬 곱셈

Normal Equation에 의해 최적화된 θ를 확인해보겠습니다.

theta_best

##결과값##
>>
array([[3.93328217],
       [3.08032243]])

사실 $θ_0 = 4$, $θ_1 = 3$을 기대했기 때문에 완전히 정확하다고 할 순 없겠지만, 매우 비슷합니다. 이제 최적화된 $θ$를 사용하여 예측을 해보겠습니다.

X_new = np.array([[0], [2]]) # 2차원 열 벡터
X_new_b = np.c_[np.ones((2,1)), X_new] # 모든 샘플에 x0 = 1을 추가
y_predict = X_new_b.dot(theta_best)
y_predict

##결과값##
>>
array([[ 3.93328217],
       [10.09392703]])

모델의 예측을 그래프에 나타내보겠습니다.

plt.plot(X_new, y_predict, "r-")
plt.plot(X, y, "b.")
plt.axis([0,2,0,15])
plt.show()

이번엔 잠시 Normal Equation은 접어두고, sklearn에서 Lienar Regression을 사용해보겠습니다. 보시다시피 매우 간단합니다.

from sklearn.linear_model import LinearRegression
lin_reg = LinearRegression()
lin_reg.fit(X, y)

lin_reg.intercept_, lin_reg.coef_ # .intercept_:추정된 상수항, .coef_ : 추정된 weight 벡터
>>
(array([4.27746389]), array([[2.91097464]]))

lin_reg.predict(X_new)
>>
array([[ 4.27746389],
       [10.09941316]])

sklearn의 LinearRegression 클래스는 scipy.linalg.lstsq()함수를 기반으로 하고, 이를 직접 호출할 수도 있습니다.

theta_best_svd, residuals, rank, s = np.linalg.lstsq(X_b, y, rcond=1e-6)
theta_best_svd

##결과값##
array([[4.27746389],
       [2.91097464]])

위에서 사용한 np.linalg.lstsq는 $θ=X^+*y$을 계산하여 최적화 된 $θ$를 도출합니다. 이때 $X^+$는 $X$의 유사 역행렬(pseudoinverse matrix)입니다. 이를 pseudoinverse matrix을 직접 구할 수도 있긴 합니다.

np.linalg.pinv(X_b).dot(y)

##결과값##
>>
array([[4.27746389],
       [2.91097464]])

여긴 수학적인 부분이므로 건너뛰어도 무방합니다.

pseudoinverse matrix는 특이값 분해(SVD)라는 Matrix 분해 기법을 사용하여 계산됩니다. SVD는 아래와 같이 Training set를 담은 Matrix $X$를 분해합니다.

Matrix A가 위로 길쭉한 직사각형 Matrix라면 아래와 같을 것입니다.

pseudoinverse matrix는 이 Matrix A를 아래와 같이 변형하여 도출되며, 그 형태는 아래와 같을 것입니다.

그렇다면 왜 np.linalg.lstsq는Normal Equation이 아닌 pseudoinverse matrix를 이용하여 parameter를 최적화하는 것일까요?

그 이유는 Normal Equation에서는 $X^T$를 필요로 하는데, Matrix의 행이 열보다 작거나(m < n), feature가 중복되는 Matrix는 Inverse Matrix를 가지지 않는 것이 가장 큰 이유입니다. Inverse Matrix와 달리 pseudoinverse matrix는 항상 구할 수 있습니다.

4.1.2 계산 복잡도

우리가 자료구조에서 빅오를 구하며, 메모리 사용의 효율성을 따지듯 머신러닝에서도 계산 복잡도를 이용하여 모델의 성능을 비교하는 것 또한 매우 중요합니다.

우선 Normal Equation은 $X^T*X$를 계산하는데 이는 $(n+1) * (n+1)$의 크기를 가집니다. 이러한 Inverse Matrix를 구하는 계산 복잡도는 $O(n^2.4)$에서 $O(n^3)$ 사이입니다. 이를 다시 말하면 feature가 2배로 늘어나면 계산 시간이 5.3배에서 8배 정도 증가됨을 의미합니다.

sklearn의 LinearRegression 클래스가 사용하는 SVD 방법은 $O(n^2)$입니다. 다시 말해서 feature가 두배가 되면 계산 시간은 4배가 됩니다.

앞에서는 훈련 방식에 따른 계산 속도의 차이를 알아봤습니다. 이제 이와 별개로 Linear Regression의 예측 속도는 데이터와 feature 수에 선형적입니다. 이는 매우 빠른 축에 속한다고 할 수 있습니다.

4.2 Gradient Descent Algorithm

우리는 현재 Linear Regression에서 θ를 최적화하는 첫번째 방식인 Normal Equation에 대해 알아보았습니다. 이제 가장 보편적으로 쓰이는 Gradient Descent Algorithm에 대해 알아보겠습니다.

Gradient Descent Algorithm의 아이디어는 loss function을 최소화하기 위해 반복적으로 θ를 조정하는 것입니다.

알고리즘을 단계화시켜 개념을 정립해보겠습니다.

1) 랜덤으로 θ를 정의하여 초기 위치를 정합니다.

2) θ에 대한 loss function의 기울기(gradient)를 계산하여 이 기울기가 감소하는 방향으로 θ를 조정합니다.

3) 기울기가 0이 되거나, 매우 가까울 때까지 2)를 반복합니다. 만약 0에 도달했다면 cost를 최소로 하는 최적화된 θ를 찾은 것입니다.

Gradient Descent Algorithm에서 중요한 하이퍼 파라미터는 learning rate입니다. learning rate는 한번 이동할 때 얼마나 이동하냐를 결정짓습니다.

만약 learning rate가 너무 작다면 알고리즘이 수렴하기 위해 매우 많이 반복해야 하므로 시간이 오래 걸립니다.

그렇다고 너무 크다면 오히려 알고리즘이 더 큰 값으로 발산하게 만들 수도 있습니다.

여기서 우리가 주목할 점은 모든 loss function이 위에서 본 그래프들처럼 무난한 포물선의 형태를 그리지 않는다는 것입니다. 만약 loss function이 훨씬 더 꼬불꼬불하여 복잡하다면 부분적으로 극소를 가지는 local minimum 그리고 전체에서 가장 최솟값을 가지는 지점인 global minimum 두가지가 존재하게 됩니다.

근데 만약 알고리즘이 왼쪽부터 시작하여 오른쪽으로 이동하는 과정에서 global minimum에 도달하기 전에 local minimum을 만나면 이곳에서 수렴하게 된다는 문제점이 있습니다.

다행스러운건 우리가 지금까지 다뤘던 Linear Regression에서 사용되는 loss function은 무난한 이차함수의 포물선 형태를 가지는 볼록 함수(convex function)입니다. 다시 말해서 local minimum 없이 global minimum만 존재한다는 뜻입니다.

이제 feature의 범위(scale)에 따라 loss function의 형태는 어떤지, 어떤 결과를 불러오는지 알아보겠습니다.

보통 loss function은 위에서 내려다 봤을 때 원 모양이지만, feature 간 scale이 매우 다르면 길쭉한 모양이 됩니다.

만약 일반적인 원 모양이라면 알고리즘이 global minimum으로 곧장 진행하고 있어 빠르게 수렴하게 됩니다. 그런데 오른쪽 그래프와 같이 길쭉할 경우 최솟값에는 수렴하겠으나, 시간이 오래 걸릴 것입니다.

4.2.1 Batch Gradient Descent

이제 Batch GD를 시작으로 몇가지 GD 알고리즘의 종류에 대해 알아보겠습니다. 그전에 우리가 앞에서 기울기를 줄이는 방향으로 이동한다는 말을 도식화하여 Gradient Descent Algorithm식을 확인하겠습니다.

우리가 현재 θ 지점에서의 loss function의 기울기라는 것은 loss function의 편도 함수로 구합니다.

만약 feature가 여러개라면 벡터를 이용해 한번에 계산할 수도 있겠습니다.

Batch GD는 θ를 조정하기 위한 기울기를 구할 때 Training data 전체를 사용합니다. 즉 우리는 매 스텝마다 기울기를 구해서 θ를 조정해나갈텐데, 만약 Training set이 매우 크다면 시간이 매우 오래 걸린다는 결론에 쉽게 도달할 수 있습니다.

우리가 알고리즘에서 minimum에 도달하기 위해서는 기울기가 구해지면 이것이 작아지는 방향으로 가야합니다. 여기서 각 스텝의 이동 속도를 결정하는 learning rate가 사용됩니다.

이를 간단히 구현해보고 최적화된 θ까지 바로 확인해보겠습니다.

eta = 0.1
n_iterations = 1000
m = 100

theta = np.random.randn(2,1)

for iteration in range(n_iterations):
  gradients = 2/m * X_b.T.dot(X_b.dot(theta) - y)
  theta = theta - eta * gradients

theta

##결과값##
>>
array([[4.27746389],
       [2.91097464]])

Normal Equation을 통해 도출했던 θ와 정확히 같습니다. 그렇다면 learnin rate가 달라짐에 따라 경사 하강 알고리즘의 스텝은 어떻게 나아가는지 그래프를 관찰해보겠습니다.

- learning rate가 작은 경우(왼쪽) : 최솟값엔 도달하겠지만 시간이 매우 오래걸릴 것입니다.

- learning rate가 적당한 경우(가운데) : 몇번의 반복만에 최솟값에 수렴하였습니다.

- learning rate가 클 경우(오른쪽) : 알고리즘이 이리저리 튀면서 스텝마다 최솟값에서 점점 멀어져 발산해갑니다.

그렇다면 적당한 learning rate는 어떻게 찾을 수 있을까요?

첫번재는 GridSearch를 사용합니다. 예를 들어, 0.000001부터 시작하여 10배로 불리며 각각의 결과를 관찰할 수 있겠습니다.

두번째는 반복 횟수를 크게 지정하고, 기울기 값이 어떤 ε라는 매우 작은 값보다 작으면 거의 minimum에 도달한 것으로 간주하고 중지하는 것입니다.

4.2.2 SGD

Batch GD의 가장 큰 문제는 매 스텝마다 전체 Training set을 계산해야 하기에 데이터셋이 클 경우 매우 느리다는 점이었습니다.

SGD는 매 스텝마다 전체 데이터셋이 아닌 하나의 데이터를 랜덤으로 선택하여 그 데이터에 대한 기울기를 계산합니다. 즉 매 스텝마다 사용하는 데이터가 작기 때문에 알고리즘이 매우 빠릅니다.

그러나 빠른만큼 훨씬 불안정합니다. 다시 말해 최솟값으로 도달할 때 위아래로 튀면서 감소합니다. 그 결과 완벽하게 global minimum에 도달하진 못합니다.

하지만 불안정하다는 의미는 local minimum을 건너뛸 수 있다는 의미이기도 합니다. 따라서 SGD가 Batch GD보다 global minimum에 도달할 확률이 더 큽니다.

그렇다면 SGD의 이러한 불안정성을 어떻게 해결할 수 있을까요?

첫번째 방식은 learning rate를 점진적으로 감소기키는 것입니다. 다시 말해서 처음에는 큰 보폭으로 최솟값으로 다가가다가, 어느 순간부터 좁은 보폭으로 global minimum에 세심하게 다가가는 기법입니다.

SGD를 구현해보겠습니다. 각 반복을 epoch라 하는데 아래 코드의 경우 1000번을 반복하도록 하는데 50번만 반복하고도 최솟값에 근접하게 도달한 케이스입니다.

n_epochs = 50
t0, t1 = 5, 50  # 학습 스케줄 하이퍼파라미터

def learning_schedule(t):
    return t0 / (t + t1)

theta = np.random.randn(2,1)  # 랜덤 초기화

for epoch in range(n_epochs):
    for i in range(m):
        if epoch == 0 and i < 20:                    
            y_predict = X_new_b.dot(theta)           
            style = "b-" if i > 0 else "r--"         
            plt.plot(X_new, y_predict, style)        
        random_index = np.random.randint(m)
        xi = X_b[random_index:random_index+1]
        yi = y[random_index:random_index+1]
        gradients = 2 * xi.T.dot(xi.dot(theta) - yi)
        eta = learning_schedule(epoch * m + i)
        theta = theta - eta * gradients
        theta_path_sgd.append(theta)              

plt.plot(X, y, "b.")                             
plt.xlabel("$x_1$", fontsize=18)                     
plt.ylabel("$y$", rotation=0, fontsize=18)           
plt.axis([0, 2, 0, 15])                              
save_fig("sgd_plot")                                 
plt.show()

theta

##결과값##
>>
array([[4.21076011],
       [2.74856079]])

첫 20번의 훈련스텝을 보겠습니다. 매우 불안정하다는 것 그리고 learning rate가 점점 줄어든다는 것을 알 수 있습니다.

n_epochs = 50
t0, t1 = 5, 50  # 학습 스케줄 하이퍼파라미터

def learning_schedule(t):
    return t0 / (t + t1)

theta = np.random.randn(2,1)  # 랜덤 초기화

for epoch in range(n_epochs):
    for i in range(m):
        if epoch == 0 and i < 20:                    
            y_predict = X_new_b.dot(theta)          
            style = "b-" if i > 0 else "r--"         
            plt.plot(X_new, y_predict, style)        
        random_index = np.random.randint(m)
        xi = X_b[random_index:random_index+1]
        yi = y[random_index:random_index+1]
        gradients = 2 * xi.T.dot(xi.dot(theta) - yi)
        eta = learning_schedule(epoch * m + i)
        theta = theta - eta * gradients
        theta_path_sgd.append(theta)                

plt.plot(X, y, "b.")                                 
plt.xlabel("$x_1$", fontsize=18)                     
plt.ylabel("$y$", rotation=0, fontsize=18)           
plt.axis([0, 2, 0, 15])                              
plt.show()

SGD의 경우 매 스텝마다 데이터를 랜덤으로 선택하기 때문에 어떤 데이터는 여러 번 선택되는 반면, 어떤 데이터는 한번도 반영되지 않을 수도 있습니다. 이를 방지하려면 epoch마다 데이터를 섞어주면 됩니다.

sklearn에서 SGD를 구현해보았습니다. 반복 횟수는 1000번, 0.001보다 cost가 작을때까지 반복합니다.(tol=1e-3), learning rate는 0.1로 설정하였습니다.

from sklearn.linear_model import SGDRegressor

sgd_reg = SGDRegressor(max_iter = 1000, tol = 1e-3, penalty = None, eta0 = 0.1)
sgd_reg.fit(X, y.ravel())

sgd_reg.intercept_, sgd_reg.coef_
>>
(array([4.24365286]), array([2.8250878]))

4.2.3 Mini-Batch Gradient Algorithm

이제 마지막으로 알아볼 알고리즘은 Mini-Batch Gradient Algorithm입니다. 이것은 Batch GD처럼 전체도 아니고, SGD처럼 하나도 아닌 mini-batch라 부르는 작은 데이터 세트에 대한 기울기를 계산합니다.

이 mini-batch를 크게하면, Batch GD에 가까워지므로 SGD에서 관찰됐던 불안정성이 조금씩 해결됩니다. 그러나 local minimum에 도달한 확률은 더욱 커집니다.

다음은 세 가지 Gradient Descent Algorithm의 훈련 과정을 그래프로 표현한 것입니다.

- Batch GD는 실제로 minimum에서 멈췄습니다. 그러나 SGD와 Mini-Batch GD는 근처에서 맴돕니다.

- Batch GD가 학습에 가장 많은 시간이 소요됩니다.

여기까지 Linear Regression의 원리와 구현, 그리고 Gradient Descent Algorithm의 종류와 원리 그리고 구현까지 알아보았습니다.

긴 글 읽어주셔서 감사합니다. 오늘도 행복한 하루 보내시길 바랍니다:)

[핸즈온 머신러닝 2판 ] MNIST를 활용한 다중 분류(Multi Class Classification)은 어떻게 하는 것일까?

Box형 — Mon, 20 Jul 2020 14:34:22 +0900

나머지 인생을 설탕물이나 팔면서 보내고 싶습니까

아니면 세상을 바꿔 놓을 기회를 갖고 싶습니까?

- 스티브 잡스 -

저번 포스팅에서는 MNIST 데이터셋을 활용하여 이진 분류(Bianry Classification)을 구현해보았습니다. 이번 포스팅에서는 같은 MNIST 데이터셋을 활용하여 둘 이상의 클래스를 구별할 수 있는 다중 분류(Multiclass Classifier)에 대해 공부해보겠습니다.

3.4 Multi-Class Classification

SGDClassifier, RandomClassifier, Naive Bayers 같은 일부 알고리즘들은 Multi-class Classification이 가능합니다. 그러나 Logistic Regression, SVM과 같은 알고리즘은 Binary Classification만 가능합니다. 그러나 여러 개의 Binary Classifier를 사용하여 Multiclass Classifier 구현이 가능합니다.

예를 들어 특성 숫자 하나만을 구분하는 10개의 Bianry Classifier(0~9)를 훈련시켜 클래스가 10개인 숫자 이미지 분류 시스템을 만들 수 있습니다. 여기에 이미지 분류 시 Decision score가 가장 높은 것을 클래스로 선택하게 됩니다. 이를 OvR(one vs rest) 혹은 OvA(one vs all)이라고 합니다.

클래스가 10개인 숫자 이미지 분류 시스템을 구현하는 또 하나의 방법은 0과 1 구별, 0과 2구별, 1과 2 구별 등 모든 숫자의 조합에 대해 Binary Classifier를 학습시키는 것입니다. 이를 OvO(one vs one)이라고 합니다. 즉 클래스가 $N$개라면 Classifier는 $N * (N-1)/2$개가 필요합니다.

MNIST의 경우 10개의 클래스가 존재하므로 45개의 Classifier를 훈련시켜야 할 것이고, 이미지 하나를 분류하기 위해선 이 45개의 Classifier를 모두 통과시킨 후 가장 높은 점수를 얻은 클래스를 선택하게 될것입니다. 이러한 OvO의 장점은 각 Classifier를 훈련시킬 때 전체 데이터가 아닌 구별을 위한 두가지 클래스에 대한 데이터만 들어간다는 점입니다.

이러한 OvO의 특징은 training set의 크기에 민감하여 작은 training set을 선호하는 SVM에서 효과적입니다. 그러나 대부분의 Binary Classification 알고리즘에서는 OvR을 선호합니다.

sklearn으로 Multiclass Classification 구현 시 Binary Classifier를 선택하면 알고리즘에 따라 자동으로 OvR 또는 OvO를 실행합니다. 이제 직접 SVM을 테스트 해보겠습니다.

from sklearn.svm import SVC

svm_clf = SVC()
svm_clf.fit(X_train, y_train)
svm_clf.predict([some_digit])

###결과값###
>>
array([5], dtype=uint8)

이제 sklearn이 실제로 OvO 방법을 사용하는지 확인해보겠습니다. decision_function()을 사용하면 1개가 아니라, 데이터 당 10개의 점수를 반환합니다. 즉 이 10개의 점수는 각 클래스 마다의 점수라는 것을 의미합니다.

some_digit_scores = svm_clf.decision_function([some_digit])
some_digit_scores

###결과값###
>>
array([[ 2.81585438,  7.09167958,  3.82972099,  0.79365551,  5.8885703 ,
         9.29718395,  1.79862509,  8.10392157, -0.228207  ,  4.83753243]])

이 10개 중 가장 높은 점수에 해당하는 것은 클래스 5입니다.

np.argmax(some_digit_scores)
>>
5

svm_clf.classes_
>>
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=uint8)

svm_clf.classes_[5]
>>
5

만약 sklearn에서 OvO나 OvR을 강제하고 싶다면 'OneVsRestClassifier'나 'OneVsOneClassifier'를 사용하면 됩니다. 사용 방법은 Binary 혹은 Multiclass Classifier 객체를 만들어 저 둘 중 하나에 인자로 던져주면 됩니다. 우선은 SVM부터 실행해보겠습니다.

from sklearn.multiclass import OneVsRestClassifier

ovr_clf = OneVsRestClassifier(SVC())
ovr_clf.fit(X_train, y_train)
ovr_clf.predict([some_digit])

###결과값###
>>
array([5], dtype=uint8)

len(ovr_clf.estimators_)
>>
10

SGDClassifier나 RnadomForestClassifier를 훈련시키는 것도 마찬가지입니다.

sgd_clf.fit(X_train, y_train)
sgd_clf.predict([some_digit])

###결과값###
>>
array([3], dtype=uint8)

decision_function()으로 SGD가 클래스마다 부여한 점수를 확인해보겠습니다. 대부분의 점수가 큰 음수라는 것은 Classifier가 예측 결과에 대한 강한 확신을 보인다는 뜻입니다. 다만 클래스가 4의 점수가 1823이라는 것은 분류기가 의심하고 있다는 뜻입니다.

sgd_clf.decision_function([some_digit])

###결과값###
>>
array([[-31893.03095419, -34419.69069632,  -9530.63950739,
          1823.73154031, -22320.14822878,  -1385.80478895,
        -26188.91070951, -16147.51323997,  -4604.35491274,
        -12050.767298  ]])

이제 Classifier의 성능을 평가해보겠습니다. 평가에는 일반적으로 'cross validation'을 사용합니다.

cross_val_score(sgd_clf, X_train, y_train, cv=3, scoring="accuracy")

###결과값###
>>
array([0.87365, 0.85835, 0.8689 ])

모든 fold가 84% 이상을 얻었습니다. 나쁘지는 않은 성능이지만 높일 여지는 있습니다. Input의 scale을 조정하여 accuracy를 높여보고자 합니다.

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train.astype(np.float64))
cross_val_score(sgd_clf, X_train_scaled, y_train, cv=3, scoring="accuracy")

###결과값###
>>
array([0.8983, 0.891 , 0.9018])

3.5 에러 분석

보통은 가장 좋은 몇가지 모델을 골라 하이퍼파라미터를 튜닝하겠지만, 지금은 가능성 높은 모델 하나를 찾았다고 가정하고 성능을 향상시킬 방법을 찾아보겠습니다. 한 가지 방법은 만들어진 에러의 종류를 분석하는 것입니다.

먼저 Confusion Matrix(오차 행렬)을 살펴보겠습니다.

y_train_pred = cross_val_predict(sgd_clf, X_train_scaled, y_train, cv=3)
conf_mx = confusion_matrix(y_train, y_train_pred)
conf_mx

###결과값###
>>
array([[5577,    0,   22,    5,    8,   43,   36,    6,  225,    1],
       [   0, 6400,   37,   24,    4,   44,    4,    7,  212,   10],
       [  27,   27, 5220,   92,   73,   27,   67,   36,  378,   11],
       [  22,   17,  117, 5227,    2,  203,   27,   40,  403,   73],
       [  12,   14,   41,    9, 5182,   12,   34,   27,  347,  164],
       [  27,   15,   30,  168,   53, 4444,   75,   14,  535,   60],
       [  30,   15,   42,    3,   44,   97, 5552,    3,  131,    1],
       [  21,   10,   51,   30,   49,   12,    3, 5684,  195,  210],
       [  17,   63,   48,   86,    3,  126,   25,   10, 5429,   44],
       [  25,   18,   30,   64,  118,   36,    1,  179,  371, 5107]])

정상적으로 출력되긴 했지만, 가독성이 조금 떨어집니다. 따라서 이 숫자를 이미지로 표현하여 가독성을 높이도록 하겠습니다.

plt.matshow(conf_mx, cmap = plt.cm.gray)
plt.show()

위 Confusion Matrix는 이미지들이 올바르게 분류되었음을 나타내는 주대각선에 있으므로 만족스러운 결과입니다. 그러나 숫자 5는 상대적으로 어두워보이는데, 이는 다른 숫자들만큼 Classification이 잘 되지 않았기 때문입니다.

그래프의 에러에 초점을 맞춰 Confusion Matrix의 각 값을 대응되는 클래스의 이미지 개수로 나누어 에러 비율을 비교합니다.

row_sums = conf_mx.sum(axis=1, keepdims=True)
norm_conf_mx = conf_mx / row_sums

이제 이미지로 표현할 건데 주대각선만 0으로 채우겠습니다. 행은 실제 클래스, 열은 예측한 클래스입니다. 클래스 8의 열이 밝다는 것은 많은 이미지들이 8로 잘못 분류되었음을 의미합니다.

np.fill_diagonal(norm_conf_mx, 0)
plt.matshow(norm_conf_mx, cmap=plt.cm.gray)
plt.show()

Confusion Matrix 분석 시 Classifier의 성능을 향상시킬 키를 찾을 수도 있습니다. 앞서 말했던 것과 같이 위 그래프를 통해 8로 잘못 분류되는 것을 계산할 필요가 있습니다. 예를 들어 8에 대한 데이터를 더 학습하거나, 8과 다른 숫자의 차이를 구별하여 해결하는 등 그 방법은 다양하게 존재하겠습니다.

좀 더 깊이 들어가 개개의 에러를 분석해보면 Classifier가 무슨 일을 하고, 왜 잘못되었는지에 대해 통찰은 얻겠지만, 난이도는 훨씬 높고 시간도 오래 걸릴 것입니다. 예를 들어 3과 5의 데이터들을 비교해보겠습니다.

cl_a, cl_b = 3, 5
X_aa = X_train[(y_train == cl_a) & (y_train_pred == cl_a)]
X_ab = X_train[(y_train == cl_a) & (y_train_pred == cl_b)]
X_ba = X_train[(y_train == cl_b) & (y_train_pred == cl_a)]
X_bb = X_train[(y_train == cl_b) & (y_train_pred == cl_b)]

plt.figure(figsize=(8,8))
plt.subplot(221); plot_digits(X_aa[:25], images_per_row=5)
plt.subplot(222); plot_digits(X_ab[:25], images_per_row=5)
plt.subplot(223); plot_digits(X_ba[:25], images_per_row=5)
plt.subplot(224); plot_digits(X_bb[:25], images_per_row=5)
plt.show()

Classifier가 분류한 일부는 정말 사람도 분간하기 어려울만큼 모양이 애매합니다. 그러나 일부를 제외한 대부분의 잘못 분류된 이미지는 확실히 에러인 것 같고, Classifier가 실수한 이유를 이해하기 어렵습니다.

사실 그 원인은 선형(Linear) 모델은 SGDClassifier를 사용했기 때문입니다. Linear model은 조금 축약해서 말하자면 픽셀 강도에 대한 가중치의 합을 클래스의 점수로 계산합니다. 따라서 모양이 유사한 3과 5는 몇개의 픽셀만 다를 것이므로 모델이 쉽게 혼동할 수 밖에 없습니다.

이러한 부분을 보완하기 위해서는 3과 5의 형태의 차이를 발견하여 데이터 전처리를 통해 혼동되지 않도록 해준다면 에러를 줄일 수 있을 것입니다.

3.6 Multi-Label Classification

지금까지는 하나의 데이터가 하나의 클래스에만 할당되었습니다. 그러나 Classifier에 따라 하나의 데이터가 여러 개의 클래스를 출력해야 할 때도 있습니다.

예를 들어 얼굴 인식 분류기를 생각해보겠습니다. 만약 하나의 사진에 여러 사람이 등장한다면 인식된 사람마다 하나의 클래스를 모두 지정하는게 맞을 것입니다. 구체적으로 Classifier가 앨리스, 밥, 찰리 세 얼굴을 인식하도록 훈련되어있을 때, 앨리스와 찰리가 있는 사진을 본다면 [1, 0, 1]을 출력해야 합니다. 이처럼 여러 개의 Binary 클래스를 출력하는 Classifier를 'Multi-Label Classification'이라고 합니다.

이해를 위해 간단한 예시를 들어보겠습니다. 아래 코드는 각 숫자 이미지에 두 개의 Label이 담긴 y_multilabel 배열을 만듭니다. 첫 번째 레이블은 숫자가 큰 값(7, 8, 9) 중 하나인지 나타내고, 두 번째는 홀수인지 나타냅니다. 그리고 그 다음줄에서 KNeighborsClassifier에 이 multilabel을 넣고 훈련시킵니다.

from sklearn.neighbors import KNeighborsClassifier

y_train_large = (y_train >= 7)
y_train_odd = (y_train % 2 == 1)
y_multilabel = np.c_[y_train_large, y_train_odd]

knn_clf = KNeighborsClassifier()
knn_clf.fit(X_train, y_multilabel)

예측을 만들면 두개의 Label이 출력 됩니다. 5는 7, 8, 9에 속하지 않고(False) 홀수이므로(True) 아래 결과는 맞다고 할 수 있습니다.

knn_clf.predict([some_digit])

###결과값###
>>
array([[False,  True]])

Multi-Label Classifier를 평가하는 방법은 많습니다. 다만 적절한 지표는 상황마다 다릅니다. 예를 들어 다음과 같이 모든 Label에 대한 F1 점수의 평균을 계산할 수 있겠습니다.

y_train_knn_pred = cross_val_predict(knn_clf, X_train, y_multilabel, cv=3)
f1_score(y_multilabel, y_train_knn_pred, average="macro")
>>
0.976410265560605

위 코드는 모든 레이블의 가중치(Weight)가 같다고 가정한 것입니다. Weight를 주는 가장 간단한 방법은 Label에 클래스의 지지도(support) 즉 각 Label에 속한 데이터의 수를 Weight로 주는 것입니다. 이를 위해서는 average="macro"를 "weighted"로 설정하면 됩니다.

3.7 Multi-output Classification

마지막으로 알아볼 Classification은 Multi-output Classification입니다. Multi-Label Classification에서 하나의 Label이 Multi-Class가 될 수 있도록 즉 두개 이상의 값을 가질 수 있도록 일반화한 것입니다.

이를 위해 이미지에서 Noise를 제거하는 시스템을 만들어보겠습니다. Noise가 많은 이미지를 Input으로 받고, Noise를 제거한 숫자 이미지를 MNIST 이미지처럼 픽셀의 강도를 담은 배열로 출력하겠습니다. 특히 하나의 픽셀이 하나의 Label이기 때문에 Classifier의 출력은 Multi-Label이고, 각 Label은 0~255사이의 값을 가집니다.

우선 Input으로 사용할 Noise 섞인 이미지를 만들기 위해 MNIST에서 나눈 training set과 test set 각각에 numpy의 randint() 함수를 사용하여 픽셀 강도에 잡음을 추가하겠습니다. 이에 대한 Label은 Noise가 없는 원본 이미지가 되겠습니다.

왼쪽이 Noise가 섞인 이미지(input), 오른쪽이 깨끗한 이미지(Label)

이제 Classifier를 훈련시켜 위 이미지를 깨끗하게 만들어보겠습니다.

knn_clf.fit(X_train_mode, y_train_mod)
clean_digit = knn_clf.predict([X_test_mod[some_index]])
plot_digit(clean_digit)

이것으로 Classification에 대한 설명을 마쳤습니다. 다음 포스팅에서는 지금까지는 구체적인 이해없이 지나쳤던 모델의 훈련에 대해 알아보는 시간을 가져보겠습니다.

긴 글 읽어주셔서 감사합니다. 행복한 하루 보내시길 바랍니다 :)

[핸즈온 머신러닝 2판] MNIST를 활용한 이진 분류(Binary Classification)은 어떻게 하는 것일까?

Box형 — Sun, 19 Jul 2020 12:51:33 +0900

이번 포스팅에서는 머신러닝 공부의 Hello World! 라고 부르는 데이터셋인 MNIST를 사용하여 분류(Classification) 작업을 하는 모델을 만들어보고자 합니다.

이번 포스팅은 아래 포스팅을 공부하시고 보시면 더욱 효과적입니다.

https://box-world.tistory.com/24

[머신러닝] 머신러닝 시스템 디자인 하기 : Precision, Recall, F score

시작하며 머신러닝 시스템을 디자인하면서 적용해볼 수 있는 방법들은 다양하게 존재합니다. 이번 포스팅에서는 여러 방법들 중에 하나의 최선의 방법을 골라 적용할지 판단하는 체계적인 방��

box-world.tistory.com

3.1 MNIST

MNIST 데이터셋은 고등학생과 미국 인구조사국 직원들이 손으로 쓴 70000개의 작은 숫자 이미지로 구성되어있습니다. 각 이미지에는 어떤 숫자를 나타내는지 Label은 붙어있지 않습니다. sklearn에서는 MNIST 데이터셋 등 일반적으로 알려진 데이터셋을 내려받을 수 있는 함수를 제공합니다.

from sklearn.datasets import fetch_openml

mnist = fetch_openml('mnist_784', version = 1)
mnist.keys()

###결과값###
>>
dict_keys(['data', 'target', 'frame', 'feature_names', 'target_names', 'DESCR', 'details', 'categories', 'url'])

sklearn이 읽어들인 데이터셋은 비슷한 딕셔너리 구조를 가지고 있습니다.

- DESCR : 데이터셋을 설명함

- data : 데이터가 하나의 행, feature가 하나의 열로 구성된 배열을 가짐

- target : label을 담아놓은 배열

직접 살펴보겠습니다.

X, y = mnist["data"], mnist["target"]
X.shape

###결과값###
>>
(70000, 784)

y.shape
###결과값###
>>
(70000,)

70000개의 이미지는 28 * 28 픽셀이기 때문에 784개의 feature를 가지고 있습니다. 각 feature는 0~255사이의 픽셀 강도를 나타냅니다. 하나의 이미지를 확인하기 위해서는 1) 이미지의 feature 벡터를 28 * 28 배열로 크기를 바꾸고, 2) matplotlib의 imshow() 함수를 사용해 그려줍니다.

import matplotlib as mpl
import matplotlib.pyplot as plt

some_digit = X[0]
some_digit_image = some_digit.reshape(28, 28)

plt.imshow(some_digit_image, cmap = "binary")
plt.axis("off")
plt.show()

위 이미지의 label을 확인해보겠습니다.

y[0]

###결과값###
>>
'5'

이때 label은 문자열입니다. 그러나 머신러닝 알고리즘에서는 숫자를 사용해야하기 때문에 y를 정수로 변환해줘야 합니다.

import numpy as np

y = y.astype(np.uint8)

아래에 보이는 전체적인 MNIST 이미지 샘플들을 보면 분류 작업이 매우 어려울 것이란 것을 직감할 수 있습니다.

def plot_digits(instances, images_per_row=10, **options):
    size = 28
    images_per_row = min(len(instances), images_per_row)
    images = [instance.reshape(size,size) for instance in instances]
    n_rows = (len(instances) - 1) // images_per_row + 1
    row_images = []
    n_empty = n_rows * images_per_row - len(instances)
    images.append(np.zeros((size, size * n_empty)))
    for row in range(n_rows):
        rimages = images[row * images_per_row : (row + 1) * images_per_row]
        row_images.append(np.concatenate(rimages, axis=1))
    image = np.concatenate(row_images, axis=0)
    plt.imshow(image, cmap = mpl.cm.binary, **options)
    plt.axis("off")
    
plt.figure(figsize=(9,9))
example_images = X[:100]
plot_digits(example_images, images_per_row=10)
save_fig("more_digits_plot")
plt.show()

이제 본격적인 훈련에 앞서 데이터셋을 6:1 비율의 training set과 test set으로 분리하겠습니다.

X_train, X_test, y_train, y_test = X[:60000], X[60000:],y[:60000],y[60000:]

참고로 데이터셋은 웬만하면 섞는게 좋습니다. 왜냐하면 어떤 알고리즘은 순서에 민감하여 비슷한 데이터가 연속으로 들어오면 성능이 나빠질 수 있기 때문입니다. 우리가 사용할 training set의 경우 이미 섞여 있어 별도의 함수를 사용하지 않았습니다.

2.3. 이진 분류기 훈련

문제를 단순화해서 이미지가 5이냐 아니냐 두개의 클래스를 분류하는 이진 분류기(Binary classifier)로 문제의 접근을 시작해보겟습니다.

우선 분류 작업을 위한 target vector를 만들어 보겠습니다.

y_train_5 = (y_train == 5) # 5는 True, 다른 숫자는 모두 False
y_test_5 = (y_test == 5)

이제 분류 모델을 만들어 훈련시켜보겠습니다. 우리가 첫 번째로 사용할 모델은 sklearn의 SGDClassifier 클래스의 확률적 경사 하강법(Stochastic Gradient Descent)입니다. SGD는 Loss function 계산 시 전체가 아닌 일부 데이터셋을 이용하기 때문에 속도가 빨라서 매우 큰 데이터셋을 다루는데 효과적입니다.

from sklearn.linear_model import SGDClassifier

sgd_clf  = SGDClassifier(random_state = 42)
sgd_clf.fit(X_train, y_train_5)

이제 훈련된 모델을 이용해 숫자 5의 이미지를 감지해보겠습니다.

sgd_clf.predict([some_digit])

###결과값###
>>
array([ True])

3.3 성능 측정

3.3.1 cross validation을 사용한 accuracy 측정

sklearn이 제공하는 기능보다 cross validation 과정을 더 많이 제어해야 한다면 직접 함수를 정의하면 됩니다.

- StratifiedFold는 클래스 비율이 유지되도록 fold를 만들어 줍니다.

- 매 반복에서 Classifier 객체를 복제하여 training fold로 훈련시키고, test fold로 예측을 만듭니다.

- 그 다음 올바른 예측의 수를 세어 정확한 예측의 비율을 출력 합니다.

from sklearn.model_selection import StratifiedKFold
from sklearn.base import clone
skfolds = StratifiedKFold(n_splits=3,random_state = 42)

for train_index, test_index in skfolds.split(X_train, y_train_5):
  clone_clf = clone(sgd_clf)
  X_train_folds = X_train[train_index]
  y_train_folds = y_train_5[train_index]
  X_test_fold = X_train[test_index]
  y_test_fold = y_train_5[test_index]

  clone_clf.fit(X_train_folds, y_train_folds)
  y_pred = clone_clf.predict(X_test_fold)
  n_correct = sum(y_pred == y_test_fold)
  print(n_correct / len(y_pred))

cross_val_score() 함수로 fold가 3개인 k-fold cross validation을 이용하여 SGDClassifier를 평가해보겠습니다.

from sklearn.model_selection import cross_val_score

cross_val_score(sgd_clf, X_train, y_train_5, cv = 3, scoring = "accuracy")

###결과값###
>>
array([0.95035, 0.96035, 0.9604 ])

모든 fold에 대한 accuracy가 95% 이상입니다. 성능이 매우 준수해보이는데 과연 그럴까요? Label에 상관없이 70000개의 모든 데이터를 5가 아니라고 분류하는 더미 분류기를 만들어 accuracy를 확인해보겠습니다.

from sklearn.base import BaseEstimator

class Never5Classifier(BaseEstimator):
  def fit(self, X, y=None):
    return self
  def predict(self, X):
    return np.zeros((len(X),1), dtype=bool) #0으로 초기화된 nparray 리턴

never_5_clf = Never5Classifier()
cross_val_score(never_5_clf, X_train, y_train_5, cv = 3, scoring = "accuracy")

###결과값###
>>
array([0.91125, 0.90855, 0.90915])

모두 5가 아니라고 예측했음에도 정확도가 90%가 넘습니다. 이미지의 10%가 5에 해당하기 때문에 다 아니라고 예측해도 맞출 확률이 90%이기 때문입니다. 여기에서 왜 classification을 다룰 때, accuracy를 성능 측정 지표로 사용하지 않는지 알려줍니다. 특히 클래스가 불균형한 데이터셋일수록 더욱 그렇습니다.

3.3.2 오차 행렬

Classification의 성능을 평가하는데 더 좋은 방법은 오차 행렬(Confusion matrix)입니다. 기본적인 아이디어는 클래스 A의 샘플이 클래스 B로 분류된 횟수를 세는 것입니다. 예를 들어서 Classifier가 숫자 5를 3으로 잘못 분류한 횟수를 알고 싶다면, 행렬의 5행 3열을 보면 됩니다.

Confusion matrix를 만드려면 실제 정답값과 비교할 수 있도록 예측값을 만들어야 합니다. 이때 주의할 점은 test set은 건드려선 안된다는 점입니다. 누차 강조하지만 test set는 프로젝트의 가장 마지막에 쓰입니다. 대신 cross_val_predict()를 사용할 수 있습니다.

cross_val_predict()는 cross_val_score()처럼 k-fold cross validation을 수행하지만, 점수 대신 각 test fold에서 얻은 예측을 반환합니다. 이를 다시 말하면 모든 training set에 대해 '깨끗한' 예측을 했다고 말할 수 있습니다. 즉 훈련 동안 보지 못했던 데이터에 대해 예측했다는 의미입니다.

from sklearn.model_selection import  cross_val_predict

y_train_pred = cross_val_predict(sgd_clf, X_train, y_train_5, cv = 3)

이제 실제 정답값과 예측값을 넣고 Confusion matrix를 호출해보겠습니다.

from sklearn.metrics import confusion_matrix

confusion_matrix(y_train_5, y_train_pred) #분류결과표

###결과값###
>>
array([[53892,   687],
       [ 1891,  3530]])

Confusion matrix는 네 가지 영역으로 구별됩니다. 행은 실제 클래스, 열은 예측한 클래스입니다.

True Positive(3530)는 실제 이미지가 5인데(Positive), 예측도 5로 한것입니다(Positive).

True Negative(53892)는 실제 이미지가 5가 아닌데(Negative), 예측값도 5가 아니라고 한것입니다.(Negative).

False Positive(687)는 실제값은 5인데(Positive), 예측값은 5가 아닌 경우입니다(Negative).

False Positive(1891)는 실제값은 5가 아닌데(Negative), 예측값은 5라고 한 경우입니다(Positive).

만약 Classifier가 완벽하다면 True Positive와 True Negative를 제외하고 다음과 같이 나머지는 0일 것입니다.

y_train_perfect_predictions = y_train_5
confusion_matrix(y_train_5, y_train_perfect_predictions)

###결과값###
>>
array([[54579,     0],
       [    0,  5421]])

Confusion Matrix에 대한 정보를 요약해 표현하는 두가지 중요한 지표는 Recall과 Precision입니다.

- Recall : 5라고 예측한 데이터들 중 실제 5인 데이터는 얼마나 들어있느냐 입니다.

- Precision : 실제로 5인 데이터들 중 예측값도 5라고 얼마나 잘 예측했느냐입니다.

3.3.3 Precision과 Recall

sklearn은 Precision과 Recall을 포함하여 Classifier의 지표를 계산하는 여러 함수를 제공합니다.

from sklearn.metrics import precision_score, recall_score

precision_score(y_train_5, y_train_pred)

###결과값###
>>
0.8370879772350012

recall_score(y_train_5,y_train_pred)

###결과값###
>>
0.6511713705958311

위 결과를 통해 우리의 모델은 전체 숫자 5에서 83%만 정확하게 5라고 예측했으며, 5라고 예측한 것중 65%만 실제 5였음을 알 수 있습니다.

여기에 한 단계 더 나아가 Precision과 Recall을 하나의 숫자로 표현한 지표인 F1 score가 있습니다.

from sklearn.metrics import f1_score

f1_score(y_train_5, y_train_pred)

###결과값###
>>
0.7325171197343846

보통 Precision과 Recall이 비슷하다면 F1 score가 높습니다. 그러나 상황에 따라 Precision과 Recall 중 더 중요한 지표가 있을 수 있습니다.

예를 들어 어린이에게 안전한 동영상을 걸러내는 Classifier를 만든다 한다면 Recall을 높여 나쁜 동영상이 몇개 노출되는 것보단 좋은 동영상이 제외되더라도(Low Recall) 안전한 것들만 노출시키는 것이 좋습니다(High Precision).

Precision과 Recall은 반비례 관계(trade-off)이므로 상황에 따라 충분히 고민하고 경중을 따지는게 좋습니다.

3.3.4 Precision/Recall trade-off

SGDClassifier가 어떻게 Classification하는지 보면서 Precision과 Recall의 trade off 관계를 이해해보겠습니다. 우리의 Classifier는 Decision Function을 사용하여 각 데이터의 점수를 계산합니다. 이 점수가 임곗값(threshold)보다 크면 Positive 클래스를 할당하고, 그렇지 않다면 Negative 클래스를 할당합니다.

Decision Threshold가 위 그림에서 두개의 숫자 5 사이라고 가정해보겠습니다. 이 기준선의 오른쪽에는 4개의 True Positive와 하나의 False Positive가 있습니다. 그러므로 이 threshold에서 Precision은 80%라 할 수 있습니다. 하지만 실제 숫자 5는 6개이고 이중 Classifier는 4개만 감지했으므로 Recall은 67%입니다.

Threshold를 높이면(오른쪽 방향으로 옮기면) False Positive였던 6이 True Negative가 되면서 Precision이 100%가 됩니다. 그러나 True Positive하나가 False Negatvie가 되면서 Recall은 50%로 줄어듭니다. 반대로 Threshold를 내리면 Recall이 높아지는대신 Precision이 줄어들 것입니다.

sklearn에서는 Threshold를 직접 지정할 수는 없지만, 예측에 사용한 점수는 확인할 수 있습니다. decision_function() 메서드를 호출하면 각 데이터의 점수를 알 수 있습니다. 그리고 이 점수를 기반으로 원하는 Threshold를 정하여 예측을 만들 수 있습니다.

y_scores = sgd_clf.decision_function([some_digit])
y_scores

###결과값###
>>
array([2164.22030239])

#threshold가 0일때

threshold = 0
y_some_digit_pred = (y_scores > threshold)
y_some_digit_pred

###결과값###
>>
array([ True])

이제 threshold를 높여보겠습니다. 보다시피 threshold가 0일 때는 감지되던 실제 5인 데이터가 threshold를 높이게 되면서 놓치게 됩니다.

threshold = 8000
y_some_digit_pred = (y_scores > threshold)
y_some_digit_pred

###결과값###
>>
array([False])

그렇다면 적절한 threshold는 어떻게 정할 수 있을까요? 1) 우선 cross_val_predict() 메서드를 이용하여 training set 내 모든 데이터의 점수를 구해야 합니다.

y_scores = cross_val_predict(sgd_clf, X_train, y_train_5, cv=3, method = "decision_function")

이제 위의 결과를 precision_recall_curve() 함수에 넣으면 모든 threshold에 대한 Precision과 Recall의 변화 추이를 알 수 있습니다.

from sklearn.metrics import precision_recall_curve

precisions, recalls, thresholds = precision_recall_curve(y_train_5, y_scores)

def plot_precision_recall_vs_threshold(precisions, recalls, thresholds):
    plt.plot(thresholds, precisions[:-1], "b--", label="Precision", linewidth=2)
    plt.plot(thresholds, recalls[:-1], "g-", label="Recall", linewidth=2)
    plt.legend(loc="center right", fontsize=16) # Not shown in the book
    plt.xlabel("Threshold", fontsize=16)        # Not shown
    plt.grid(True)                              # Not shown
    plt.axis([-50000, 50000, 0, 1])             # Not shown



recall_90_precision = recalls[np.argmax(precisions >= 0.90)]
threshold_90_precision = thresholds[np.argmax(precisions >= 0.90)]


plt.figure(figsize=(8, 4))                                                                  # Not shown
plot_precision_recall_vs_threshold(precisions, recalls, thresholds)
plt.plot([threshold_90_precision, threshold_90_precision], [0., 0.9], "r:")                 # Not shown
plt.plot([-50000, threshold_90_precision], [0.9, 0.9], "r:")                                # Not shown
plt.plot([-50000, threshold_90_precision], [recall_90_precision, recall_90_precision], "r:")# Not shown
plt.plot([threshold_90_precision], [0.9], "ro")                                             # Not shown
plt.plot([threshold_90_precision], [recall_90_precision], "ro")                             # Not shown                   
plt.show()

(아래 그래프에서 Precision 곡선이 중간에 울퉁불퉁한 이유는 threshold를 올리더라도 Precision이 낮아질 때가 있기 때문입니다. 예를 들어 가운데 Threshold에서 오른쪽으로 숫자 하나만큼 이동하면 4/5(80%)에서 3/4(75%)로 줄어들게 됩니다.)

혹은 Recall에 대한 Precision 곡선(PR)을 그릴 수도 있습니다. 아래 그림을 보시면 Recall이 80%인 부근에서 Precision이 급격하게 줄어들기 시작합니다. 이 부분 직전을 trade off로 선택하는 것이 좋습니다. 예를 들면 60% 부근이 여기에 해당될 수 있겠습니다.

만약 Precision 90%가 목표라면 최댓값의 첫번째 인덱스를 반환하는 np.argmax()를 이용하여 90%의 Precision을 만드는 가장 낮은 Threshold를 찾을 수 있습니다.

threshold_90_precision = thresholds[np.argmax(precisions >= 0.90)]
#~7816

training set에 대한 예측을 만듭니다.

y_train_pred_90 = (y_scores >= threshold_90_precision)

이 예측에 대한 Precsion과 Recall을 확인하면, Precision 90%를 실제로 달성했음을 볼 수 있습니다.

precision_score(y_train_5, y_train_pred_90)
>>
0.9000345901072293

recall_score(y_train_5, y_train_pred_90)
>>
0.4799852425751706

3.3.5 ROC 곡선

ROC 곡선도 Binary Classification에서 많이 쓰이는 도구 중 하나입니다. ROC 곡선은 False Positive 비율(FPR)에 대한 True Positive 비율(TPR, Recall의 다른 이름)의 곡선입니다. FPR은 1 - True Positive 비율(TPR)입니다. TPR은 특이도(specificity)라고도 합니다. 다시 말해서 ROC 곡선은 Recall에 대한 1 - specificity라고 할 수 있습니다.

ROC 곡선 사용을 위해서는 우선 roc_curve() 함수를 사용하여 여러 threshold에 대한 TPR과 FPR을 계산해야 합니다.

from sklearn.metrics import roc_curve

fpr, tpr, thresholds = roc_curve(y_train_5, y_scores)

그리고 matplotlib을 이용하여 TPR에 대한 FPR 곡선을 나타냅니다.

def plot_roc_curve(fpr, tpr, label=None):
    plt.plot(fpr, tpr, linewidth=2, label=label)
    plt.plot([0, 1], [0, 1], 'k--') # dashed diagonal
    plt.axis([0, 1, 0, 1])                                    # Not shown in the book
    plt.xlabel('False Positive Rate (Fall-Out)', fontsize=16) # Not shown
    plt.ylabel('True Positive Rate (Recall)', fontsize=16)    # Not shown
    plt.grid(True)                                            # Not shown

plt.figure(figsize=(8, 6))                         # Not shown
plot_roc_curve(fpr, tpr)
plt.plot([4.837e-3, 4.837e-3], [0., 0.4368], "r:") # Not shown
plt.plot([0.0, 4.837e-3], [0.4368, 0.4368], "r:")  # Not shown
plt.plot([4.837e-3], [0.4368], "ro")               # Not shown

plt.show()

TPR이 높을수록 Classifier가 만드는 FPR이 늘어납니다. 빨간색 점선은 데이터를 랜덤으로 분류하는 Classifier의 ROC 곡선입니다. 좋은 Classifier일수록 이 빨간색 점선에서 멀리 떨어져 있어야 합니다.

곡선 아래의 면적(AUC)를 측정하면 Classifier를 비교할 수 있습니다. 빨간 색 점선의 AUC는 0.5입니다.

from sklearn.metrics import roc_auc_score

roc_auc_score(y_train_5, y_scores)
>>
0.9604938554008616

그렇다면 어떨 때 ROC 곡선을 사용하고 어떨 때 Precision/Recall(PR) 곡선을 사용해야 할까요? 보통은 Positive 클래스가 드물거나, False Negative보다 False Positive가 더 중요할 때, 그러니까 예를 들어 보통 걸릴 확률이 아주 미비한 암 발병과 같은 것을 검출하는 상황에서는 PR 곡선을 씁니다. 그리고 그렇지 않으면 ROC 곡선을 사용합니다.

이제 RandomForestClassifier를 훈련시켜 SGDClassifier의 ROC 곡선과 ROC AUC 점수를 비교해보겠습니다. 우선 training set의 점수를 알아야 하는데 RandomForestClassifier에는 작동 방식의 차이로 decision_function() 대신 predict_proba() 메서드가 있습니다. 이는 데이터가 행, 클래스가 열이고 데이터가 주어진 클래스에 속할 확률을 담은 배열을 반환합니다.

from sklearn.ensemble import RandomForestClassifier

forest_clf = RandomForestClassifier(random_state = 42)
y_probas_forest = cross_val_predict(forest_clf, X_train, y_train_5, cv=3, method = "predict_proba")

roc_curve() 함수 사용을 위해서는 Label과 점수가 필요합니다. 그러나 점수 대신에 클래스 확률을 사용할 수 있기 때문에, Positive 클래스 확률을 점수로 사용해보겠습니다.

y_scores_forest = y_probas_forest[:, 1]
fpr_forest, tpr_forest, thresholds_forest = roc_curve(y_train_5, y_scores_forest)

이제 ROC 곡선을 그려보고 SGDClassifier와 RandomeForest를 비교해보겠습니다. 아래 그래프 결과를 보면 RandomForest의 결과가 훨씬 좋은 것을 확인할 수 있습니다.

plt.figure(figsize=(8, 6))
plt.plot(fpr, tpr, "b:", linewidth=2, label="SGD")
plot_roc_curve(fpr_forest, tpr_forest, "Random Forest")
plt.plot([4.837e-3, 4.837e-3], [0., 0.4368], "r:")
plt.plot([0.0, 4.837e-3], [0.4368, 0.4368], "r:")
plt.plot([4.837e-3], [0.4368], "ro")
plt.plot([4.837e-3, 4.837e-3], [0., 0.9487], "r:")
plt.plot([4.837e-3], [0.9487], "ro")
plt.grid(True)
plt.legend(loc="lower right", fontsize=16)
plt.show()

ROC AUC 점수도 훨씬 높을 수 밖에 없습니다.

roc_auc_score(y_train_5, y_scores_forest)
>>
0.9983436731328145

이번 포스팅에서는 Binary Classifier를 훈련ㅅ키는 것부터 다양한 지표를 이용하여 모델을 평가하는 법을 공부하였습니다. 다음 포스팅에서는 Multi Classifier에 대해 공부해보겠습니다.

긴 글 읽어주셔서 감사합니다. 행복한 하루 보내시길 바랍니다 :)

[ 핸즈 온 머신러닝 2판 ] pandas, sklearn을 통한 모델 학습과 튜닝은 어떻게 하는 것일까? (3)

Box형 — Thu, 16 Jul 2020 14:35:09 +0900

이전 2개의 포스팅에 결쳐 우리는 지금까지 문제를 정의하고 데이터를 읽어들여 탐색하였습니다. 그리고 데이터를 training set과 test set으로 나누고 학습을 위한 머신러닝 알고리즘에 주입할 데이터를 자동으로 전처리하고 정제하는 파이프라인까지 만들어 보았습니다.

이번 포스팅에서는 머신러닝 모델을 선택하고 훈련시켜 세부적으로 튜닝하는 법까지 다뤄보겠습니다.

box-world.tistory.com/42

[ 핸즈 온 머신러닝 2판 ] pandas, sklearn을 통한 데이터 전처리는 어떻게 하는걸까? (1)

발견에는 항상 뜻밖의 재미가 있다 - 제프 베조스(Amazon CEO) - Chapter 2 이번 포스팅을 시작으로 3번에 걸쳐 하나의 머신러닝 프로젝트가 어떻게 구성되고 진행되는지 알아보겠습니다. 우선 주요 단

box-world.tistory.com

box-world.tistory.com/43

[ 핸즈온 머신러닝 2판 ] pandas, sklearn을 통한 데이터 전처리는 어떻게 하는걸까? (2)

저번 포스팅에서는 캘리포니아 주택 가격 데이터셋을 가지고 pandas, sklearn을 이용하여 데이터의 특성을 탐색하고, 모델 학습을 위해 test set을 분리하는 다양한 방법에 대해 알아보았습니다. ��

box-world.tistory.com

2.6 모델 선택과 훈련

2.6.1 training set에서의 훈련 및 평가

우선 가장 대표적인 모델인 linear regression을 훈련시켜보겠습니다.

from sklearn.linear_model import LinearRegression

lin_reg = LinearRegression()
lin_reg.fit(housing_prepared, housing_labels)

이제 우리는 linear regression 모델을 만들었으니, training set의 일부 샘플을 넣어보겠습니다.

some_data = housing.iloc[:5]
some_labels = housing_labels.iloc[:5]
some_data_prepared = full_pipeline.transform(some_data)
print("예측: ", lin_reg.predict(some_data_prepared))

###결과값###
>>
예측:  [210644.60459286 317768.80697211 210956.43331178  59218.98886849
 189747.55849879]

print("레이블: ", list(some_labels))

###결과값###
>>
레이블:  [286600.0, 340600.0, 196900.0, 46300.0, 254500.0]

아주 정확한 예측은 아니지만, 어느정도 작동하는 것을 볼 수 있습니다. 이제 sklearn의 mean_sqaure_error 함수를 이용하여 전체 training set에 대한 이 linear regression 모델의 rmse를 측정해보겠습니다.

대부분 구역의 median house value가 $120000~$265000 사이인 것을 감안하면, $68628의 오차는 그리 좋은 편은 아닌 것 같습니다. 이러한 결과는 모델이 과소 적합(Underfit) 되었기 때문이며 이는 데이터가 부족하거나, 모델이 강력하지 못한 탓입니다. 우선 좀 더 복잡한 모델을 시도해서 어떻게 되는지 확인해보겠습니다.

from sklearn.metrics import mean_squared_error

housing_predictions = lin_reg.predict(housing_prepared)
lin_mse = mean_squared_error(housing_labels,housing_predictions)
lin_rmse = np.sqrt(lin_mse)
lin_rmse

###결과값###
>>
68628.19819848923

DecisionTreeRegressor를 훈련시켜보겠습니다. 이 모델은 강력하며, 데이터에서 복잡한 비선형관계를 찾을 수 있습니다.(DecisionTree에 대해서는 추후에 설명드리겠습니다.)

from sklearn.tree import DecisionTreeRegressor

tree_reg = DecisionTreeRegressor()
tree_reg.fit(housing_prepared, housing_labels)

이제 모델을 평가해보겠습니다. 0.0이라는 것은 오차가 없다는 뜻인데, 모델이 완벽할 리는 없고 아마 데이터가 심각하게 과대 적합(Overfit) 되었을 확률이 큽니다. 하지만 이 또한 확신할 수 없습니다. 따라서 우리는 training set에서 일부를 교차 검증(cross-validation) 데이터로 분리시켜 모델을 평가하는데 사용해야 합니다.

housing_predictions = tree_reg.predict(housing_prepared)
tree_mse = mean_squared_error(housing_labels, housing_predictions)
tree_rmse = np.sqrt(tree_mse)
tree_rmse

###결과값###
>>
0.0

2.6.2 Cross-Validation을 사용한 평가

DecisionTreeRegressor 모델을 이어서 계속 보겠습니다. 우선 이전에 정의했던 train_test_split 함수를 사용하여 training set을 더 작은 traing set과 cv set으로 나누고, training set에서는 모델 훈련을, cv set에서는 모델 평가가 이루어지게 하면 됩니다.

혹은 훌륭한 대안으로 sklearn의 k-fold cross-validation 기능을 사용할 수 있습니다. 이는 training set를 fold라 불리는 10개의 subset으로 무작위 분할합니다. 그 후 DecisionTree 모델을 10번 훈련하고 평가하는데, 이때 매번 다른 하나의 fold를 사용하여 평가하고 나머지 9개는 훈련에 사용됩니다. 그리고 10개의 평가 점수가 담긴 배열이 결과가 됩니다.

np.sqrt()에 -scores가 들어간 것은 cross_val_score() 메서드의 scoring 매개변수는 낮을수록 좋은 loss function이 아니라, 클수록 좋은 utility function을 기대합니다. 따라서 MSE의 반대 즉 음숫값을 계산하는 neg_mean_squared_error 함수를 사용합니다. 그래서 제곱근 계산을 위하여 -scores로 부호를 바꾼 것입니다.

from sklearn.model_selection import cross_val_score

scores = cross_val_score(tree_reg, housing_prepared, housing_labels,
                         scoring = "neg_mean_squared_error", cv=10)
tree_rmse_scores = np.sqrt(-scores)

아래 결과를 살펴보면 DecisionTreeRegressor의 결과가 이전만큼 좋아보이지 않습니다. 심지어 linear regression 모델보다 안좋습니다. 이를 통해 Cross-validation으로는 모델의 성능 추정뿐 아니라 이 추정이 얼마나 정확한지(표준편차)를 측정할 수 있습니다.

DecisionTree 점수가 71407에서 ±2439 사이입니다. cv set을 하나만 사용했다면 이를 알 수 없었을 것입니다. 그러나 모델을 여러 번 훈련시키는 것은 cost가 높으므로 이 점을 고려하며 사용해야겠습니다.

def display_scores(scores):
  print("점수:",scores)
  print("평균:",scores.mean())
  print("표준편차:",scores.std())

display_scores(tree_rmse_scores)

###결과값###
>>
점수: [69649.64460859 66090.16419858 70329.66447084 69160.83207592
 70549.37962702 73640.27705273 70815.59582659 70998.36764945
 76652.63720653 68576.3158628 ]
평균: 70646.28785790454
표준편차: 2711.925409096817

비교를 위해 linear regression 모델의 점수를 계산해보겠습니다. 확실히 DecisionTreeRegressor가 Overfit되어 성능이 나쁘다는 것을 알 수 있는 대목입니다.

lin_scores = cross_val_score(lin_reg, housing_prepared, housing_labels,
                             scoring="neg_mean_squared_error",cv=10)

lin_rmse_scores = np.sqrt(-lin_scores)
display_scores(lin_rmse_scores)

###결과값###
>>
점수: [66782.73843989 66960.118071   70347.95244419 74739.57052552
 68031.13388938 71193.84183426 64969.63056405 68281.61137997
 71552.91566558 67665.10082067]
평균: 69052.46136345083
표준편차: 2731.674001798344

마지막으로 RandomForestRegressor 모델을 하나 더 시도해보겠습니다. 이는 feature를 무작위로 선택하여 많은 DecisionTree를 만들고 그 예측들을 평균 내는 방식으로 작동합니다.

이렇게 여러 모델을 만들어 하나의 모델을 만드는 것을 앙상블 학습(Ensemble Learning)이라고 하며 머신러닝 알고리즘의 성능을 극대화하는 방식 중 하나입니다.

from sklearn.ensemble import RandomForestRegressor

forest_reg = RandomForestRegressor()
forest_reg.fit(housing_prepared, housing_labels)
housing_predictions = forest_reg.predict(housing_prepared)
forest_mse = mean_squared_error(housing_labels, housing_predictions)
forest_rmse = np.sqrt(forest_mse)
forest_rmse

###결과값###
>>
18790.050174547516

훨씬 훌륭해보입니다. 그러나 training set에 대한 점수가 cv set에 대한 점수보다 훨씬 낮다는 것은 training set에 여전히 Overfit되어 잇따는 의미입니다. 이러한 Overfit을 해결하려면 모델을 간단히 하거나, 더 많은 데이터를 모아야 합니다.

scores = cross_val_score(forest_reg, housing_prepared, housing_labels,
                         scoring = "neg_mean_squared_error", cv=10)
forest_rmse_scores = np.sqrt(-scores)
display_scores(forest_rmse_scores)

###결과값###
>>
점수: [49621.96770814 47698.25757407 50071.21751987 52311.76799284
 49529.02895964 53216.72302009 48755.50575797 47792.20315641
 53017.97804452 49841.16154041]
평균: 50185.58112739592
표준편차: 1912.3687121407233

특히 모델 선정 시 중요한 것은 하나의 모델을 오래 붙잡고 하이퍼파라미터 튜닝에 시간을 소요하기 전 2~5개 정도의 모델을 선정한 후 다양한 모델을 만들어보고 큰 그림을 그리는 것이 좋습니다.

다음은 실험한 sklearn 모델을 쉽게 저장할 수 있는 파이썬 패키지입니다.

import joblib

##모델 저장 시
joblib.dump(모델명,"my_model.pkl")

##모델 복원 시
my_model_loaded = joblib.load("my_model.pkl")

2.7 모델 세부 튜닝

이제 쓸만한 모델을 대충 추렸다고 가정하고, 이 모델들을 각각 세부 튜닝해보겠습니다.

2.7.1 그리드 탐색(Grid Search)

가장 단순한 방법은 만족할 만한 하이퍼 파라미터 조합을 찾을 때까지 수동으로 조정하는 것입니다.

sklearn의 GridSearchCV를 사용하면, 탐색하고자 하는 하이퍼파라미터와 시도해볼 값을 지정만 하면, 가능한 모든 하이퍼파라미터 조합에 대한 Cross-Validation을 사용해 평가합니다. 다음은 RandomForestRegressor에 대한 코드입니다. (보통 어떤 하이퍼파라미터 값을 지정해야 할지 모르겠다면 연속된 10의 거듭제곱(10, 100, 1000...)을 시도해보는 것이 좋습니다.)

param_grid에 따라 sklearn이 n_estimators와 max_features의 3 * 4 조합을 평가한 후, 두 번째 dict에 있는 2 * 3 조합을 시도합니다. 이를 모두 합하면 총 18개 조합을 탐색하고 cv = 5에 의해 각각 5번 모델을 훈련시킵니다. 즉 18 * 5 = 90번을 훈련시킵니다.

from sklearn.model_selection import GridSearchCV

param_grid = [
              {'n_estimators' : [3, 10, 30], 'max_features': [2, 4, 6, 8]},
              {'bootstrap':[False],'n_estimators':[3,10], 'max_features':[2,3,4]},
]

forest_reg = RandomForestRegressor()

grid_search = GridSearchCV(forest_reg, param_grid, cv=5,
                           scoring = 'neg_mean_squared_error',
                           return_train_score=True)

grid_search.fit(housing_prepared, housing_labels)

훈련을 시킨 후 다음과 같이 최적의 조합을 얻을 수 있습니다.

grid_search.best_params_

###결과값###
>>
{'max_features': 8, 'n_estimators': 30}

최적의 estimator에 직접 접근할 수도 있습니다.

grid_search.best_estimator_

###결과값###
>>
RandomForestRegressor(bootstrap=True, ccp_alpha=0.0, criterion='mse',
                      max_depth=None, max_features=8, max_leaf_nodes=None,
                      max_samples=None, min_impurity_decrease=0.0,
                      min_impurity_split=None, min_samples_leaf=1,
                      min_samples_split=2, min_weight_fraction_leaf=0.0,
                      n_estimators=30, n_jobs=None, oob_score=False,
                      random_state=None, verbose=0, warm_start=False)

그리고 18개의 조합에 대한 평가 점수도 확인할 수 있습니다. 어쨌든 우리는 이제 최적의 모델을 찾았습니다.

cvres = grid_search.cv_results_
for mean_score, params in zip(cvres["mean_test_score"],cvres["params"]):
print(np.sqrt(-mean_score),params)
  
###결과값###
>>
62600.75458160353 {'max_features': 2, 'n_estimators': 3}
55591.35252026881 {'max_features': 2, 'n_estimators': 10}
52846.87575009015 {'max_features': 2, 'n_estimators': 30}
59730.917651981195 {'max_features': 4, 'n_estimators': 3}
52997.7576498801 {'max_features': 4, 'n_estimators': 10}
50563.70361731654 {'max_features': 4, 'n_estimators': 30}
59290.062986907295 {'max_features': 6, 'n_estimators': 3}
51769.540932619544 {'max_features': 6, 'n_estimators': 10}
50116.10761043424 {'max_features': 6, 'n_estimators': 30}
59543.28349500444 {'max_features': 8, 'n_estimators': 3}
51715.32187214485 {'max_features': 8, 'n_estimators': 10}
49920.36274608907 {'max_features': 8, 'n_estimators': 30}
62010.100776085696 {'bootstrap': False, 'max_features': 2, 'n_estimators': 3}
54309.058249698515 {'bootstrap': False, 'max_features': 2, 'n_estimators': 10}
59237.80817701035 {'bootstrap': False, 'max_features': 3, 'n_estimators': 3}
52482.66370840826 {'bootstrap': False, 'max_features': 3, 'n_estimators': 10}
58842.04223735213 {'bootstrap': False, 'max_features': 4, 'n_estimators': 3}
51687.84566902621 {'bootstrap': False, 'max_features': 4, 'n_estimators': 10}

2.7.2 Random Search

Grid Search는 위에서 본 적은 수의 조합을 탐구할 때 괜찮습니다. 그러나 탐색의 조합 수가 커지면 RandomizedSearchCV를 사용하는 편이 더 좋습니다. RandomizedSearchCV는 GridSearchCV와 거의 같은 방식으로 사용하지만, 모든 조합을 시도하는 대신 각 반복마다 하이퍼파라미터에 임의의 수를 대입하여 지정한 횟수만큼 평가합니다.

from sklearn.model_selection import RandomizedSearchCV
from scipy.stats import randint

param_distribs = {
        'n_estimators': randint(low=1, high=200),
        'max_features': randint(low=1, high=8),
    }

forest_reg = RandomForestRegressor(random_state=42)
rnd_search = RandomizedSearchCV(forest_reg, param_distributions=param_distribs,
                                n_iter=10, cv=5, scoring='neg_mean_squared_error', random_state=42)
rnd_search.fit(housing_prepared, housing_labels)

###결과값###
>>
RandomizedSearchCV(cv=5, error_score=nan,
                   estimator=RandomForestRegressor(bootstrap=True,
                                                   ccp_alpha=0.0,
                                                   criterion='mse',
                                                   max_depth=None,
                                                   max_features='auto',
                                                   max_leaf_nodes=None,
                                                   max_samples=None,
                                                   min_impurity_decrease=0.0,
                                                   min_impurity_split=None,
                                                   min_samples_leaf=1,
                                                   min_samples_split=2,
                                                   min_weight_fraction_leaf=0.0,
                                                   n_estimators=100,
                                                   n_jobs=None, oob_score=Fals...
                                                   warm_start=False),
                   iid='deprecated', n_iter=10, n_jobs=None,
                   param_distributions={'max_features': <scipy.stats._distn_infrastructure.rv_frozen object at 0x7f20324dfeb8>,
                                        'n_estimators': <scipy.stats._distn_infrastructure.rv_frozen object at 0x7f20324df668>},
                   pre_dispatch='2*n_jobs', random_state=42, refit=True,
                   return_train_score=False, scoring='neg_mean_squared_error',
                   verbose=0)

cvres = rnd_search.cv_results_
for mean_score, params in zip(cvres["mean_test_score"], cvres["params"]):
    print(np.sqrt(-mean_score), params)
    
###결과값###
>>
49150.70756927707 {'max_features': 7, 'n_estimators': 180}
51389.889203389284 {'max_features': 5, 'n_estimators': 15}
50796.155224308866 {'max_features': 3, 'n_estimators': 72}
50835.13360315349 {'max_features': 5, 'n_estimators': 21}
49280.9449827171 {'max_features': 7, 'n_estimators': 122}
50774.90662363929 {'max_features': 3, 'n_estimators': 75}
50682.78888164288 {'max_features': 3, 'n_estimators': 88}
49608.99608105296 {'max_features': 5, 'n_estimators': 100}
50473.61930350219 {'max_features': 3, 'n_estimators': 150}
64429.84143294435 {'max_features': 5, 'n_estimators': 2}

2.7.3 앙상블 방법

모델 튜닝의 또 다른 방법은 최상의 모델을 연결해보는 것입니다. 다시 말해서 DecisionTree의 앙상블 모델인 RandomForest가 성능이 더 좋은 것처럼 모델의 그룹이 최상의 단일 모델보다 더 나은 성능을 발휘할 때가 많습니다. 특히 개개의 모델이 각기 다른 형태의 오차를 만들 때 더욱 그렇습니다.

2.7.4 최상의 모델과 오차 분석

최상의 모델을 분석하면 문제에 대한 좋은 통찰을 얻는 경우가 많습니다. 예를 들어 RandomForestregressor가 정확한 예측을 만들기 위한 각 feature의 상대적인 중요도를 알려줍니다.

feature_importances = grid_search.best_estimator_.feature_importances_
feature_importances

###결과값###
>>
array([7.08371932e-02, 6.56756347e-02, 4.27773453e-02, 1.52918532e-02,
       1.38124536e-02, 1.50121082e-02, 1.44797217e-02, 3.56732982e-01,
       5.52871544e-02, 1.15384814e-01, 6.37338038e-02, 6.96180139e-03,
       1.58719639e-01, 6.57055394e-05, 2.13890180e-03, 3.08888805e-03])

가독성을 위해 각 중요도에 대응하는 feature를 함께 출력해보겠습니다. 아래 정보를 바탕으로 덜 중요한 특성들은 제외할 수도 있습니다.

이렇게 시스템이 특정 오차를 만들었다면 feature를 추가하거나, 제거하거나, 이상치(Anomaly data)를 지우는 등 문제를 해결하는 방법을 찾으려 해야합니다.

extra_attribs = ["rooms_per_hhold", "pop_per_hhold", "bedrooms_per_room"]
cat_encoder = full_pipeline.named_transformers_["cat"]
cat_one_hot_attribs = list(cat_encoder.categories_[0])
attributes = num_attribs + extra_attribs + cat_one_hot_attribs
sorted(zip(feature_importances,attributes),reverse=True)

###결과값###
>>
[(0.35673298193099007, 'median_income'),
 (0.1587196393569354, 'INLAND'),
 (0.11538481389295871, 'pop_per_hhold'),
 (0.07083719317436987, 'longitude'),
 (0.06567563468470206, 'latitude'),
 (0.06373380379050103, 'bedrooms_per_room'),
 (0.05528715436665197, 'rooms_per_hhold'),
 (0.04277734534225705, 'housing_median_age'),
 (0.015291853205156254, 'total_rooms'),
 (0.015012108190849801, 'population'),
 (0.014479721702475657, 'households'),
 (0.013812453588641672, 'total_bedrooms'),
 (0.006961801391129748, '<1H OCEAN'),
 (0.0030888880452384668, 'NEAR OCEAN'),
 (0.002138901797746015, 'NEAR BAY'),
 (6.570553939631248e-05, 'ISLAND')]

2.7.5 Test set로 시스템 평가하기

어느 정도 모델 튜닝을 통해 만족할 만한 모델을 얻었으니 이제는 test set을 이용하여 최종 모델을 평가해보겠습니다.

우선 test set에서 예측 변수와 label을 얻은 후 이전에 만들었던 full_pipeline을 사용해 데이터를 변환합니다. 이때 test set에서 training하면 안되기 때문에 fit_transform()이 아닌 transform()입니다. 그리고 test set에서 최종 모델을 평가합니다.

final_model = grid_search.best_estimator_

X_test = strat_test_set.drop("median_house_value",axis=1)
y_test = strat_test_set["median_house_value"].copy()

X_test_prepared = full_pipeline.transform(X_test)

final_predictions = final_model.predict(X_test_prepared)

final_mse = mean_squared_error(y_test, final_predictions)
final_rmse = np.sqrt(final_mse)

###결과값###
>>
47730.0

이렇게 우리는 3번의 포스팅에 걸쳐 하나의 머신러닝 프로젝트 안에서 데이터를 가져와 특징을 파악하고, 전처리하여 모델 훈련 후 튜닝까지 하는 법을 대략적으로 살펴보았습니다.

긴 글 읽어주셔서 감사합니다. 오늘도 행복한 하루 보내시길 바랍니다:)

[ 핸즈온 머신러닝 2판 ] pandas, sklearn을 통한 데이터 전처리는 어떻게 하는걸까? (2)

Box형 — Wed, 15 Jul 2020 16:37:17 +0900

저번 포스팅에서는 캘리포니아 주택 가격 데이터셋을 가지고 pandas, sklearn을 이용하여 데이터의 특성을 탐색하고, 모델 학습을 위해 test set을 분리하는 다양한 방법에 대해 알아보았습니다.

이번 포스팅에서는 데이터를 탐색하고 시각화하는 것부터 데이터를 전처리 하는 과정까지 다뤄보도록 하겠습니다.

box-world.tistory.com/42

[ 핸즈 온 머신러닝 2판 ] pandas, sklearn을 통한 데이터 전처리는 어떻게 하는걸까? (1)

box-world.tistory.com

2.4 데이터 이해를 위한 탐색과 시각화

우선 데이터셋에서 training set만 떼서 탐색을 진행하겠습니다. 보통 데이터가 크다면 training set 중에서도 일부를 떼어 탐색용 subset을 만들기도 하지만 우리는 전체 training set을 사용하겠습니다.

housing = strat_train_set.copy()

2.4.1 지리적 데이터 시각화

데이터셋에 위도(longitude)와 경도(latitude)에 해당하는 지리정보가 있으므로 이를 산점도(Scatter)를 이용하여 시각화하겠습니다. 산점도란 두개 변수간의 관계를 직교 좌표계 위에 나타낸 그래프를 의미합니다.

위 그림 자체로는 특별한 패턴을 찾기 어려울 것입니다. 여기에 alpha 옵션을 주면 군집도를 통해 패턴을 찾아낼 수 있습니다.

이제 여기에 주택 가격을 나타내보겠습니다. 원의 반지름은 구역의 인구, 그리고 파란색에서 빨간색으로 갈수록 높은 가격을 가지는데 이를 함수에서 cmpa = get_cmap("jet")로 표현합니다.

그래프를 보면 인구 밀도와 주택 가격이 밀접하게 관련되어 있다는 것을 알 수 있습니다.

2.4.2 상관관계 조사

데이터셋이 너무 크지 않기 때문에 feature 간의 표준 상관계수(Standard correlation coefficient)를 corr() 함수를 이용해 쉽게 계산할 수 있습니다.

corr_matrix = housing.corr()

이제 중간 주택 가격(median_house_value)와 다른 특성 간의 상관관계의 크기에 대해 알아보겠습니다. 상관관계의 범위는 (-1,1) 사이이며 1에 가까울수록 강한 양의 상관관계를 의미합니다. 그리고 0에 가까울수록 선형적인 상관관계가 없다고 할 수 있습니다.

- 중간 주택 관계와 위도는 약한 음의 상관관계를 보입니다.

다음은 두 변수간에 가질 수 있는 다양한 상관관계의 형태를 보여줍니다. 주의할 것은 우리가 위에서 확인한 상관계수는 선형적인 상관관계만 측정합니다. 즉 아래 세번째 줄과 같은 비선형적인 상관관계는 잡지 못하고 0에 가까운 값으로 도출되게 됩니다.

feature간 상관관계를 확인하는 또 다른 방법은 pandas의 scatter_matrix를 이용하여 숫자형 특성 사이에 산점도를 그리는 것입니다. 아래서 그 일부를 보도록 하겠습니다.

왼쪽 위에서 오른쪽 아래로가는 대각선은 자기 자신에 대한 상관관계이므로 직선이 되는 것이기에 무시하셔도 됩니다. 아래에서 우리가 주목할 것은 첫번째 줄의 두번째 그래프인 중간 소득(median_income)과 중간 주택 가격의 관계이니 이를 확대에서 다시 살펴보겠습니다.

from pandas.plotting import scatter_matrix

attributes = ["median_house_value", "median_income", "total_rooms",
              "housing_median_age"]
              
scatter_matrix(housing[attributes], figsize=(12,8))

- 중간 소득이 커질수록 중간 주택 가격이 상승하는 강한 상관관계를 보여주며, 포인트들이 너무 멀리 퍼져있지 않습니다.

- 중간 주택 가격이 500000인 부분에서 수평선이 나타나는 이유는 가격 제한을 500000 이하로 두었기 때문입니다. 이 외에 350000, 280000에서 보이는 수평선은 면밀히 살펴보고 이상한 형태의 학습이 있었다면 이를 지워야 합니다.

2.4.3 feature 조합으로 실험

모델 학습을 위해 데이터를 준비하는 과정에서 마지막으로 해볼 수 잇는 것은 여러 feature 조합을 시도해보는 것입니다. 이 부분에 대해서는 단순히 코딩이 아니라 feature간의 의미를 생각하며 어떤 features를 결합해야 유의미한 결과를 얻을 수 있을지 생각해야 합니다.

예를 들어 특정 구역의 방 개수 자체는 해당 지역의 가구 수를 모른다면 의미가 없을 것입니다. 이렇나 맥락에서 가구당 방 개수를 도출해볼 수 있습니다. 다음에서 이런 특성들을 만들어 corr_matrix를 확인해보겠습니다.

- 새롭게 추가한 bedrooms_per_room은 total_bedrooms나 total_rooms보다 중간 주택 가격과의 상관관계가 훨씬 높습니다.

housing["rooms_per_household"] = housing["total_rooms"]/housing["households"]
housing["bedrooms_per_room"] = housing["total_bedrooms"]/housing["total_rooms"]
housing["population_per_household"]=housing["population"]/housing["households"]

corr_matrix = housing.corr()
corr_matrix["median_house_value"].sort_values(ascending=False)


###결과값###
>>
median_house_value 1.000000
median_income 0.687160
rooms_per_household 0.146285
total_rooms 0.135097
housing_median_age 0.114110
households 0.064506
total_bedrooms 0.047689
population_per_household -0.021985
population -0.026920
longitude -0.047432
latitude -0.142724
bedrooms_per_room -0.259984
Name: median_house_value, dtype: float64

지금까지 데이터를 탐색하는 몇 단계를 거쳐보았습니다. 하지만 머신러닝에서는 한번에 끝나는 일은 잘 없습니다. 최대한 빨리 이러한 프로토타입을 만들어 데이터에 대한 통찰을 얻고, 다시 이러한 과정을 반복하며 유의미한 결과를 계속해서 뽑아내는 과정을 거쳐야 합니다.

2.5 머신러닝 알고리즘을 위한 데이터 준비

이제 머신러닝 알고리즘을 위해 데이터를 만들어 보겠습니다. 중요한 것은 이러한 작업은 자동화되어야 하는데 다음은 그 이유입니다.

- 어떤 데이터셋이 주어져도 쉽게 데이터를 변환할 수 있습니다.

- 프로젝트에서 앞으로 사용할 다양한 변환 라이브러리로 활용될 수 있습니다.

- 여러 가지 데이터 변환을 쉽게 하며 어떤 조합이 가장 좋은지 확인하는데 편리합니다.

우선 앞서서 생성한 strat_train_set에서 데이터 변형이 label에도 적용되는 것을 방지하기 위해 label인 median_house_value를 training set에서 분리하겠습니다.

housing = strat_train_set.drop("median_house_value",axis=1)
housing_labels = strat_train_set["median_house_value"].copy()

2.5.1 데이터 정제

데이터 정제란 전처리가 완료된 데이터에 대해 빈값(결측치)이나 정상 범위를 벗어난 값(이상치)들을 제거하거나 다른 값으로 대체하는 처리 과정을 의미합니다.

우선 앞서서 total_bedrooms에 누락된 값이 있었습니다. 누락된 값은 다음 세 가지 방식으로 처리할 수 있습니다.

- 해당 구역을 제거하기

- 전체 feature 삭제

- 특정 값을 채우기(0, median, mean etc...)

이러한 작업은 pandas의 2차원 테이블 구조인 DataFrame의 다양한 메서드를 이용하여 간단하게 처리가 가능합니다.

housing.dropna(subset=["total_bedrooms"]) # 누락된 데이터가 들어있는 구역은 제거
housing.drop("total_bedrooms",axis=1) # feature 삭제

median = housing["total_bedrooms"].median() # median으로 채우기
housing["total_bedrooms"].fillna(median,inplace = True)

혹은 sklearn의 SimpleImputer로 누락된 값을 다룰 수 있습니다. strategy = "median"으로 누락된 값을 중간값으로 대체할 것을 지정합니다.

from sklearn.impute import SimpleImputer

imputer = SimpleImputer(strategy="median")

SimpleImputer를 적용하기 앞서 수치형(categorical) 특성인 ocean_proximity를 제외한 복사본에 적용하겠습니다.

housing_num = housing.drop("ocean_proximity",axis=1)

이제 imputer에 데이터셋을 인자로 주면 각 feature의 median을 statistics_ 속성에 저장합니다.

imputer.fit(housing_num)

imputer.statistics_

###결과값###
>> array([ -118.51 , 34.26 , 29. , 2119.5 , 433. , 1164. , 408. , 3.5409])

마지막으로 transform() 메서드로 데이터셋에 적용해주면 됩니다.

X = imputer.transform(housing_num)

X는 numpy 배열입니다. 이를 다시 pandas DataFrame으로 되돌릴 수 있습니다.

housing_tr = pd.DataFrame(X, columns=housing_num.columns,
                          index = housing_num.index)

좀 더 공부하기에 앞서 sklearn의 'estimator'와 'trasformer' 개념에 대해서 간단히 짚고 가겠습니다.

estimator는 input data에서 새롭게 추정된 데이터로 fit() 메서드가 사용됩니다. transformer는 input data를 변형하며 transform() 메서드가 사용됩니다. 예를 들어 앞서 사용한 imputer 객체는 estimator, imputer 자체는 transformer라고 할 수 있습니다.

2.5.2 텍스트와 범주형 특성 다루기

이제 수치형 feature가 아닌 유일한 categorical feature인 ocean_proximity에 대해 다뤄보겠습니다. 우선 처음 10개 데이터에서 이 feature 값을 확인해보겠습니다.

housing_cat = housing[["ocean_proximity"]]

housing_cat.head(10)

###결과값###
>>
17606 <1H OCEAN
18632 <1H OCEAN
14650 NEAR OCEAN
3230 INLAND
3555 <1H OCEAN
19480 INLAND
8879 <1H OCEAN
13685 INLAND
4937 <1H OCEAN
4861 <1H OCEAN

대부분의 머신러닝 알고리즘은 숫자를 다루기 때문에 이러한 categorical feature는 텍스트에서 숫자로 바꿔줄 필요가 있습니다. 이를 위해 sklearn의 OridinalEncoder 클래스를 사용합니다.

from sklearn.preprocessing import OrdinalEncoder

ordinal_encoder = OrdinalEncoder()
housing_cat_encoded = ordinal_encoder.fit_transform(housing_cat)
housing_cat_encoded[:10]

###결과값###
>>
array([[0.],
       [0.],
       [4.],
       [1.],
       [0.],
       [1.],
       [0.],
       [1.],
       [0.],
       [0.]])

그리고 이렇게 변환된 array에서 categories_ 인스턴스 변수를 이용하면 카테고리 목록 확인이 가능합니다.

ordinal_encoder.categories_

###결과값###
>>
[array(['<1H OCEAN', 'INLAND', 'ISLAND', 'NEAR BAY', 'NEAR OCEAN'],
       dtype=object)]

위 표현 방식의 문제점은 알고리즘이 가까이 있는 두값이 떨어져있는 두 값보다 더 비슷하다고 생각한다는 점입니다(['bad', 'average', 'good', 'excellent']와 같은 경우).

그래서 대부분의 categorical feature에 대해 숫자로 변환할 때는 one-hot encoding 방식을 사용합니다. 예를 들어 카테고리가 <1H OCEAN>이라면 이는 1을 가지고 나머지 feature는 모두 0을 가지는 벡터가 해당 데이터가 어느 카테고리에 속하는지 표현하는 방식이 되는 것입니다.

이때 출력은 numpy array가 아니라 sparse matrix라는데 주목해야합니다. 즉 앞서 말했던 하나만 1이고 나머지는 0으로 채워져있는 벡터의 형태를 의미하는 것이빈다. 그러나 0을 모두 메모리에 저장하는 것은 비효율적이므로 sparse index는 0이 아닌 원소의 위치만을 저장합니다.

from sklearn.preprocessing import OneHotEncoder
cat_encoder = OneHotEncoder()
housing_cat_1hot = cat_encoder.fit_transform(housing_cat)
housing_cat_1hot

###결과값###
>>
<16512x5 sparse matrix of type '<class 'numpy.float64'>'
	with 16512 stored elements in Compressed Sparse Row format>

이를 numpy 배열로 바꾸고 싶다면 다음과 같이 할 수 있습니다.

housing_cat_1hot.toarray()

###결과값###
>>
array([[1., 0., 0., 0., 0.],
       [1., 0., 0., 0., 0.],
       [0., 0., 0., 0., 1.],
       ...,
       [0., 1., 0., 0., 0.],
       [1., 0., 0., 0., 0.],
       [0., 0., 0., 1., 0.]])

이렇게 변환한 numpy 배열에서도 categories_ 인스턴스 변수가 적용됩니다.

cat_encoder.categories_

###결과값###
>>
[array(['<1H OCEAN', 'INLAND', 'ISLAND', 'NEAR BAY', 'NEAR OCEAN'],
       dtype=object)]

2.5.3 나만의 변환기

sklearn이 유용한 transformer를 제공하지만, 상황에 따라 특정 작업을 위해 우리가 직접 transformer를 만들어야 할수도 있습니다. 이를 위해 내가 만든 transformer가 sklearn과 매끄럽게 연동되길 원한다면 fit(), transform(), fit_transform() 메서드가 구현된 클래스를 만들면 됩니다. 다음은 간단한 변환기입니다.

아래는 transformer가 add_bedrooms_per_room 하이퍼파라미터를 하나 가지며 기본값은 True입니다.

from sklearn.base import BaseEstimator, TransformerMixin

rooms_ix, bedrooms_ix, population_ix, households_ix = 3,4,5,6

class CombineAttirbutesAdder(BaseEstimator, TransformerMixin):
  def __init__(self, add_bedrooms_per_room = True):
    self.add_bedrooms_per_room = add_bedrooms_per_room
  def fit(self, X, y=None):
    return self
  def transform(self, X):
    rooms_per_household = X[:, rooms_ix] / X[:, households_ix]
    population_per_household = X[:, population_ix] / X[:, households_ix]
    if self.add_bedrooms_per_room:
      bedrooms_per_room = X[:,bedrooms_ix] / X[:, rooms_ix]
      return np.c_[X, rooms_per_household, population_per_household,
                   bedrooms_per_room]

    else:
      return np.c_[X, rooms_per_household, population_per_household]

attr_adder = CombineAttirbutesAdder(add_bedrooms_per_room=False)
housing_extra_attribs = attr_adder.transform(housing.values)

2.5.4 특성 스케일링

가장 중요한 데이터 처리 과정 중 하나가 feature scaling입니다. 왜냐면 머신러닝 알고리즘은 feature들의 input data의 범위(scale)이 다르면 잘 작동하지 않기 때문입니다. 우리의 데이터셋의 경우 전체 방 개수의 범위는 6~39320인 것에 비해 median_income은 0~15입니다.

scaling에는 보통 min-max scaling(normalization)과 표준화(standardization)이 사용됩니다.

min-max scaling은 데이터가 0~1 범위에 들도록 스케일을 조정해줍니다. sklearn에서는 'MinMaxScaler' transformer를 제공합니다. 다른 범위를 사용하고 싶다면 feature_range 매개변수로 조정하면 되겠습니다.

표준화는 분산이 1이 되도록 합니다. 이는 min-max scaling에서의 0~1과 같은 범위은 상한, 하한이 없어 특정 알고리즘에서는 문제가 될 수 있습니다. 그러나 표준화는 '이상치'에 영향을 덜 받습니다. sklearn에서는 'StndardScaler' transformer를 표준화를 위해 제공합니다.

2.5.5. Transform 파이프라인

transform 단계가 여러개라면 그 순서는 더욱 중요할 수 밖에 없습니다. sklearn에서는 이러한 연속된 변환이 순서대로 안정적으로 이뤄지도록 Pipeline 클래스를 통해 지원해줍니다. 다음은 숫자형 feature를 처리하는 파이프라인입니다.

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler

num_pipeline = Pipeline([('imputer',SimpleImputer(strategy="median")),
                         ('attribs_adder', CombineAttirbutesAdder()),
                         ('std_scaler', StandardScaler()),
                         ])

housing_num_tr = num_pipeline.fit_transform(housing_num)

Pipeline은 연속된 단계를 나타내는 (이름 / estimator) 쌍의 목록을 입력으로 받습니다. 이때 마지막 단계를 제외하고는 나머지 단계에서는 transformer만 사용이 가능합니다. 즉 fit_transform() 메서드를 가지고 있어야 합니다.

파이프라인의 fit() 메서도를 호출하면 내부의 모든 transformer의 fit_transform() 메서드를 순서대로 호출하면서 한 단계의 출력을 다음 단계의 입력으로 전달합니다. 마지막 단계에서는 fit() 메서드만 호출합니다.

파이프라인 객체는 마지막 estimator와 동일한 메서드를 제공합니다. 위 예에서는 StandardScaler가 마지막 단계이므로 파이프라인은 transform() 메서드를 가지고 있습니다.

지금까지는 categorical feature와 수치형 feature를 따로 다뤘습니다. 그러나 하나의 transformer로 categorical과 수치형을 동시에 처리할 수 있다면 훨씬 편할 것입니다. sklearn에서는 ColumnTransformer를 통해 이를 지원합니다. 이는 pandas DataFrame과 잘 동작합니다.

- 우선 수치형 열, 범주형 열 리스트를 각각 만들어줍니다.

- 그 다음 ColumnTransformer의 생성자에서는 (이름, transformer, transformer에 적용될 리스트)를 각 튜플마다 받습니다.

- 이때 OneHotEncoder는 대부분이 0으로 구성된 Sparse Matrix를, num_pipeline은 대부분이 0이 아닌 값으로 구성된 Dense Matrix를 반환합니다. 이렇게 두가지가 섞여있을 때 ColumnTransformer는 최종 Matrix에서 0이 아닌 값에 대한 비율을 분석하여 30% 이하이면 Sparse를 그렇지 않으면 Dense를 반환합니다. (기본적으로 sparse_threshold = 0.3)

from sklearn.compose import ColumnTransformer

num_attribs = list(housing_num)
cat_attribs = ["ocean_proximity"]

full_pipeline = ColumnTransformer([("num", num_pipeline, num_attribs),
                                   ("cat",OneHotEncoder(), cat_attribs),
                                   ])

housing_prepared = full_pipeline.fit_transform(housing)

이러헥 해서 우리는 전체 주택 데이터를 받아 적절한 변환을 적용하는 파이프라인을 만들었습니다.

다음 포스팅에서는 전처리한 데이터를 이용해 모델을 선택하고 훈련하여 튜닝하는 단계에 대해 다뤄보겠습니다. 오늘도 행복한 하루 보내시길 바랍니다 :)

box-world.tistory.com/44

[ 핸즈 온 머신러닝 2판 ] pandas, sklearn을 통한 모델 학습과 튜닝은 어떻게 하는 것일까? (3)

이전 2개의 포스팅에 결쳐 우리는 지금까지 문제를 정의하고 데이터를 읽어들여 탐색하였습니다. 그리고 데이터를 training set과 test set으로 나누고 학습을 위한 머신러닝 알고리즘에 주입할 데�

box-world.tistory.com

[ 핸즈 온 머신러닝 2판 ] pandas, sklearn을 통한 데이터 전처리는 어떻게 하는걸까? (1)

Box형 — Tue, 9 Jun 2020 20:37:49 +0900

발견에는 항상 뜻밖의 재미가 있다

- 제프 베조스(Amazon CEO) -

Chapter 2

이번 포스팅을 시작으로 3번에 걸쳐 하나의 머신러닝 프로젝트가 어떻게 구성되고 진행되는지 알아보겠습니다. 우선 주요 단계는 다음과 같습니다.

1) 큰 그림 보기

2) 데이터 구하기

3) 데이터 탐색 및 시각화

4) 모델 학습을 위한 데이터 전처리

5) 모델 선택 및 훈련

6) 모델 튜닝

7) 솔루션 제시

8) 시스템 론칭, 모니터링 및 유지 보수

2.1 실제 데이터로 작업하기

머신러닝을 적용하기 위해서 가장 먼저 필요한 것은 바로 데이터가 될텐데요. 특히 우리가 공부할 때는 인공적인 데이터셋이 아닌 실제 데이터셋을 직접 다뤄보는 것이 더욱 효과적입니다. 다음은 유명한 대표적인 데이터 저장소들입니다.

- UC 얼바인 머신러닝 저장소(https://archive.ics.uci.edu/ml/datasets.html)

- 캐글 (https://www.kaggle.com/)

- 아마존 AWS 데이터셋 (https://registry.opendata.aws/)

설명을 위해 우리가 사용할 데이터셋은 StarLib 저장소에 있는 캘리포니아 주택 가격입니다. 이제 데이터셋이 어떻게 구성되어 있는지 살펴보겠습니다.

2.2 큰 그림 보기

데이터는 인구(population), 중간 소득(median income), 중간 주택 가격(median housing price) 등으로 구성되어 있습니다. 우리는 이제부터 주어진 데이터를 모델에 학습시킨 후 새로운 데이터가 주어졌을 때 해당 구역의 중간 주택 가격을 예측하게끔 해야합니다.

2.2.1 문제 정의

머신러닝 모델은 'Tool' 말 그대로 도구입니다. 다시 말해서 머신러닝 자체가 목적이 아니기 때문에 머신러닝이 사용되는 1)비즈니스의 목적이 무엇인지를 가장 먼저 파악하고 이에 따라 모델의 방향성을 결정해야 하는게 중요하겠습니다.

우리가 만들 '중간 주택 가격 예측 모델'은 부동산 투자를 위하여 구역의 가격을 예측하여 이것이 다른 데이터들과 결합하여 투자를 결정하는데 사용됩니다. 수익과 바로 직결되기 때문에 올바른 예측은 더욱 중요할 수 밖에 없습니다.

두번째로 파악해야할 것은 이러한 주택 가격을 예측하기 위해 2)기존에는 어떤 솔루션을 사용했냐는 것입니다. 예를 들어 그 동안은 구역의 주택 가격을 전문가가 수동으로 측정했다면, 정보를 모으고 복잡한 규칙을 사용하여 추정을 하기까지 비용과 시간도 많이 들고 결과가 안좋았다면, 이러한 이유로 회사는 구역의 데이터를 기반으로 모델을 훈련시켜 예측하게 하는 것이 훨씬 합리적일 것입니다.

그리고 최종적으로 문제 정의를 하게 됩니다. 문제 정의에는 해결해야하는 문제 그리고 데이터에 기반하여 지도, 비지도, 강화 학습 중 무엇인지, 분류인지 회귀인지 혹은 배치 학습인지 온라인 학습인지 등을 결정해야 합니다. 우리가 해결할 문제는 다음과 같이 정의할 수 있습니다.

- 캘리포니아 데이터셋은 Labeled Training set이므로 지도 학습(Supervised Learning)입니다.

- 가격 즉 값을 예측하는 것이므로 회귀(Regression)입니다.

- 예측을 위해 사용할 feature에는 인구, 중간 소득 등 여러 개 이므로 다중 회귀(Multiple Regression)입니다.

- 구역 별로 하나의 값을 예측하므로 단변량 회귀(Univariate Regression)입니다. 논외로 하나의 구역마다 여러 값을 예측해야 한다면 다변량 회귀(Multivariate Regression)입니다.

- (데이터가 매우 크다면 맵리듀스(MapReduce)를 이용하여 배치 학습을 여러 서버로 분할하거나 온라인 학습을 할 수 있습니다.)

2.2.2 성능 측정 지표 선택

다음 단계는 성능 측정 지표를 선택하는 것인데, 대표적으로는 평균 제곱근 오차(RMSE)가 있습니다. 이는 오차가 커질수록 값이 커지기 때문에 예측에 얼마나 많은 오류가 있는지 파악할 수 있습니다.

$$RMSE(X,h) = \sqrt{\frac{1}{n}\Sigma_{i=1}^{n}{({h(x^i) -y^i})^2}}$$

책의 내용과 별도로 제가 알아본 바로는 RMSE는 루트라는 무거운 연산에 비해 크게 메리트가 없어 다음과 같은 MSE를 좀 더 보편적으로 쓴다고 합니다.

$$MSE(X,h) = \frac{1}{n}\Sigma_{i=1}^{n}{({h(x^i) -y^i})^2}$$

2.3 데이터 가져오기

이제 본격적으로 실제 데이터를 가져와 직접 데이터를 다뤄보도록 하겠습니다. 저는 Google의 Colab 환경에서 코드 작성을 진행하였습니다.

2.3.1 데이터 다운로드

다음 코드에서는 다운로드 링크를 통해 csv 파일 형식으로 데이터셋을 받아온 후 별도의 디렉토리에 넣어줍니다.

import os
import tarfile
from six.moves import urllib

DOWNLOAD_ROOT = "https://raw.githubusercontent.com/ageron/handson-ml2/master/"
HOUSING_PATH = os.path.join("datasets", "housing")
HOUSING_URL = DOWNLOAD_ROOT + "datasets/housing/housing.tgz"

def fetch_housing_data(housing_url=HOUSING_URL, housing_path=HOUSING_PATH):
    if not os.path.isdir(housing_path):
        os.makedirs(housing_path)
    tgz_path = os.path.join(housing_path, "housing.tgz")
    urllib.request.urlretrieve(housing_url, tgz_path)
    housing_tgz = tarfile.open(tgz_path)
    housing_tgz.extractall(path=housing_path)
    housing_tgz.close()

fetch_housing_data()

그리고 pandas 라이브러리를 이용하여 데이터를 읽어들입니다.

pandas란 python의 데이터 분석 라이브러리로써 행과 열로 이루어진 데이터 객체를 만들어 대용량의 데이터를 효과적으로 다루게 해줍니다. 이는 다른 포스팅에서 추후에 좀 더 구체적으로 다뤄보겠습니다.

import pandas as pd

def load_housing_data(housing_path=HOUSING_PATH):
  csv_path = os.path.join(housing_path, "housing.csv")
  return pd.read_csv(csv_path)

load_housing_data()

2.3.2 데이터 구조 훑어보기

이제 좀 더 구체적으로 데이터가 어떤 특성을 가지고 어떻게 구성되어있는지 알아보겠습니다. 우선 head()를 사용하여 처음 다섯 행을 확인해보겠습니다. 여기서 하나의 행은 하나의 구역을 나타내며 특성은 longitude부터 ocean_proximity까지 총 10개입니다.

info() 메서드를 통해 데이터에 대한 간략한 설명 그 중에서도 전체 행 수, 각 feature의 데이터 타입과 Null이 아닌 값들의 개수 등을 확인할 때 유용합니다.

- 데이터셋에는 20640개의 샘플로 상당히 적은 양에 속하지만, 초보자가 다루기엔 충분합니다.

- 4번째 feature인 total_bedrooms만 20433개의 Null이 아닌 값을 가지는데, 이는 나머지 207개의 구역이 이 feature를 가지고 있지 않기 때문입니다.

- ocean_proximity를 제외한 모든 feature의 데이터 타입은 숫자형입니다. ocean_proximity는 head()에서 데이터가 반복되는 것으로 보아서 범주형(categorical) 데이터이기 때문에 value_contents()를 통해 각 카테고리별 속해있는 구역을 확인해봅니다.

describe()를 통해 ocean_proximity 이외에 숫자형 feature의 요약 정보를 확인해보겠습니다. count, mean, std 등은 다들 통계를 공부해봤다면 알법한 쉬운 정보들로 구성되어있습니다.

데이터를 훑어보는데는 많은 방법들이 있겠지만, 직접 그래프로 시각화하여 보는 것만큼 효과적인 방법은 없다고 생각합니다. 다음은 숫자형 feature를 히스토그램으로 그려본 결과입니다.

2.3.4 테스트 세트 만들기

다음 코드를 통해 모델의 성능을 측정하기 위한 테스트 데이터셋을 20% 정도 떼어 놓겠습니다. 우선 데이터를 쪼갤 함수를 만든 후 쪼갠 후, train set과 data set의 크기를 비교해보았습니다.

import numpy as np

def split_train_test(data, test_ratio):
  shuffled_indices = np.random.permutation(len(data))
  test_set_size = int(len(data)*test_ratio)
  test_indices = shuffled_indices[:test_set_size]
  train_indices = shuffled_indices[test_set_size:]
  return data.iloc[train_indices], data.iloc[test_indices]

그런데 위와 같은 방식으로 했을 때의 문제점은 함수를 실행할 때마다 다른 test set을 생성한다는 것입니다. 즉 모델이 전체 데이터셋을 보게 되는 것이죠. 이를 피하기 위해 np.random.permutation(np.random.seed(42))와 같이 랜덤값 생성 시 초깃값을 지정할 수 있습니다.

하지만 이마저도 업데이트 시 데이터는 바뀌었는데 초깃값은 그대로니 test set이 변경된다는 문제가 있습니다. 따라서 안정적인 데이터 분할을 위해선 각 샘플에 identifyer를 사용하여 test set에 보낼지 말지 결정하는 것입니다.

예를 들어 identifyer의 해시값이 20%보다 작다면 test set으로 보내는 식입니다. 이를 통해 데이터셋이 업데이트 되더라도 기존에 training set에 있던 데이터가 test set에 들어가는 것을 방지할 수 있습니다.

from zlib import crc32

def test_set_check(identifier, test_ratio):
  return crc32(np.int64(identifier)) & 0xffffffff < test_ratio * 2**32

def split_train_test_by_id(data, test_ratio, id_column):
  ids = data[id_column]
  in_test_set = ids.apply(lambda id : test_set_check(id, test_ratio))
  return data.loc[~in_test_set],data.loc[in_test_set]

이때 원래 데이터셋에는 identifyer에 대한 column이 없기 때문에 column의 인덱스를 ID로 사용하겠습니다.

housing_with_id = housing.reset_index()
train_set, test_set = split_train_test_by_id(housing_with_id, 0.2, "index")

그러나 이렇게 행의 인덱스를 identifyer로 사용하기 위해서는 새로운 데이터셋은 끝에 추가되어야하며 어떤 행도 삭제가 되면 안됩니다. 좀 더 안정적인 identifyer를 사용하기 원한다면 구역의 longitude와 latitude처럼 몇백년이 지나도 변하지 않는 features를 연결하여 다음과 같이 ID를 만들 수 있습니다.

'사이킷런'도 데이터셋을 여러 서브셋으로 나누는 기능을 제공합니다. 가장 간단한 함수인 train_test_split은 난수 초깃값을 지정할 random_state 매개변수가 있고, 행의 개수가 같은 여러 데이터셋을 동시에 넘겨 같은 인덱스를 기반으로 나누게 할 수 있습니다.

from sklearn.model_selection import train_test_split

train_set, test_set = train_test_split(housing, test_size = 0.2, random_state = 42)

지금까지 우리가 본 것은 순수한 무작위 샘플링 방식입니다. 그러나 이러한 방식은 데이터의 대표성을 보장할 수 없습니다. 예를 들어 남자 400명, 여자 600명으로 구성된 1000개의 데이터셋에서 200개를 test set으로 분할할 때 200개 모두 남자일 수도 있다는 말이 됩니다.

우선 우리 데이터셋의 소득 분포는 어떻게 되어있는지 보겠습니다. pd.cut() 함수를 이용하여 소득을 5개의 카테고리로 구분한 후 이를 히스토그램으로 표현합니다.

housing["income_cat"] = pd.cut(housing["median_income"],
                               bins=[0,1.5,3.0,4.5,6,np.inf],
                               labels=[1,2,3,4,5])

이제 사이킷런의 StratifiedShuffleSplit을 사용하여 비율을 유지하여 샘플링을 하는 계층 샘플링을 하고 비율을 확인해보겠습니다.

from sklearn.model_selection import StratifiedShuffleSplit

split = StratifiedShuffleSplit(n_splits=1, test_size=0.2, random_state = 42)
for train_index, test_index in split.split(housing,housing["income_cat"]):
  strat_train_set = housing.loc[train_index]
  strat_test_set = housing.loc[test_index]

여기까지가 프로젝트 진행을 위해 문제를 정의하고, pandas와 sklearn을 활용하여 데이터의 특성을 파악하는 법을 알아보았습니다. 다음 포스팅에 계속 이어서 데이터를 어떻게 탐색하고 시각화하는지 공부해보겠습니다.

box-world.tistory.com/43

[ 핸즈온 머신러닝 2판 ] pandas, sklearn을 통한 데이터 전처리는 어떻게 하는걸까? (2)

box-world.tistory.com

box-world.tistory.com/44

[ 핸즈 온 머신러닝 2판 ] pandas, sklearn을 통한 모델 학습과 튜닝은 어떻게 하는 것일까? (3)

box-world.tistory.com

[핸즈 온 머신러닝] 머신러닝(Machine Learning)의 종류와 유의할 점

Box형 — Tue, 2 Jun 2020 16:52:14 +0900

크게 실패할 용기있는 자만이 크게 이룰 수 있다”

-존 F. 케네디(35대 미국 대통령)-

시작하며

사실 우리 주변에 머신러닝은 이미 오래전부터 존재해왔습니다. 그 시작은 1990년대에 등장한 스팸 필터(spam filter)입니다. 물론 성능이 완벽하진 않았겠지만, 기술적으로 머신러닝이 분명했고 시간이 흐르면서 이는 추천과 음성 검색으로 발전하였고, 현재는 더욱 다양한 분야에 머신러닝을 접목시키고자 많은 분들이 연구하고 있습니다.

그러면 이 머신러닝의 범주는 정확히 어디까지일까요? 기계가 학습한다는 것은 어떤 의미이며 머신러닝은 우리에게 왜 필요한 것일까요?

이번 포스팅에서 전체적인 머신러닝의 그림을 조망하며 본격적으로 구체적인 개념을 공부하기 전 머신러닝을 거시적으로 바라보는 시간을 가져보겠습니다.

머신러닝이란?

머신러닝은 데이터를 학습하도록 컴퓨터를 프로그래밍하는 과학입니다.

어떤 작업 T에 대한 컴퓨터 프로그램의 성능을 P로 측정했을 때, 경험 E로 인해 성능이 향상됐다면, 이 컴퓨터 프로그램은 작업 T와 성능 측정 P에 대한 경험 E로 학습한 것이다.

위는 인공지능의 대표적인 연구자인 '톰 미첼'이 내린 공학적인 정의로 머신러닝의 정의를 설명할 때 가장 일반적으로 인용되는 문구입니다.

작업 T는 메일이 스팸인지를 판단하는 것이고, 경험 E는 시스템 학습에 사용되는 훈련 데이터(Training data)이며, 성능 측정 P는 우리가 직접 정의내려야 합니다. 예를 들어 전체 메일 중 정확히 분류된 메일의 비율을 P로 사용할 수 있습니다.

머신러닝을 왜 사용해야할까?

머신러닝이 무엇인지를 알게 되었으니 이제 왜 머신러닝이어야만 하는지 스팸 필터를 만드는 과정을 일반적인 프로그래밍과 머신러닝을 이용한 프로그래밍 둘로 나누어 비교하면서 생각해보겠습니다.

'4U', '신용카드', '무료' 등 스팸 메일에 자주 등장하는 단어들이 있습니다. 일반적인 프로그래밍의 경우엔 이러한 단어의 패턴들을 찾아내는 알고리즘을 단어 하나당 하나씩 만들어 프로그램이 패턴을 발견 시 해당 메일을 스팸으로 분류하게 해야합니다.

그러나 머신러닝을 이용한다면, 스팸 메일에 자주 나타나는 패턴을 스스로 학습하기 때문에, 프로그램이 훨씬 짧아지고 유지보수도 훨씬 쉬워집니다.

만약 스팸 메일 발송자가 '4U' 단어가 포함된 메일은 모두 차단한다는 사실을 알게 되어 '4U' 대신 'For U'를 사용한다면 일반적인 프로그래밍의 경우 또 다시 이것에 대한 알고리즘을 만들거나 계속해서 수정해야합니다.

그러나 머신러닝을 이용한다면, 스팸 메일에 유독 'For U'가 자주 쓰인다는 것을 인식하여 프로그래머가 별도의 작업을 하지 않아도 단어가 자동으로 스팸으로 분류됩니다.

머신러닝을 통해 배울 수도 있습니다. 예를 들어 스펨 메일을 분류하는 머신러닝 모델이 있다면 이것을 분석하여 스팸 메일을 분류하는데 핵심이 되는 단어나 패턴이 무엇인지를 배울 수 있을 것입니다. 이렇게 머신러닝을 이용하여 빅데이터에서 보이지 않던 패턴을 발견하는 것을 데이터 마이닝이라고 합니다.

머신러닝 시스템의 종류

[ 지도학습 / 비지도학습 ]

1) 지도학습(Supervised Learning)

지도학습은 모델 학습에 사용되는 Training Data(훈련 데이터)에 Label이 붙어있습니다. 대표적인 지도 학습의 종류에는 분류와 회귀가 있습니다. 스팸 메일이 분류의 예, 집의 사이즈를 보고 가격을 예측하는 것이 회귀의 대표적인 예가 되겠습니다.

이외에 다음과 같은 알고리즘도 지도 학습에 포함됩니다.

- K-nearest neighbors, Linear regression, Logistic Regression, SVM(Support Vector Machine), Decision Tree and Random Forest, Neural Network

2) 비지도학습(Non-Supervised Learning)

비지도학습에 사용되는 Training set에는 Label이 없습니다. 그렇기 때문에 학습 모델이 보통 알고리즘을 통해 직접 특성을 찾아내야합니다. 다음은 비지도학습에 포함되는 알고리즘들입니다.

2 - 1) 군집(Clustering)

- 군집 : 비슷한 특성을 가지는 데이터끼리 묶어 특정한 패턴이나 규칙을 발견하기 위해 쓰입니다. 예를 들어 블로그 방문자에 대한 데이터가 있을 때, 이를 비슷한 특성을 가지는 데이터를 묶는 군집 알고리즘을 이용하여 60%의 방문자가 남성이며 저녁에 방문한다는 것을 알수도 있습니다.

- 이상치 탐지 : 전체 데이터에 비해 매우 작은 비율의 데이터를 찾아낼 때 쓰입니다. 예를 들어, 10만건중 10번 꼴로 발견되는 신용 사기의 패턴을 분석하여 사전에 이를 발견하기 위해 쓰일 수 있습니다.

- 특이치 탐지 : 이상치 탐지가 Training set에서 0.01%의 매우 작은 데이터를 발견하는데 쓰인다면, 특이치 탐지는 Training set과 아예 다른 새롭고 특이한 데이터를 찾는데 쓰입니다.

- K-means, DBSCAN, HCA, Anomaly Detection, novelty detection, one-SVM, isolation forest

2 - 2) 시각화(visualization) 및 차원 축소(dimension reduction)

- 시각화 : 고차원의 데이터를 넣으면 그 구조를 가능한 한 유지하면서 도식화가 가능한 2D나 3D로 표현해줍니다.

- 차원 축소 : 고차원의 데이터를 최대한 정보를 잃지 않으면서 차원을 낮추는 것으로, 데이터를 가볍게 해주는 역할을 합니다.

- PCA, Kernel-PCA, LLE, t-SNE

2 - 3) 연관 규칙 학습(Association Rule Leraning)

- 대량의 데이터에서 특성 간의 특별한 관계를 찾는데 유용하게 쓰입니다. 예를 들어, 슈퍼마켓 판매 기록 데이터를 연관 규칙 학습을 시켰더니 높은 비율로 스테이크를 살때 감자를 함께 산다는 것을 발견하여 이를 진열대 정리에 반영할 수도 있습니다.

- Apriori, Eclat

3) 준지도 학습(Semisupervised Learning)

준지도 학습은 Traning set의 Label이 일부에만 붙어있는 데이터가 쓰입니다. 예를 들어, 저의 증명사진에 대해서, 저라는 정보를 기입하지 않고 갤러리에 올렸을 때는 갤러리 내에 제가 포함된 사진이 있는지 자동으로 찾아줄 수 있습니다. 이것은 비지도학습입니다. 반대로 가족 사진을 갤러리에 올리며 사진 속 어떤 사람이 누군인지를 입력하면, 검색을 통해 해당 가족 인물이 포함된 사진을 쉽게 찾을 수 있습니다. 이는 지도학습입니다.

대부분의 준지도 학습 알고리즘은 지도 학습과 비지도 학습의 조합으로 이루어집니다. 심층 신뢰 신경망(DBN)은 비지도 학습 알고리즘인 제한된 볼츠만 머신(RBM)에 기초합니다. 여러 겹(Layer)의 RBM으로 구성된 DBN은 각 Layer의 RBM에서 이뤄진 비지도 학습 방식을 이용하여 전체 시스템을 지도 학습으로 조정합니다.

4) 강화 학습(Reinforcement Learning)

강화 학습은 에이전트(Agent)라고 부르는 학습 시스템이 환경을 관찰해서 행동을 실행하고 그에 따른 보상이나 벌점을 받습니다. 이를 통해 정책(Policy)라 부르는 최상의 전략을 스스로 학습하여 주어진 상황에서 에이전트가 어떻게 행동해야할지 정의합니다. 대표적인 예로, 알파고가 있습니다. 알파고는 별도의 바둑 규칙을 알려주지 않은 채 스스로 수없이 바둑을 두며 스스로 정책을 수립하였습니다.

[ 배치 학습(오프라인 학습)과 온라인 학습 ]

배치 학습은 데이터를 한번에 받아 학습하여 시스템을 만드는 것입니다. 즉 많은 양의 데이터를 한번에 학습해야 하기에 시간과 컴퓨팅 자원을 많이 소모하므로 오프라인에서 주로 수행되어 오프라인 학습으로 불리기도 합니다.

그리고 배치 학습은 새로운 데이터에 대해 학습하기 위해서는 새로운 데이터를 포함 시킨 전체 데이터를 다시 학습시킨 시스템과 기존 시스템을 교체하는 식으로 이뤄지기 때문에 굉장히 비효율적일 수 있습니다.

이에 비해 온라인 학습은 미니 배치(mini batch)라는 작은 묶음 단위로 주입되는 데이터로 점진적으로 학습합니다. 그렇기 때문에 매 학습 단계가 빠르고 컴퓨팅 자원이 많이 소모되지 않습니다. 이것은 주식과 같이 연속적인 데이터를 받으며 빠른 변화가 필요한 시스템에 적합합니다. 혹은 데이터셋이 메모리크기보다 큰 경우 온라인 학습을 통해 데이터의 일부를 조금씩 메모리에 가져와 점진적으로 학습할 수도 있습니다.

온라인 학습에서 제일 중요한 요소 중 하나는 학습률(Learning Rate)입니다. 이 학습률을 높게하면 시스템이 데이터에 빨리 적응하지만 예전 데이터는 금방 잊어버리게 됩니다. 반대로 학습률이 낮다면 새로운 데이터에 적응하는데 더 오랜 시간이 걸리게 되지만, 새로운 데이터의 잡음이나 이상한 데이터에 덜 민감해집니다.

온라인 학습의 가장 큰 문제점은 나쁜 데이터입니다. 예를 들어, 특정 음악 차트에 누군가 자신의 노래를 차트 상위권으로 올리기 위해 의도적으로 매크로를 돌리는 경우를 생각해볼 수 있습니다. 이 경우 관리자가 이를 걸러내는 시스템을 짜거나 지속적인 관리를 해야합니다.

[ 모델 기반 학습과 사례 기반 학습 ]

1) 모델 기반 학습

모델 기반 학습은 데이터를 대표할 수 있는 모델을 생성하여 이를 예측에 이용하는 것입니다. 우리가 앞으로 머신러닝에서 공부할 대부분의 알고리즘들이 바로 여기에 속하게 됩니다. 이러한 모델 기반 학습은 데이터 분석, 모델 선택, 모델 학습, 모델에 새로운 데이터를 적용하여 결과 평가하기 이렇게 보통 4단계로 이루어집니다.

2) 사례 기반 학습

사례 기반 학습은 유사도라는 것을 이용하여 데이터를 분류합니다. 예를 들어 스팸 메일 분류의 경우, 일치하는 단어를 유사도의 척도로 사용하여 어떤 메일이 일정 유사도를 넘으면 스팸을 분류합니다.

머신러닝 적용 시 유의할 점

1) Training data의 수가 충분한가?

우리가 생각하는 좋은 머신러닝 알고리즘이 만들어지기 위해서는 수천개에서 수백만개의 데이터가 필요합니다. 문제는 실제로 우리가 몸담게될 산업현장에서는 우리가 공부할 때 사용하는 예제처럼 예쁘게 정제된 데이터가 대부분 없습니다. 따라서 현재 인공지능을 접목하고자 하는 산업 곳곳에서는 이러한 데이터를 구하기 위해 데이터 파이프라인을 구축하고, 학습에 이용할 수 있도록 데이터를 정제하는 기술을 개발하는데 힘쓰고 있습니다.

2) Trainig data가 대표성을 지니고 있는가?

우리가 어떠한 머신러닝 알고리즘을 개발하여 특정 분야에 적용하고자 한다면 모델 학습에 사용되는 데이터는 대표성을 지녀야합니다. 예를 들어, 나라의 여러 특성을 이용하여 GDP를 예측하는 모델을 만들고자 할 때 특정 나라를 누락시킨다면 이러한 데이터를 학습한 알고리즘은 정확하다고 할 수 없을 것입니다. 이렇게 표본추출을 잘못하여 데이터가 대표성을 띄지 못하는 현상을 샘플링 편향(Sampling bias)라고 합니다. 이외에도 학습 데이터가 너무 작을 경우 샘플링 잡음(Sampling noise)라고 부르는 예외적인 데이터에 모델이 영향을 받을 수 있습니다.

3) Training data의 품질이 높은가?

Training data에 에러, 이상치(예외), 잡음(열악한 측정 장치로 인한)으로 가득찬다면 머신러닝 시스템이 잘 작동할리가 없습니다. 현재에도 다양한 산업군에서 '좋은' 데이터라는 것을 얻기 위해 데이터 사이언티스트의 역할이 더욱 중요해지고 있습니다.

데이터 사이언티스트는 데이터에 이상치가 들어있다면 이를 무시하거나 수동으로 뺄 수도 있고, 일부 데이터에 몇몇 특성이 빠져있다면 이를 그대로 진행할지 채울지를 고민해야합니다.

4) Training data에 필요없는 특성이 들어있진 않는가?

예를 들어 주어진 데이터를 통해 이 사람의 5년 후의 키를 예측하는 알고리즘을 짠다고 해보겠습니다. 그런데 뜬금없이 데이터의 특성으로 각 사람의 수학 점수가 들어간다면 당연히 좋은 알고리즘이 나올 수 없을 것입니다. 이처럼 Training set을 결정할 때는 알고리즘에 필요한 특성들로만 구성되어있는지 고민해야합니다.

5) 모델의 과대적합(Overfitting) / 과소적합(Underfitting)

우리가 머신러닝 학습을 통해 만들어진 모델은 데이터를 대표합니다. 그런데 모델의 대표성이 지나치게 높거나 낮으면 알고리즘의 정확도에 큰 영향을 끼칠 수 있습니다. 예를 들어 암을 발견하는 알고리즘에서 모델이 데이터에 너무 꽉끼는 바람에 99.7% 이상의 확률을 가진 사람만 암으로 판단한다고 하면 실제로 암인데도 불구하고 98%나 99.1%의 확률로 암이 아니라는 끔찍한 오진을 내리게 될수도 있습니다.

요약

- 머신러닝은 프로그래머가 명시적으로 하나하나 구현하는 것이 아닌, 주어진 데이터를 가지고 스스로 학습하면서 성능을 강화시켜나간다.

- 머신러닝 시스템에는 지도 학습과 비지도 학습, 배치 학습과 온라인 학습, 사례 기반 학습과 모델 기반 학습 등이 있다.

- 머신러닝 알고리즘 자체도 중요하지만, 학습에 사용될 데이터를 여러 기준에 따라 알맞게 정제하는 것 또한 매우 중요하다.

[머신러닝 순한맛] 순환 신경망(RNN)이란?

Box형 — Wed, 27 May 2020 11:45:36 +0900

모든 경험에는 가르침이 있다

- 브라이언 트레이시 -

시작하며

과거를 통해 미래를 예측하는 능력은 누구나 갖고 싶어하는 것입니다. 하지만 오늘날 딥러닝 분야에서는 이러한 예측 능력을 수학적으로 구현하여 미래에 한발짝 다가가고자 하는 알고리즘이 있습니다. 바로 RNN(Recurrent Neural Network)입니다.

이번 포스팅에서는 자연어 처리(NLP), 주가 예측 등 폭넓게 사용되는 기본적인 RNN에 대해 알아보겠습니다.

RNN's Basic Idea

여기 네 개의 단어가 있습니다.

'I'는 주어, 'work'는 동사, 'at'은 전치사, 'google'은 명사라는건 대부분 알고 있습니다. 좀 더 구체적으로 들여다보자면 주어인 'I'가 왔기 때문에 그 뒤는 동사일 것이라고 자연스럽게 예측했고, 전치사 'at'이 왔기 때문에 그 뒤는 명사가 올것이라고 추론할 수 있었던 것입니다. 이러한 일련의 추론 과정을 수학적으로 모델링한 것이 바로 'RNN'입니다.

RNN의 구조

방금 보았던 예시를 4개의 단어를 Input으로 받아 품사가 무엇인지 Output으로 알려주는 RNN으로 다시 표현해보겠습니다. Input은 동시가 아닌 순차적으로 들어오며, 'I'는 hidden state라는 것을 거쳐 '주어'라는 것을 미리 알고 있다고 가정합니다.

그러면 'I' 다음 'work'를 Input으로 받는데, 이때 hidden state는 'work' 뿐만 아니라 이전 'I'에 대한 데이터를 이전 hidden state를 통해 받아 '동사'라고 판단하게 됩니다.

마지막으로 'google'이 들어왔을 때는 'google'과 함께 'I','work','at'에 대한 정보를 함께 조합하여 'google'이 명사일 확률이 높다고 결론을 내리게 됩니다.

이처럼 RNN은 Hidden state가 방향을 가진 Edge로 연결되어 순환구조를 이루는 인공신경망의 한 종류를 의미합니다. 그리고 이는 문장과 같은 'Sequence Data'를 분석하는데 유용하며, Input과 Output의 길이에 제약받지 않고 유연한 구조를 가질 수 있다는 점이 장점입니다.

이제 예시는 접어두고 Input은 $x_i$, Output은 $y_i$, hidden state는 $h_2$로 설정하고 구체적으로 구조를 살펴보겠습니다.

갑자기 등장한 $W_{xh}$, $W_{hh}$때문에 놀랐셨을텐데, 이것은 우리가 그동안 자주 봐왔던 가중치입니다. 결국 큰 맥락에서 딥러닝의 일종인 'RNN'은 이전의 Input 데이터들을 반영하여 현재의 Input 데이터가 무엇인지 판단하는데, 이때 판단의 정확도를 높이기 위해 여타 딥러닝처럼 가중치인 $W$를 최적화하는 매커니즘을 가지고 있습니다.

RNN은 이전의 데이터를 반영한다는 것을 $+$를 이용해 수학적으로 표현합니다. 예를 들어 위 그림에서 Input으로 $x_2$가 들어왔을 때 hidden state는 $x_2$ 그리고 이전 hidden state를 통해 $x_1$를 받아 Output을 출력하게 됩니다.

이때 각 $x_2$은 가중치 $W_{hh}$가, $x_1$은 가중치 $W_{xh}$가 곱해지고 여기에 Bias term인 'b'까지 더해져 만들어진 $$W_{hh}*(x_2) + W_{xh}*(x_1) + b$$는 활성 함수(activation function)인 $tanh$를 거쳐 최종적인 $y_2$를 도출하게 됩니다.( 활성 함수 = 가설함수 $h(x)$ )

이때 $h(x)$의 형태가 우리가 일반적으로 써오던 $Wx + b$가 아닌 $tanh$인 이유가 중요합니다. 만약 위 그림에서 4개의 hidden state에 $tanh$ 대신 $Wx + b$가 들어있다면, $y(x) =h(h(h(h(x))))$인데 이는 $y(x) = c*c*c*c*x$로써 사실상 결과값은 일차함수로 기존과 다를것이 없습니다. 따라서 딥러닝의 장점을 살려주기 위해서는 활성함수로 선형 함수가 아닌 '비선형함수'를 사용해야합니다.

이제 각각 도출한 $y$값을 softmax에 넣으면 각 단어가 어떤 품사에 해당할지를 확률값으로 알려주고 이중 제일 확률이 높은 값이 예측값이 됩니다.

이제 남은 것은 '최적화(Optimization)'입니다. 최적화란 예측값과 실제값의 Cost를 줄여나가는 과정을 의미합니다. 따라서 $W_{hh}$, $W_{xh}$, $b$ 총 세가지를 'Gradient Descent Algorithm'을 이용하여 최적화하게 되고, 이 과정에서 'Back Propagation'이 이용됩니다.

중요한 점은 위 그림에서 $W_{hh}$, $W_{xh}$, $b$가 네 개있는 거처럼 보이지만 실제로는 12개의 값이 아닌 3개의 변수라는 점입니다.

Back Propagation에 대한 개념은 아래 포스팅에 자세히 설명되어있습니다.

https://box-world.tistory.com/19

[머신러닝] Back Propagation(역전파) 정복하기

시작하며 오늘은 머신러닝에서 가장 큰 고비 중 하나인 ' Back Propagation(역전파) 알고리즘' 에 대해 공부해보겠습니다. 알고리즘을 이해하기 어려울 수도 있고, 복잡한 수식이 나와 거부감이 드실

box-world.tistory.com

[머신러닝 순한맛] CNN(Convolutional Neural Network)란?

Box형 — Mon, 25 May 2020 16:49:44 +0900

당신이 두려워하는 일을 매일 하라

- 엘리너 루즈벨트 -

시작하며

10년 후에 우리의 삶을 송두리째 바꿀 단 하나의 기술을 꼽으라 하면 저는 '자율주행'이라고 답할 것입니다. 현재 IT 산업 전반적으로 자율주행 자동차 상용화를 위해 천문학적인 금액을 투자중입니다. 그리고 이러한 자율주행 기술 구현을 위해 핵심이 되는 기술이 바로 '컴퓨터 비전(Computer vision)'입니다.

이번 포스팅에서는 이러한 컴퓨터 비전 분야에서 이미지 분석을 위해 가장 보편적으로 사용되는 'CNN(Convolutional Neural Network)'에 대해 공부해보겠습니다.

이번 포스팅은 아래 포스팅을 통해 딥러닝(Deep Learning)을 이해하고 공부하시면 더욱 효과적입니다.

https://box-world.tistory.com/17

[머신러닝] 딥러닝의 시작 Neural Network 정복하기 1

시작하며 우리는 저번 포스팅에서 Overfitting을 다루며 배웠던 'non-linear classification' 에서, feature가 두개일 때 위와 같이 Decision Boundary를 표현해보았습니다.. Overfitting https://box-world.tist..

box-world.tistory.com

CNN : 등장 배경

CNN이란 이미지 분석을 위해 사용되는 가장 유명한 딥러닝 알고리즘 중 하나이며, 핵심은 바로 이미지의 패턴(pattern)을 분석하는 것입니다. 그 이유는 CNN의 시초를 이해하면 알 수 있습니다.

CNN 의 시초가 된 고양이 실험

1959년, 고양이가 어떻게 이미지를 인식하는지 알아보기 위해 한 실험을 진행하였습니다. 보통 사람이 이미지를 볼 때는 각 뉴런들이 각 이미지의 서로 다른 부분적인 조각을 담당합니다. 즉 하나의 이미지를 인지한다는 건 여러 개의 입력이 각 뉴런에 들어옴으로써 이루어진다고 할 수 있고, 이것이 CNN의 기본 아이디어입니다.

CNN : 작동 원리

이제 본격적으로 CNN의 작동 원리에 대해 알아보겠습니다.

우선 2개의 Convolutional Layer로 이루어진 'Neural Network'가 있습니다. Hidden Layer라고도 부르는 이 두개의 Convolutional Layer가 바로 CNN Neural Network의 핵심이 됩니다.

Convolutional Layer가 바로 CNN 이미지 분석의 핵심인 '패턴 분석'을 담당합니다. 그리고 이러한 패턴 분석을 위해 쓰이는 도구가 'Filter'입니다.

여기 이미지를 보면 언덕, 모양, 텍스쳐 등 이미지를 구성하는 다양한 '오브젝트(object)'들이 있습니다. 이때 'Filter'가 발견 하는 패턴은 Object를 구성하는 Edge, Corner, Circle 등이 될 수 있습니다. 자세한 작동원리는 조금 있다 설명드리겠습니다.

이때 Neural Network가 깊어질수록 Input으로 들어간 이미지는 더 많은 Convolutional Layer를 거치게 되면서, Filter가 발견하는 패턴은 더욱 구체화됩니다. 즉 첫 Layer에서 Filter가 발견한 패턴이 Edge, Corner, Circle 등이었다면 이것이 점점 깊어질수록 눈, 귀, 머리카락, 새들의 털, 부리 등 훨씬 구체적인 패턴을 발견할 수 있는 것입니다.

CNN : Filter의 역할

그러면 이제부터 Convolutinal Layer(Conv Layer)와 Filter가 네트워크안에서 어떤식으로 작동하는지 알아보겠습니다.

우선 Input Layer의 각 Unit에 사람이 손으로 쓴 숫자 이미지를 넣어보겠습니다. 이렇게 Input Layer로 받아들인 이미지는 다음 Conv Layer에 전달됩니다. 이때 각 Conv Layer에는 Filter가 존재하게 되고, Filter의 개수는 여러 개일 수 있습니다.

Filter란 Input 이미지보다 훨씬 작은 행렬로써 사용자가 몇 개의 row와 column을 가질지 정할 수 있고, 그 안의 숫자값들은 random으로 초기화되어 있습니다. 예를 들어 위 그림처럼 3x3 Filter가 있다고 할 때, 이것은 Input으로 들어온 이미지를 3x3 단위로 차례대로 돌아다니게 되며 이것을 'Convolving'이라고 부릅니다.

예를 들어 왼쪽 그림처럼 Input으로 받은 이미지가 있을 때, 이미지를 구성하는 행렬안의 숫자들은 이미지를 구성하는 픽셀(Pixel)을 뜻합니다. 그리고 오른쪽 그림에서 보이는 3x3 행렬이 우리가 사용할 Filter이고, 우선 갯수는 하나로 설정하겠습니다.

그러면 맨 처음 이미지에 3x3 Filter를 갖다댔을 떄 나온 특정 값(Dot)을 오른쪽 행렬 내 하나의 Element로 저장 합니다. 이때 이 픽셀이 흑백일 경우, Dot은 2차원이지만, 컬러일 경우는 RGB가 고려되기 때문에 3차원입니다.

그 다음 Filter는 오른쪽 그림과 같이 한칸 단위로 반복적으로 이동하면서 Dot을 뽑아냅니다. 이렇게 우리가 지정한 Filter가 Input 이미지의 전 영역을 Convolving한 후 나타난 결과가 오른쪽 이미지인 것입니다. 즉 이것은 첫 Conv Layer가 Input layer에서 받은 이미지를 통해 출력한 Output으로 다음 Conv layer의 Input으로 넘어가게 됩니다.

보통 Filter에서 나오는 특정 값(Dot)은 Input 이미지의 3x3 행렬을 $Wx + b(=θx + b)$에 대입하여 도출됩니다. 이때 $Wx + b$을 Relu 함수에 넣어줄 수도 있습니다. (참고로 딥러닝에서는 $θx + b$보단 $Wx + b$이라고 일반적으로 표현합니다.)

Relu 함수에 대해서 간단하게 설명드리자면, 우리가 Logistic Regression에서 사용하는 sigmoid 함수를 생각해보면 중간의 기울기는 0보다 매우 크지만 양옆으로 갈수록 0에 가까워지는걸 알 수 있습니다.

이렇게 양 옆으로 갈수록 0에 가까워지는 특성은 네트워크가 깊어질수록 Gradient가 0에 가까워져 데이터가 소멸이나 손실이 되어 우리가 원하는 학습을 못하는 결과가 일어납니다. 따라서 Relu 함수를 통해 이러한 데이터의 손실을 막을 수 있습니다.

왼쪽 그림처럼 7x7 이미지에 하나의 Filter를 Stride를 1로 설정하여 이미지 전체를 Convolving했을 경우, output 사이즈는 5x5가 됩니다. 이때 Stride란 Filter를 한번 움직였을 때 이동하는 칸(Pixel)을 의미합니다. 오른쪽 그림에서는 Input 이미지와 Stride에 따른 Output Size의 크기를 공식으로 표현한 것입니다.

근데 Filter를 Convolving할 때, Stride가 커질수록 Output Size가 작아지게 됩니다. 즉 정보가 손실된다는 뜻 입니다. 그래서 이러한 정보의 손실을 막기 위해 사용되는 것이 패딩(Padding)입니다.

'Padding'은 위 그림처럼 이미지를 0으로 둘러싸줍니다. 이렇게 하면 이미지가 지나치게 작아지는걸 막을 수 있고, 혹은 가장자리가 0임을 이용하여 모서리라는 것을 알려줄 수도 잇습니다. 또한 Padding을 적용하면 Output Size가 줄어들지 않고, Input Size와 동일하게 유지됩니다.

이제 Conv Layer를 어떻게 만드는지 알아보겠습니다. 오른쪽 그림같이 하나의 Filter를 거쳐 나온 output을 activation map이라고 합니다. 이떄 Filter가 여러개 있으면 중앙 이미지와 같이 activation map도 여러개가 있을 것이고 오른쪽 그림같이 이를 합치면 하나의 Conv Layer를 만들 수 있습니다.

또 하나의 개념인 Pooling에 대해서 살펴보겠습니다. 여기 4x4의 이미지를 2x2 filter를 이용하여 stride 2로 Convoving 했을때 색깔별로 영역을 나눌 수 있는데 Pooling은 저 색깔로 구분된 각 영역에서 특정값 하나를 그대로 뽑아 오는 것입니다. 가장 흔하게 쓰이는 것은 Max Pooling으로서 최대값을 뽑아오는 것입니다.

만약 하나의 Layer에 Filter가 여러 개라면 이런식으로 하나하나씩 Pooling 한다음 합치면 됩니다.

Pooling의 목적은 overfitting을 막기 위함입니다. 하나의 Pixel은 하나의 Feature에 해당합니다. 예를 들어 96x96짜리 image에 8X8 400개의 filter를 넣는다고 하면 한 필터당 7921개의 feature를 가지는 output이 나오는데, 이런 것이 무려 400개가 있는것입니다. 따라서 너무 많은 Feature로 발생할 수 있는 Overfitting을 방지하고자 Pooling을 사용하는 것입니다.

지금까지 우리가 본것은 하나의 Layer에서 Filter가 어떤 역할을 하는지 보여드린 것이고, 이제 Filter가 Conv Layer를 통과하면서 어떻게 패턴을 분석하는가에 대해 알아보겠습니다.

우선 사람이 손으로 쓴 숫자 7을 나타내는 이미지가 있고, 3x3 Filter 4개가 있습니다. 즉 기존 예시들과 다르게 Filter가 여러개라는 것을 유의하셔야 합니다.

이 Filter안의 값에서 -1은 검은색, 1은 하얀색, 0은 회색을 뜻합니다. 그리고 아래 보이는 4개의 이미지가 각 Filter를 Convoving한 Output입니다. 각 Filter가 발견한 패턴은 두가지로 구분할 수 있습니다. 첫번째는 4가지 Filter가 공통적으로 발견한 이미지의 가장자리 즉 Edge입니다. 그리고 두번째가 밝게 보이는 하얀색 부분입니다.

7을 3차원으로 바라보았을 때, 첫번째 Output의 경우 위에서 바라봤을 때 보이는 패턴을 / 두번째는 왼쪽에서 / 세번째는 아래에서 / 네 번째는 오른쪽을 인식하고 있습니다. 이해하기 어렵다면 각 방향에서 손전등을 비췄다고 생각하시면 됩니다.

이것은 하나의 Conv Layer를 통과시켰을 때의 결과이고, 더 많은 Layer를 통과시킬수록 구체적인 패턴을 발견할 수 있습니다.

예를 들어 위에서 여섯번째 3x3 Output은 원을 발견하였고, 마지막 Ouput은 corner를 발견하였고, 이것보다 더 우리가 레이어를 통과시키면 동물 개와 같이 훨씬더 복잡한 모양의 패턴도 알아낼 수 있습니다.

이제 또 다른 예시를 보면서 최종적으로 CNN을 정리해보겠습니다. 우선 Layer는 패턴을 분석하기 위한 Conv Layer, 데이터 손실을 방지하기 위한 Relu Layer, overfitting을 방지하는 Pooling Layer 등을 이용하여 네트워크를 구성합니다. 그리고 마지막에 FC Layer라는 것을 이용하여 최종적으로 Input 이미지가 무엇인지 분류(Classification)를 합니다.

[머신러닝 순한맛] 다변량 정규분포(Multivariate Gaussian Distribution) in 이상 탐지(Anomaly Detection)

Box형 — Sun, 24 May 2020 14:40:57 +0900

혁신을 할 때는 모든 사람들이 당신을 미쳤다고 할 테니,

그들 말에 준비가 되어 있어야 한다.

- 래리 앨리슨 (Oracle ceo) -

시작하며

우리는 저번 포스팅을 통해 Anomaly Detection의 전반적인 이해를 마쳤습니다. 이번 포스팅에서는 Anomaly Detection에서 발생할 수 있는 문제를 살펴보며, 이에 대한 해결책인 다변량 정규분포(Multivariate Gaussian Distribution)에 대해 공부해보겠습니다.

이번 포스팅은 아래 포스팅들을 통해 Anomaly Detection을 이해하고 보시면 더욱 효과적입니다.

https://box-world.tistory.com/35

[머신러닝 순한맛] 이상 탐지(Anomaly Detection)이란?

"기술에는 품위와 친절이 녹아있어야 한다." - 팀 쿡 - 시작하며 여기 암을 조기에 발견할 수 있는 인공지능을 만드는 개발자가 있습니다. 그 개발자는 우여곡절끝에 정확도 99.00%를 자랑하는 머��

box-world.tistory.com

https://box-world.tistory.com/36

[머신러닝 순한맛] 이상 탐지(Anomaly Detection) vs Classification in Supervised Learning

실패에 대해 걱정하지 마라. 한번만 제대로 하면 된다. - 드류 휴스턴(Dropbox 공동 창업자) 시작하며 우리는 저번 포스팅에서 Anomaly Detection이란 무엇이며,이를 위한 알고리즘의 작동 원리까지 공��

box-world.tistory.com

Multivariate Gaussian Distribution

위 그림은 CPU 연산량 $(x_1)$에 따라 메모리 사용량 $(x_2)$을 측정하는 Dataset입니다. 여기서 Anomaly Detection을 사용하고자 각 feature를 일반적인 가우시안 분포(Gaussian Distribution)으로 나타내자 문제가 발생하였습니다.

보시다시피 녹색 데이터는 Anomaly Data임이 분명한데, 이를 일반적인 '2차원 가우시안 분포'로 나타낼 때는 $ε$보다 큰 값을 가지게 되어 정상적인 데이터로 분류됩니다. 이를 해결하기 위해 나온 것이 '다변량 정규분포(Multivariate Gaussian Distribution)'입니다.

우리가 지금까지 배운 Anomaly Detection 알고리즘은 가장 보편적으로 사용되는 'Original Model'입니다. 사실 방금 문제를 'Multivariate Gaussian Distribution' 사용없이 '새로운 feature를 추가하여 해결하는 방법'도 있으나, 새로운 feature를 사용자가 직접 추가해야한다는 점에서 불편하고 정확도가 떨어지기에 좀 더 formal한 방법을 사용하여 해결하고자 하는 것입니다.

'Multivariate Gaussian Distribution'은 한마디로 이차원에서 존재하던 정규분포를 다차원 공간으로 확장한 것입니다. 문제가 되는 Dataset에서 Anomaly 데이터를 검출하지 못했던 이유는 '이차원 정규분포'에서 데이터를 바라보기 때문에 녹색 데이터 그리고 비슷한 위치에 존재하는 빨간색 데이터가 사실상 동일한 위치에 있는걸로 보이기 때문입니다. 따라서 이를 3차원 이상으로 확장하여 이를 보완하고자 하는 것입니다.

'Multivariate Gaussian Distribution' 에 사용되는 공식은 위와 같습니다. 여기에는 두가지 parameter가 등장하는데, $μ$는 n 개의 feature를 나타내는 n차원 vector이고, $Σ$는 공분산 행렬(covariance matrix)로 $n * n$차원 행렬입니다. 그리고 $|Σ|$은 sigma의 절대값으로 뒤에 나올 sigma 값을 결정합니다. 한가지 주의할 점은 각 feature에 대한 가우시안 분포를 구하여 곱하는 구조가 아닌 공식에 parameter를 대입하여 한번에 $p(x)$를 도출합니다.

PCA 알고리즘에서 이용되는 'covariance matrix'는 간단히 말하자면 데이터가 어떻게 퍼져있는가에 대한 행렬입니다. PCA에서 이것이 이용됐던 이유는 기존 데이터의 분포와 성질을 최대한 변화시키지 않으면서 낮은 차원에 mapping하기 위해서 였습니다. 따라서 'Multivariate Gaussian Distribution'에서도 2차원에서 나타나던 데이터의 분포를 최대한 변화시키지 않으면서 이를 다차원으로 확장시키기 위해 공분산 행렬을 이용하는 것입니다.

PCA 알고리즘이 궁금하신 분은 아래 포스팅을, 공분산 행렬에 대해 더 궁금하신 분은 아래 두번째 포스팅을 참고해주세요

https://box-world.tistory.com/33

[머신러닝 순한맛] PCA(Principal Component Analysis) 알고리즘이란?

″성공의 핵심 요소는 인내심이다.” -Bill Gates- 시작하며 우리 저번 포스팅에서 Data Compression 또는 Dimentianality Reduction의 기본적인 원리를 알아보았습니다. 이번 시간에는 이러한 원리를..

box-world.tistory.com

https://angeloyeo.github.io/2019/07/27/PCA.html

주성분 분석(PCA) - 공돌이의 수학정리노트

angeloyeo.github.io

이제 'Multivariate Gaussian Distribution'을 기하학적으로 이해해보겠습니다. 위 그림은 두 개의 parameter $μ$과 $Σ$에 따른 그래프의 변화입니다. $μ$가 고정된 상태에서 $Σ$ 행렬의 값이 커질수록 원의 크기가 커지면서 데이터가 퍼지게 됩니다. 반대로 값이 작아질수록 원의 크기가 작아지면서 데이터가 뭉치게 됩니다.

$Σ$ 행렬에서 1행 1열의 element는 $x_1$의 분산(퍼지는 정도)를 2행 2열은 $x_2$의 분산을 결정합니다. 따라서 $x_2$의 분산을 고정시켜놓고 $x_1$의 분산을 줄이면 $x_1$ 관점에서 원이 홀쭉해지고, 분산을 늘리면 원이 뚱뚱해짐을 확인할 수 있습니다.

반대로 $x_1$의 분산을 고정하고 $x_2$의 분산을 변화시켰을 때 그래프의 변화입니다.

$Σ$ 행렬에서 1행 2열과 2행 1열의 element는 $x_1$과 $x_2$의 상대적인 위치관계에 대한 분산을 조절합니다. 즉 분산 값이 커질수록 데이터가 퍼지게 되니 원은 길게 홀쭉해지게 됩니다. 반대로 분산이 작아질수록 원은 납작하게 홀쭉해집니다.

$μ$는 'Multivariate Gaussian Distribution'의 중심 위치를 결정합니다.

어쨌든 몇가지 예시를 통해 parameter 값을 조정하여 'Multivariate Gaussian Distribution'가 어떻게 변하는지를 보았고, 이것을 이용하여 Anomaly Data가 확실히 검출될 수 있도록 해야합니다.

이제 Cpu / Memory Dataset에서 발생했던 문제를 해결해보겠습니다. 우선 Dataset의 평균과 분산을 이용하여 $μ$와 $Σ$를 구하고, 이를'Multivariate Gaussian Distribution' 공식에 대입하여 $p(x)$를 도출합니다. 이때 $ε$보다 작은 데이터는 Anomaly 데이터가 될 것입니다.

이제 데이터의 분포를 살펴보면 정상적인 데이터들은 길쭉한 원의 형태로 분포되어 있고, 녹색 데이터만 동떨어져 확실히 분류가 됨을 볼 수 있습니다.

우리가 기존에 Original Model에서 사용했던 $p(x)$ 공식은 사실상 'Multivariate Gaussian Distribution'의 $p(x)$와 동일하다고 봐도 무방합니다. 왜냐하면 Original $p(x)$에서 각각의 feature에 대한 $σ^2$을 모두 모아 행렬로 표현하면 'Multivariate Gaussian Distribution'의 $p(x)$의 $Σ$가 되기 때문입니다.

마지막으로 두 모델의 장단점을 비교해보겠습니다.

* Original Model

- (단점) 문제가 발생했을 때, 사람이 직접 오류를 분석하고 feature를 추가해야 한다는 점에서 리스크가 있습니다.

- (장점) 연산 Cost가 매우 저렴하기 때문에 보통 보편적으로 많이 사용합니다. 그래서 feature가 100000개라도 부담없이 사용하며, training set이 100개정도로 매우 작아도 Anomaly Detection이 가능합니다.

* Multivariate Gaussian Distribution

- (단점) $Σ$는 $n*n$ 행렬입니다. 따라서 연산 과정에서 이것의 inverse를 계산하는 cost는 매우 크기 때문에 dataset이 100000개 이상일 경우 사용하기 적절치 않습니다.

- inverse를 계산해야하기 때문에 $Σ$가 'non-invertible'이면 안됩니다. 따라서 이를 방지하기 위해 중복된 feature가 있다면 제거해야 합니다. 그리고 반드시 data의 개수가 feature의 수보다 10배 이상은 클때 사용이 가능합니다.

- (장점) 특정 조건에서만 사용이 가능하지만, 문제 발생 시 사람이 직접 feature를 추가하지 않아도 됩니다.

[머신러닝 순한맛] 이상 탐지(Anomaly Detection) vs Classification in Supervised Learning

Box형 — Sun, 24 May 2020 00:37:22 +0900

실패에 대해 걱정하지 마라. 한번만 제대로 하면 된다.

- 드류 휴스턴(Dropbox 공동 창업자)

시작하며

우리는 저번 포스팅에서 Anomaly Detection이란 무엇이며,이를 위한 알고리즘의 작동 원리까지 공부했습니다.

이번 포스팅에서는 Anomaly Detection 알고리즘의 성능을 어떻게 평가할 수 있는지 그리고 Anomaly Detection과 Supervised Learning의 차이점을 알아보겠습니다.

이번 포스팅은 아래 포스팅들을 통해 'Test / Cv data', 'Anomaly Detection'에 대해 이해하고 보시면 더욱 효과적입니다.

https://box-world.tistory.com/23

[머신러닝] 머신러닝 학습 시 고려해야할 것 : Test data와 Cv data란?

시작하며 우리가 데이터를 모델에 학습시킬 때, 모델이 학습한 결과와 실제값이 달라 accuracy(정확도) 가 떨어지는 상황에서 무엇을 할 수 있을까요? 더 많은 데이터를 넣어본다? 데이터의 표본이

box-world.tistory.com

https://box-world.tistory.com/35

[머신러닝 순한맛] 이상 탐지(Anomaly Detection)이란?

box-world.tistory.com

Anomaly Detection 알고리즘 성능 측정하기

우선 Anomaly Detection 알고리즘의 성능을 측정하는 방법에 대해 알아보겠습니다.

기본적으로 성능 측정을 위해서는 학습에 사용될 데이터가 'Labeled Data'여야 합니다. 그래야 알고리즘이 데이터를 분류한 결과가 맞는지 틀린지 알 수 있기 때문입니다.

따라서 우리에게 주어진 데이터가 'Unlabeled'일 경우, 보통 Anomaly 데이터의 Label을 $y = 1$로 하고, 그렇지 않은 정상적인 데이터의 Label은 $y=0$으로 설정하여 Labeled Data로 바꿔줍니다.

저번 포스팅에서 다룬 비행기 엔진에 대한 Dataset을 예시로 들어보겠습니다. Dataset은 10000개의 정상적인 엔진과 20개의 비정상적인 엔진으로 구성되어 있습니다. 이때 비정상적인 엔진은 전체 데이터의 0.002%에 불과하기 때문에 이를 검출하기 위해서는 Anomaly Detection 알고리즘이 필요합니다.

우선 Dataset을 Training set : Test Set : Cv set = $6 : 2 : 2$로 나눕니다. 이때 Traing set에 들어가는 6000개의 데이터는 모두 정상적인 데이터 $(y=1)$로 구성하고, 20개의 비정상적인 데이터는 10개씩 나눠 'Test Set'과 'Cv Set'에 들어가게 됩니다.

데이터를 나눈 후, Training set을 이용하여 $p(x)$ 함수를 만듭니다. 그리고 Cv / Test set을 여기에 집어넣어 결과값 $y = 1 or 0$인지 확인합니다. 이때 이를 구분짓는 경계(Threshold)를 $ε$으로 설정하여 이것보다 작으면 $y = 1$이라고 판단합니다.

여기에서 더 나아가 보통 Anomaly Detection 알고리즘을 평가할 때는, 'Precision / Recall'을 이용한 'F1 Score'를 이용합니다. 따라서 Cv set을 이용하여 여러 $ε$에 대한 각 알고리즘의 F1 score를 이용하여 최적의 $ε$ 값을 찾아낼 수 있습니다. 그 후 최종적인 알고리즘을 평가할 때 Test set을 이용하게 됩니다.

Anomaly Detection vs Classification in Supervised Learning

그런데 여기서 의문이 듭니다. 우리가 다루는 데이터가 Labeled data라는 점에서 굳이 Anomaly를 사용하지 않고, Supervised Learning의 Classification 알고리즘을 이용하여 비정상적인 데이터를 분류할 수는 없는 걸까요?

결론은 Logistic Regression과 같은 알고리즘으로는 Anomaly한 데이터를 검출하는 것이 거의 불가능합니다. 왜냐하면 기본적으로 Anomaly Detection 알고리즘은 데이터를 분류할 때 '데이터의 밀도(Density)'를 이용합니다.

예를 들어 정상적인 비행기 엔진이라면 대부분 비슷한 성능을 보일 것이므로 서로 뭉쳐있어 밀도가 높을 것입니다. 그러나 비정상적인 비행기 엔진은 정상적인 데이터들과는 동떨어져있기 때문에 밀도가 낮을 것입니다. 따라서 알고리즘은 이 밀도를 이용하여 밀도가 아주 낮은 데이터를 Anomaly하다고 판단하는 것입니다.

이에 반해 'Logistic Regression'과 같은 알고리즘은 정상적인 데이터와 비정상적인 데이터가 각각 학습되어야 합니다. 즉 알고리즘이 분류할 때 단순히 정상적인 데이터가 아니니 비정상적인 데이터겠지가 아니라, 정상적인 데이터에 대한 학습 그리고 비정상적인 데이터에 대한 학습이 모두 이루어져야 하는 것입니다.

그러니 우리가 비행기 엔진 Dataset의 경우, 비정상적인 데이터는 20개로 학습에 턱없이 부족하기 때문에 일반적인 Classification 알고리즘을 적용할 수 없는 것입니다.

Non - Gaussian Features

우리는 Anomaly Detection 알고리즘에서 '가우시안 분포(Gaussian Distribution)' 기반의 $p(x)$ 함수를 이용하였습니다. 그런데 만약 특정 feature의 확률 밀도 함수가 일반적인 가우시안 분포의 모양을 띄지 않는다면, 해당 feature의 모든 data에 $\log{x}$나 $\sqrt{x}$를 적용해주면 이를 해결할 수 있습니다.

[머신러닝 순한맛] 이상 탐지(Anomaly Detection)이란?

Box형 — Fri, 22 May 2020 14:26:12 +0900

"기술에는 품위와 친절이 녹아있어야 한다."

- 팀 쿡 -

시작하며

여기 암을 조기에 발견할 수 있는 인공지능을 만드는 개발자가 있습니다. 그 개발자는 우여곡절끝에 정확도 99.00%를 자랑하는 머신러닝 학습 모델을 만들어 냈습니다.

하지만 우리나라 기준으로 연간 암 발병률은 0.005%가 채 되지 않습니다. 열심히 만든 개발자에게는 99%도 겨우 만들어낸 훌륭한 모델이었으면 좋겠지만, 안타깝게도 이것으로 암을 조기에 발견하기에는 턱없이 부족한 정확도인것입니다.

이번 포스팅에서는 기존에 우리가 알던 분류(Classification)와는 다르게 100000개의 데이터 중에서 1개, 1000000000개 중에서 10개 꼴로 일어나는 것 같이 아주 극소수의 매우 작은 비율의 데이터 혹은 이상한(비정상적인) 데이터를 검출하는데 사용되는 이상 탐지(Anomaly Detection)에 대해서 공부해보겠습니다.

Anomaly Detection

여기 비행기 엔진을 만드는 공장이 있습니다. 정상적인 엔진이라면 '열(heat)'이 높아질수록 '회전(vibration)' 또한 빨라져야 합니다. 이제 이것을 염두에 두고 데이터를 관찰해보겠습니다.

대부분의 데이터는 열과 회전의 비례관계를 만족하며 정상적인 엔진들이라고 판단되지만, 녹색으로 표시된 데이터는 이 비례관계를 만족하다고 하기엔 애매하다고 할 수 있습니다. 바로 이 녹색 데이터가 비정상적인 데이터 Anonmaly Data입니다.

이때 한가지 유의할 점은 'Anomaly Data Detection'이라는 것은 오류를 탐지하기 위한 알고리즘이 아니라, 전체 데이터 중 매우 작은 비율을 갖는 한쪽 데이터인 'skewed class'를 검출하는 알고리즘입니다.

그렇다면 m개의 dataset이 있을 때, $x_{test}$가 anomaly한 데이터인지 어떻게 판단할 수 있을가요? 여기에 바로 데이터의 밀도를 추정하는 함수(Density Estimation)인 $p(x)$가 이용됩니다. 이것의 함수값은 우리가 넣은 데이터 $x$가 정상적인 데이터일 가능성(probability)를 의미합니다. 그래서 이 함수값이 이따 살펴볼 특정 경계값 $(ε)$ 보다 작다면 Anomaly하다고 판단하게 됩니다.

우선 구체적으로 데이터의 밀도를 추정하는 함수 $p(x)$가 어떤 형태를 띄는지 알기 위해서는 몇가지 수학적인 개념이 필요한데 겁먹을 필요 없습니다! 저 또한 수학을 잘하지 못하기 때문에 제가 이해한대로 최대한 쉽게 설명해드릴테니 믿고 따라와주시면 됩니다. :)

우선 확률 밀도 함수(Probability Density Function)라는 개념부터 살펴보겠습니다. $x = a$일 때 함수값이 $f(a)$라는 것은 어떤 feature $x$가 $a$라는 값을 가질 상대적인 가능성을 의미합니다.

혹은 이 함수값은 밀도를 의미하는데 내가 input으로 넣은 데이터의 밀도가 크다는 것은 결국 나랑 비슷한 값을 갖는 데이터가 많다는 것이기 때문에 정상적인 데이터일 확률이 크다고 이해하셔도 됩니다.

즉 상대적인 가능성을 뜻하는 $f(a)$가 낮을수록 feature $x$에서 $a$라는 값이 적게 나타나는 것이기 때문에 Anomaly할 확률은 그와 반대로 커지게 됩니다.

이 확률 밀도 함수라는 개념을 기반으로 밀도를 추정하는 방법에는 'parametric'과 'non-parametric'이 있는데 이중 우리가 이용할 방법은 'non-parametric'입니다.

정규분포

'parametric'은 우리가 사용할 dataset의 모든 feature가 '정규분포'를 따른다고 가정하고 밀도를 추정합니다. 즉 위 이미지처럼 종 모양의 형태를 띄는 정규분포는 feature $x$에 대해 평균에 가까울수록 밀도가 커지기 때문에, 평균과 비슷한 데이터가 제일 많을 것이라고 가정하고 밀도를 추정하는 것입니다.

그러나 우리가 일상 생활에서 발견하는 대부분의 데이터는 이런식의 예쁜 정규분포를 만족하지 않습니다. 따라서 순수하게 관측된 데이터만으로 확률밀도함수를 만드는 'non-parametic'을 이용하여 우리는 밀도를 추정할 것입니다.

머신러닝에서 사용하는 'non-parametic' 밀도 추정 방법 중 하나가 '커널 밀도 추정(Kernel Density Estimation)'입니다. 즉 커널이라는 것을 이용하여 확률 밀도 함수를 만들겠다는 것인데, 이것은

1) 전 구간에서 함수값이 양수여야 하며 $K(x) >= 0$

2) 대칭적이어야하고 $K(x) = K(-x)$

3) 함수의 중앙에서 멀어질수록 함수값이 감소해야합니다. $K'(x) <= 0 for every x >0$

커널의 4 종류

이를 만족하는 커널에는 위와 같이 4종류가 있는데, 어떤 커널을 고르느냐는 중요한게 아니기 때문에 이중 계산이 간편한 '가우시안 커널(Gaussian Kernel)'을 사용하겠습니다.

우선 여기에 하나의 feature에 대한 dataset이 있습니다. 그리고 Kernel을 이용하여 특정 feature의 확률 밀도 함수인 'KDE(Kernel Density Estimation)'를 구하는 법 은 다음과 같습니다.

우선 각 데이터 $x_{(i)}$ 하나 당 $x_{(i)}$를 중심으로 하는 가우시안 커널을 하나씩 생성해줍니다. 그리고 더해주면 오른쪽 그림의 파란색 함수에 해당하는 KDE를 구할 수 있습니다.

공식 p(x, μ, σ)

이해를 위해서 제가 단계를 나눠 KDE를 구하는 방식을 설명드렸지만, 각 feature의 $μ$(평균) 그리고 $σ$(표준편차)를 구하여 위 공식에 대입하면 별도의 단계없이 한번에 '해당 feature의 KDE'를 구할 수 있습니다.

여기서 중요한 것은 각 feature의 가우시안 커널 공식에서 h에 해당하는 'bandwidth'입니다. 이 bandwidth 가 너무 커지면 KDE가 완만해져서 Anomaly를 찾기 어려워지고, 반대로 너무 작아지면 KDE가 뾰족해져서 중심에서 조금만 멀어져도 Anomaly라고 판단하게 됩니다. 따라서 우리에게 중요한 것은 적절한 'bandwidth'를 찾는 것입니다.

이제 우리는 하나의 feature에 대해 'KDE' 즉 확률 밀도 함수를 구하는 법을 알게 되었습니다. 이제 이것을 Anomaly 데이터를 검출하는 알고리즘에 적용하기 위해서는 몇가지 단계를 거쳐야 합니다. 마지막에 총정리를 할테니 계속 따라와주세요!

우선 dataset에 각 feature마다 하나의 KDE를 모두 구해줍니다. 그 다음 각 feature에서 나온 KDE를 모두 곱해주면 이것이 바로 $p(x)$가 됩니다.

이제 우리에게는 데이터가 Anomaly한지 검출할 수 있는 함수 $p(x)$가 있습니다. 이제 우리가 해야할 일은 dataset을 보았을 때, Anomaly한 것으로 추정되는 데이터 $x_{(i)}$를 함수 $p(x)$에 집어넣으면 됩니다. 그리고 이렇게 해서 도출된 함수값 $p(x_{(i)})$가 양수이지만 매우 작은 $ε$보다 작다면 Anomaly하다고 판단하고, 크다면 정상적인 데이터라고 판단하게 됩니다.

요약

1) 모든 Feature에 대해서, 각 Feature의 데이터들을 중심으로 하는 가우시안 커널을 생성하고 이들을 모두 더하여, 각 Feature에 대한 확률 밀도 함수 KDE를 만들어 냅니다.

2) 각 feature의 KDE를 모두 곱하여 $p(x)$를 구합니다.

*3) * dataset에서 Anomaly하다고 생각되는 데이터를 추려낸 후, 이 데이터들을 $p(x)$의 input으로 넣어서 그 값이 $ε$을 기준으로 작은지 큰지에 따라 Anomaly 데이터 여부를 판단하면 됩니다.

마지막으로 예시를 보면서 개념을 복습해보겠습니다. 여기 $x1$, $x2$ 두개의 feature를 가지는 dataset이 있습니다. 따라서 각 feature마다 $μ$(평균) 그리고 $σ$(표준편차)를 구하여 공식에 대입하여 'KDE'를 구합니다.

보시다시피 feature $x2$의 $σ$가 더 작아서 분포가 뾰족한 것을 볼 수 있습니다. 이제 이 두개의 KDE를 곱하여 $p(x)$를 도출하고 우리가 테스트해보고 싶은 데이터를 이 함수의 input으로 넣어주면 됩니다. 이때 $ε = 0.02$라고 가정하겠습니다.

우선 $x^{{1}}_{test}$의 경우는 함수에 넣었을 때 0.0426으로 0.02인 $ε$보다 크기 때문에 정상적인 데이터라고 판단합니다. 하지만 $x^{{2}}_{test}$의 경우 0.0021로 $ε$보다 작기 때문에 Anomaly한 데이터라고 판단하게 되고 실제 그래프를 보더라도 Anomaly한 데이터일 확률이 매우 커보입니다.

https://box-world.tistory.com/24

[머신러닝] 머신러닝 시스템 디자인 하기 : Precision, Recall, F score

box-world.tistory.com

제가 이전에 위 포스팅을 통해 Skewed Class, Precision, Recall, F1 score의 개념에 대해서 다룬적이 있습니다.

바로 이번 포스팅에서 배운 Anomaly Detection을 위한 알고리즘의 성능을 측정하는데 쓰이는 대표적인 지표가 바로 이 Precision, Recall, F1 score입니다. 따라서 이 포스팅을 완벽하게 공부하신 후 위 포스팅을 보신다면 큰 도움이 될거라고 생각합니다.

[머신러닝 순한맛] PCA(Principal Component Analysis) 알고리즘이란? (2)

Box형 — Thu, 21 May 2020 19:08:28 +0900

여기에서 실패는 하나의 옵션이다.

당신이 실패를 겪지 않았다면, 충분히 혁신하지 않았다는 것이다.

- 엘론 머스크 -

시작하며

저번 포스팅에서 조금 어려울수도 있었던 PCA 알고리즘의 원리에 대해 알아보았습니다. 이번 포스팅에서는 PCA 알고리즘으로 차원을 감소시킨 데이터의 재복원, 알고리즘의 장단점 등을 알아보겠습니다.

이번 포스팅은 'PCA 알고리즘의 원리'를 이해하시고 공부하시면 더욱 효과적입니다.

https://box-world.tistory.com/33

[머신러닝 순한맛] PCA(Principal Component Analysis) 알고리즘이란?

″성공의 핵심 요소는 인내심이다.” -Bill Gates- 시작하며 우리 저번 포스팅에서 Data Compression 또는 Dimentianality Reduction의 기본적인 원리를 알아보았습니다. 이번 시간에는 이러한 원리를 바탕으�

box-world.tistory.com

(https://box-world.tistory.com/33

[머신러닝 순한맛] PCA(Principal Component Analysis) 알고리즘이란?

box-world.tistory.com

재복원(Reconstruction)

먼저 감소시킨 차원의 데이터를 어떻게 다시 원래의 차원의 데이터로 복원시킬 수 있는지 알아보겠습니다.

$$z = U^T_{reduce} * x$$

예를 들어 n차원에서 k차원으로 데이터를 차원 감소시켰을 때, 차원 감소된 데이터 $z$는 분산도가 가장 높은 k개의 PC들을 가지는 행렬 $U$와 기존 데이터 $x$를 곱함으로써 구할 수 있습니다.

$$x = U_{reduce} * z$$

우리가 다시 복원하려는 원래의 데이터는 $x$입니다. 따라서 $x$에 대해서 식을 정리하면, 위 식이 나오게 됩니다. 이때 $U_{reduce}$는 $n*k$차원, $z$는 $k * 1$차원이므로 원래의 데이터 $x$는 정상적으로 n차원 vector가 되는 것을 확인할 수 있습니다.

그러나 본래대로 복원된 n 차원의 데이터는 차원 감소되기 전 본래의 n 차원 데이터와 조금 다릅니다. 왜냐하면 차원이 감소되었다가 다시 복원되는 과정을 거치면서 데이터가 유실되었기 때문입니다.

Number of PC

** 그렇다면 n 차원의 데이터를 차원 감소시키고 싶다면 몇차원으로 감소시켜야할지 k값은 어떻게 선택해야할까요?**

여기에는 두가지 방법이 있습니다. 첫번쨰 방법을 위한 공식에는 '원래의 점과 PC1까지의 거리(Protection Error)', 그리고 '원점에서부터 원래의 점까지의 거리(Total Variation)' 두가지 요소가 필요합니다.

이 둘의 비율은 원래의 n차원 데이터 x와 k차원으로 감소된 점과의 오차율을 의미하며 이 값이 작을 수록 둘의 차이가 적어지는 것입니다. 이때 오차율이 1%라면, 반대로 99%의 복원율을 갖는다고 생각할 수도 있습니다. 주로 이 오차율에 자주 사용되는 비율에는 1%와 5%가 있습니다.

이 오차율을 이용하여 다음과 같이 활용하여 몇차원으로 줄일지 결정할 수 있습니다. 우선 우리가 알고리즘을 구현하였다면, k 값을 1부터 시작하여 1씩 늘려나가면서 각 k 값에 대한 오차율을 구할 수 있을 것입니다. 이때 k값을 늘려나가다가 오차율이 1% 이하가 되는 그떄의 k값을 선택하여 활용하면 되는 것입니다.

예를 들어 k = 16 이었을 때 오차율이 1.18% 였다가, k = 17이 되면서 오차율이 0.99%가 되어서 1% 이하로 되었다면 우리가 감소시킬 차원은 17차원이 되는 것입니다.

몇 차원으로 줄일지 정하는 또 하나의 방법은 특이값 분해(SVD)를 이용하는 것입니다. 제가 이 부분에 대해서 깊이 이해하지는 못했지만 간단하게 SVD가 어떤 역할을 하는지에 대해 설명해보겠습니다.

우리가 PCA 알고리즘을 사용하는 것은 높은 차원에서 낮은 차원으로 데이터를 차원 감소시키기 위함입니다. 이 과정에서 'SVD'는 차원을 낮출 때 데이터들 간의 상관관계를 그대로 유지시켜주는 수단입니다.

다시 말해서 우리가 n개의 PC 중 분산도가 가장 높은 k개의 PC 만을 골라 그곳에 데이터를 투영시켜주게 되는데 아시다시피 이 PC들은 서로 직교 관계에 있습니다. 즉 SVD는 n차원의 PC에서 k 차원의 PC로 줄일 떄 PC들간의 직교 관계를 그대로 유지시켜 주는데 하나의 수단으로 쓰이는 것으로 보입니다.

어쨌든 이 SVD를 이용하여 1에서 K차원 SVD값(S)과 N차원 SVD값의 비율을 뺴서 0.01보다 작게 나오는 k값을 선택하는 것입니다. 이 식을 오른쪽 식처럼 SVD에 대한 항을 우변으로 옮기고 나머지를 좌변으로 옮기면 0.99 이상의 복원율을 만족하게끔 한다는 것을 알 수 있습니다.

PCA 알고리즘의 적용

PCA 알고리즘은 비지도 학습(unsupervised Leaning)에서 쓰는 알고리즘이지만, 차원을 감소시켜 데이터를 가볍게 하여 머신러닝 학습의 속도를 높인다는 점에서 Supervised Learning에서도 활용이 가능합니다.

Supervised Learning에 대한 복습이 필요하신 분은 아래 포스팅을 참고해주시면 됩니다 :)

https://box-world.tistory.com/6

[머신러닝] 비용함수(Cost Function)란

시작하며 오늘 포스팅에서는 머신러닝의 기본적인 모델과 함께 가설함수(hypothesis) 와 비용함수 (Cost Function) 를 알아보며 다음 포스팅에서 알아볼 경사 하강 알고리즘을 위한 기초를 다져보겠습�

box-world.tistory.com

우선 적용을 위하여 Labeled된 dataset에서 x 값만 추출해냅니다. 즉 Unlabeled Data로 바꾸는 것입니다. 그리고 이 x data에 PCA 알고리즘을 적용하여 차원이 감소된 데이터 'z'를 도출합니다. 그리고 이 z data와 차원이 감소되기 전 매칭되던 y data를 매칭시켜 새로운 training dataset을 생성합니다. 그러면 가설함수나 cost 함수 또한 x 대신 z가 대신하는 것이 가능해집니다. 이렇게 PCA 알고리즘에 의해 새롭게 맵핑된 z data는 test set과 cv set에도 사용이 가능합니다.

이렇게 PCA 알고리즘을 이용하면 데이터가 가벼워지기 때문에, 메모리나 디스크와 같은 HW 사용을 줄일 수 있으며, 머신러닝 학습속도를 향상시키고 데이터를 시각화(visualization)시키는데에도 유용하게 사용됩니다.

이런 PCA 알고리즘 대표적으로 사용되는 분야가 '얼굴 인식(Face Recognition)'입니다. 간단히 설명드리자면 얼굴 인식에서 사용되는 20 개의 데이터가 45 x 40 이라고 해보겠습니다. 그러면 각 픽셀을 feature라고 생각하면 $45 * 40 = 1800$이므로 데이터는 1800차원의 벡터라고 생각할 수 있습니다.

그러면 우리가 이전에 4차원의 데이터를 2차원으로 줄일 때, 4개의 PC에서 분산도가 높은 2개의 PC만을 걸러내서 데이터를 투영시켰을 때, 이때 분산도가 높다는 것은 데이터에 많은 영향을 준다는 것이었습니다.

그러니 얼굴 인식에서도 1800차원 데이터에 대해 1800개의 PC를 생성하여 분산도가 높은 순으로 뽑아낸 20~30개의 PC에서 뽑아낸 이미지는 데이터에 공통된 요소를 잘 내포하고 있을 것입니다. 이를 EigenFace라고도 합니다. 그리고 분산도가 낮은 PC일수록 세부적인 정보 차이를 나타내게 되며 이를 '노이즈(noise)성 정보'라고 합니다.

그러나 PCA 알고리즘이 항상 좋은 것은 아닙니다. 원래의 데이터에서 차원을 낮춘다는 점에서 feature가 적은 데이터에서 자주 일어나는 Overfit 발생의 여지가 있습니다. 혹은 Overfit이 발생하였을 때, 모델의 차수를 낮추고자 PCA 알고리즘을 사용하는 것보다는 정규화(Normalization)의 람다를 이용하여 문제를 해결하는 것이 훨씬 효과적입니다.

따라서 Data가 복잡하다고 해서 무조건 PCA를 이용하기보다는, 우선 기존의 Data를 이용하여 학습해보고 메모리나 디스크의 부족 문제로 정상적인 수행이 어렵거나 데이터가 무거워 학습 시간이 오래 걸릴 경우 사용하는 것을 추천 드립니다.

[머신러닝 순한맛] PCA(Principal Component Analysis) 알고리즘이란?

Box형 — Tue, 19 May 2020 22:46:59 +0900

″성공의 핵심 요소는 인내심이다.”

-Bill Gates-

시작하며

우리 저번 포스팅에서 Data Compression 또는 Dimentianality Reduction의 기본적인 원리를 알아보았습니다. 이번 시간에는 이러한 원리를 바탕으로 효과적으로 차원을 줄이는 알고리즘인 PCA(Principal Component Analysis) Algorithm에 대해 공부해보겠습니다.

한가지 유의할 점은 기존에 많은 분들이 PCA에 대해 다루실 때 수학적으로 접근하여 설명하는 부분이 저에게는 잘 와닿지 않았습니다. 그래서 저는 그보다는 쉽게 이해할 수 있도록, 빠지는 개념은 없지만 최대한 풀어서 설명하도록 하겠습니다.

이번 포스팅은 아래 포스팅을 공부하고 보시면 더욱 효과적입니다.

https://box-world.tistory.com/32

PCA Algorithm

여기 쥐와 유전에 대한 상관관계를 표현해놓은 Dataset이 있습니다. 2 개의 유전자는 Feature를 뜻하고, 6 마리의 쥐는 데이터를 의미합니다.

만약 Feature가 하나라면, 우리는 데이터를 위와 같이 하나의 직선 위에 나타낼 수 있습니다. 특히 이때 'Mouse' 1, 2, 3번의 값은 낮고 4, 5, 6번의 값은 높다는 것을 알 수 있습니다.

만약 Feature가 두개라면, 우리는 하나의 축을 추가하여 데이터를 다음과 같이 표현할 수 있습니다. 이때도 역시 비슷한 데이터들끼리 모여있다는 것(Cluster)을 확인할 수 있습니다.

만약 Feature가 세개라면, 다시 한번 축을 추가하여 데이터를 3차원 위에서 표현할 수 있습니다.

하지만 4개의 유전자라면 즉 Feature가 4개라면, 4차원이기 때문에 더 이상 데이터를 표현할 수 없습니다.

그래서 이제부터 우리는 PCA가 어떻게 4개 이상의 유전자를 측정할 수 있는지 알아볼 것입니다. 즉 4개 이상의 차원에 존재하는 데이터를 PCA를 이용하여 2차원으로 감소시켜 표현할 것입니다.

그리고 위 그래프에서 쥐 1,2,3과 4,5,6은 여전히 군집해있다는 것을 확인할 수 있습니다. 그래서 우리는 PCA가 어떻게 특정 Feature를 Data Clustering에 가장 중요한지 알려줄 수 있는지도 알아볼 것입니다.

우선 PCA가 무엇인지, 그리고 작동 원리가 무엇인지 알아보기 위해 다시 데이터의 Feature를 두개로 줄여보겠습니다.

그 다음 위 2개의 이미지처럼 Gene 1의 평균과 Gene 2의 평균을 도출하여 아래 이미지와 같이 데이터의 중심이 어디인지를 파악합니다.

그리고 데이터의 상대적인 분포는 변화시키지 않고 그대로 데이터의 중심을 원점으로 옮깁니다.

이제 원점을 지나는 랜덤한 직선을 하나 생성합니다. 그리고 데이터에 fit하도록 직선을 회전시키면 오른쪽 그림의 결과가 나옵니다. 그런데 데이터에 fit하다는 것은 어떤 의미이며, 어떤 방법으로 데이터에 fit한 직선을 구하는지

우리가 방금 랜덤하게 생성한 선에 데이터를 투영합니다. 그리고 이 선과 데이터의 거리를 측정하여 이 거리를 최소화하는 직선을 찾습니다. 즉 PCA에게 데이터에 fit한 직선이라는 것은 데이터들과 거리가 가장 작은 직선을 의미합니다.

이렇게 '데이터와 직선의 거리를 최소화한다는 것'은 원점에서 데이터가 투영된 점들까지의 거리를 최대화하는 선을 찾는다는 것을 의미합니다. 이 부분이 이해가 안될 수도 있는데 오른쪽 이미지처럼 데이터와 fit한 선을 찾았을 때 왼쪽의 이미지보다 원점에서 투영된 점들까지의 거리가 늘어나는 것을 볼 수 있습니다.

지금까지 우리는 데이터에 fit한 하나의 직선을 찾았습니다. 아직 긴가민가 하시겠지만 절 믿고 따라오시면 됩니다.

이제 보다 수학적으로 이해하기 위해 왼쪽 그림처럼 하나의 점만 생각해보겠습니다. 우선 데이터와 원점의 거리는 변하지 않습니다. 그리고 점을 직선에 투영할 때 직각을 이루게 됩니다.

이때 이를 오른쪽 그림처럼 직각삼각형으로 보면 점과 원점 사이의 거리 a는 변하지 않기 때문에 b와 c는 반비례 관계를 가지게 됩니다. 눈치가 빠르신 분이라면 PCA 입장에서는 점과 직선 사이의 거리를 줄이려고 하기 때문에 b를 줄이고 c를 늘리려할 것이라는 걸 알 수 있습니다. 다만 실제 구현에서는 b를 구해서 최소화 하는 것보단 원점에서 투영된 점의 거리인 c를 구해서 이를 최대화하려는 것이 훨씬 쉽습니다.

이를 이제 왼쪽 그림처럼 여러개의 점들에 확장하여 적용해보겠습니다. 우선 데이터들을 직선에 투영합니다. 그 다음 오른쪽 그림처럼 '6개의 점들' 각각과 '원점'과의 거리인 d1부터 d6까지 계산합니다. 그 다음 이들을 제곱하여 음수와 양수가 상쇄되는 것을 방지합니다. 그리고 이 값들을 모두 더하게 되면 그림 위쪽과 같은 식이 나오게 되고, 우리는 이를 거리 제곱의 합 'SS'라고 부릅니다.

즉 다시 말해서 제가 아까 말했던 원점과 데이터가 직선에 투영된 점 사이의 거리를 최대화하는 직선을 찾아야 한다는 것은 결국 SS 값을 최대화하는 직선을 찾아야 한다는 것과 같은 의미입니다.

이러한 과정을 거쳐 최대의 SS를 가지는 직선을 PC1이라고 지정합니다. 이 PC1은 0.25의 기울기를 가집니다. 이때 기울기가 0.25라는 말은 Gene 1이 4번의 단위만큼 증가할 때, Gene 2는 1번의 단위만큼 증가하는 것을 의미합니다. 이것은 대부분의 데이터가 Gene 1을 따라 분산되어 있고, 아주 적은 데이터가 Gene 2을 따라 분산되어 있다는 것을 의미합니다. 아마 이 문장이 잘 이해가 안가실텐데 다음 문단에서 이해가기 쉽게 설명해보겠습니다.

방금 설명을 '칵테일 레시피'라는 것으로 쉽게 비유해보겠습니다. Gene 1을 4 조각, Gene 2를 1조각 그리고 얼음을 넣고 섞었다고 생각해보겠습니다. 그러면 우리가 마실 칵테일에서는 Gene 1의 맛이 더 많이 느껴지겠죠? 이것이 분산되어있는 데이터에서 Gene 1이 더 중요하다는 의미와 일맥상 통하게 됩니다. 수학자들은 이러한 칵테일 레시피를 '선형 결합(Linear Combination)'이라고 부릅니다. 그리고 우리가 지금까지 본 이 PC1을 변수들의 선형 결합이라고 부르기도 하지만 저는 이런 어려운 용어를 쓰지 않겠습니다 :(

이어서 우린 피타고라스의 정리를 이용해서 빨간색 선의 길이를 계산할 수 있습니다. $1^2+4^2 = 17$이므로 결과값은 $\sqrt{17} = 4.12$가 됩니다. 그리고 SVD(특이값 분해)라는 것을 통해 우리가 도출한 가장 적합한 PC1의 단위벡터를 구해줄 것입니다. 이때 SVD 적용을 위해 빨간색 선의 길이는 1이 되어야 하기 때문에 세 변을 4.12로 모두 나누어줍니다. 하지만 레시피에 들어가는 value값만 바뀌었을 뿐 비율은 여전히 동일합니다.

다시 우리의 데이터로 돌아와보겠습니다. 현재 데이터와 방금 우리가 SVD를 통해 구한 PC1에 대한 단위벡터가 있습니다. 이때 이 단위 벡터를 Gene 1의 0.97만큼과 Gene 2의 0.242 만큼으로 구성되어 있는 Eigenvector(고유 벡터)라고 합니다. 그리고 이때 비율에 해당하는 0.97, 0.242는 적재 점수(Loading score)라고 합니다.

그리고 우리가 위에서 구했던 원점과 투영된 점들의 거리 SS를 PC1을 위한 Eigen value라고 합니다. 그리고 이것의 제곱근을 PC1을 위한 Singular value라고 합니다.

여기에 왼쪽 위 그림처럼 PC2라는 것을 하나 더 그려봅시다. PC2는 그냥 원점을 지나면서 PC1과 직교하게끔 그으면 되기 때문에 복잡한 최적화 작업을 거칠 필요가 없습니다.

다시 말해서 PC2의 레시피는 직교하기 때문에 Gene 1의 -1 단위, 그리고 Gene 2의 4 단위가 될 것이며, 그리고 이를 이용해 PC2의 단위 벡터를 구하면 오른쪽과 같습니다. 그리고 우리가 PC1에 데이터를 투영했듯, PC2에도 데이터를 투영합니다.

최종적으로 구한 PC1과 PC2에 데이터를 투영한 결과입니다. 여기까지 읽는데 헷갈리시는 것도 많으실텐데 제가 마지막에 정리해드릴테니 따라와주시길 바랍니다! 이제 이제 마지막 단계를 위해 PC1을 수평으로 회전시킵니다.

수평으로 회전시킨 후, 데이터가 어디있는지 찾기 위해 투영된 점들을 이용합니다. 예를 들어, Sample 1의 경우 위와 같이 연결하여 맵핑되는 것이고 최종 결과는 오른쪽과 같이 됩니다.

이제 마지막으로 한 가지 더 해야할 일이 있습니다. 우리가 이전에 PC의 Eigenvalue로 부르던 SS값을 왼쪽 그림처럼 샘플 사이즈 n -1으로 나눠 각각 PC1, PC2의 분산(Variation)을 구합니다.

예를 들어 PC1의 분산도가 15, PC2의 분산도가 3이라면, 전체 분산도는 18일 경우 이중 PC1이 차지하는 비율은 83%이고, PC2는 17%가 됩니다. 이 분산도가 높을 수록 데이터에서 차지하는 비중이 높다는 것을 의미합니다.

오른쪽은 이를 보기 쉽게 Scree plot이라는 것으로 나타낸 것입니다. 최종적으로 나온 이 결과 4개의 Feature를 가져 4차원으로 표현되던 데이터를 2차원으로 감소시킨 결과입니다.

요약

1) 데이터에 fit한 직선 PC1을 구합니다.

2) 기존에 데이터가 n차원이었다면, 원점을 지나며 기존 PC들과 직교하는 직선 n개를 생성합니다.

3) 각 PC의 분산도를 구하고 Scree plot을 이용하여 비교하기 쉽게 시각화합니다.

4) 내가 만약 줄이려는 차원이 m차원이라면 분산도가 높은 순으로 m개 만큼의 PC만 남기고 나머지는 걷어냅니다.

5) 이제 m개의 PC만 남았기 때문에 m차원이락 할 수 있고 여기에 데이터를 투영하면 끝입니다.

이제 좀더 복잡한 예시를 보겠습니다. 이번엔 Feature가 3개이고, 데이터는 오른쪽과 같이 3차원으로 표현됩니다. 우리는 이 데이터를 2차원으로 감소시킬 것입니다.

이제 데이터의 중심을 원점으로 옮긴 후 데이터가 가장 fit한 즉 SS값을 최대로 만드는 선을 찾아냅니다. 이 점선은 PC1을 위한 선입니다.

그리고 우리가 구한 빨간색 점선의 기울기에 칵테일 레시피를 적용하면 위와 수치가 나오게 됩니다.(설명을 위해 수치를 구하는 과정은 생략하였습니다). 이 경우 Gene 3가 PC1에서 가장 중요하다고 할 수 있습니다.

그리고 빨간색 직선과 직교하면 원점을 통과하는 PC2를 생성합니다. 이때 Gene 1의 수치가 가장 크므로 PC2에서 제일 중요하다고 할 수 있습니다.

또 다시 PC1과 PC2와 직교하면서 원점을 지나는 PC3를 생성합니다.

그리고 PC1, PC2, PC3의 Eigenvalue 즉 SS를 이용하여 각 PC가 차지하는 분산도의 비율을 위와 같이 결정할 수 있습니다.

우리는 3차원에서 2차원으로 감소시키므로 저 PC들 중에서 분산도의 비율이 높은 순으로 PC1, PC2만 남겨놓고 나머지는 다 걷어냅니다.

이제 데이터를 PC1에 한번, PC2에 한번 투영 시킵니다.

투영 시킨 후 보기 편하도록 PC1의 기울기를 0이 되게끔 회전시켜줍니다.

그리고 각 데이터가 PC1과 PC2에 투영했던 두개의 x를 이용하여 데이터를 다시 위치시키면 끝입니다.

[머신러닝 순한맛] 데이터 압축(Data Compression), 차원 감소(Dimensionality Reduction) in 비지도 학습(Unsupervised Learning)

Box형 — Mon, 18 May 2020 14:47:55 +0900

"모두가 비슷한 생각을 한다는 것은 아무도 생각하고 있지 않다는 말이다"

- 알버트 아인슈타인

시작하며

데이터 가공(Data Processing)은 머신러닝에서 가장 중요한 부분중 하나로 이를 어떻게 하느냐에 따라 머신러닝의 성능이 좌지우지되기도 합니다.

이번 포스팅은 연산 시간을 크게 줄이는 방법 중 하나로 데이터 압축(Data Compression) 혹은 차원 감소(Dimensionality Reduction)에 대해서 공부해보겠습니다.

Data Compression

머신러닝에서 데이터를 압축한다는 것은 고차원의 데이터를 저차원의 데이터로 축소하는 방식을 의미하며, 이를 통해 전체 연산량을 줄여서 최종적으로 학습 시간을 단축하는 것입니다. 이것이 왜 필요한 것일까요?

Dimension이 커질수록 알고리즘의 성능은 0에 수렴한다.

이는 바로 '차원의 저주(Curse of dimensionality)'라는 것 때문입니다. 즉 차원이 증가하면 그것을 표현하기 위한 데이터의 양이 기하급수적으로 증가하기 때문에 데이터를 다루기 어려워지고 전체적인 알고리즘의 성능은 크게 감소하게 됩니다. 따라서 우리는 차원을 감소시켜 데이터의 의미를 제대로 표현하는 특징만 추려 학습에 이용하겠다는 것입니다.

차원이 증가할수록 담겨진 데이터가 적어집니다.

위는 데이터의 차원이 증가하면서 같은 공간에 데이터를 얼마나 담을 수 있는지 표현한 자료입니다.

예를 들어, 위에 보이는 그래프는 $$x1, x2$$로 구성된 2차원 데이터를 표현한 것인데, 이 점들은 모여서 선을 이루게 됩니다. 그리고 이 두가지의 데이터는 어떠한 관계를 가지고 있을 것입니다.

여기서 이 2차원의 데이터를 하나의 선에 투영하면, 1차원의 점들로 표현할 수 있습니다 다시 말해서 2차원의 점 $x^{(i)}$을 z라는 선에서 1차원으로 바라봐서 $z^{(i)}$이라는 1차원 데이터로 바라볼 수 있는 것입니다.

결국 이렇게 데이터를 일렬로 표현하기 위해서는 2차원의 데이터를 1차원인 하나의 실수로 나타내야한다는 것이며, 이는 데이터가 반으로 줄어들게 되면서, 필요한 공간 또한 반으로 줄어든다는 것을 의미합니다. 그래서 결국 알고리즘의 성능이 향상되는 것입니다.

이것이 바로 데이터를 압축 또는 차원을 감소하는 기본 원리입니다.

3차원에서 2차원으로 차원 감소

이번에는 3차원의 데이터를 2차원으로 차원 감소시켜보겠습니다. 이 경우 3차원 데이터를 2차원의 사각형에 투영하는 형태를 생각해볼 수 있습니다. 다시 말해서 3차원 데이터로 $x_1, x_2, x_3$ 값을 가지던 vector $x^({i)}$은 $z_1, z_2$ 값을 가지는 vector $z^({i)}$로 다시 표현되는 것입니다.

이러한 차원 감소는 1000차원, 2000차원같이 훨씬 더 높은 차원에서 100차원, 200차원으로 낮추는데도 사용할 수 있으며, 시스템의 성능에 긍정적인 영향을 줄것입니다.

Data Visualization

이번엔 데이터를 이해하기 위한 하나의 방법인 'Data Visulalization'입니다. 예를 들어 위와 같이 각 나라에 대한 데이터가 있습니다. 이 데이터에는 나라별로 50가지의 경제 관련 통계 자료가 들어있습니다. 즉 50차원입니다.

이 나라 별 50가지의 정보를 위와 같이 $z1, z2$로 구성된 2차원의 데이터로 압축할 수 있습니다. 분명 50가지 데이터를 하나하나 살펴봐야 한다면 귀찮겠지만, 이를 2가지의 데이터로 압축하여 볼 수 있다면 나라를 분석하는데 훨씬 더 편할 것입니다.

이를 2차원의 그래프로 표현한 결과입니다. 각 점이 나라를 나타내며, 그래프를 이해하기 위해서는 $z_1, z_2$를 대략적으로 설정하면 어떤 의미일지 파악할 수 있습니다. 이렇게 차원을 줄이고 나니 그래프로 표현이 가능함에 따라 나라별 데이터간의 차이가 한눈에 보이기 때문에 많은 장점들이 있다고 할 수 있습니다.

결론적으로 차원을 줄이는 것은 데이터의 이해를 위한 것이라고 할 수 있습니다.

다음 포스팅에서는 이러한 원리를 기반으로 한 PCA 알고리즘에 대해 공부해보겠습니다.

[머신러닝 순한맛] 비지도 학습(Unsupervised Learning)이란? : 최적화(Optimization)

Box형 — Sun, 17 May 2020 14:08:26 +0900

시작하며

우리가 Supervised Learning에서 다양한 알고리즘을 다루면서 항상 했던 연산들 중 하나가 바로 Cost 최소화 즉 Cost 함수 최적화(optimization)였습니다.

이번 포스팅에서는 K-means 알고리즘의 Cost 함수에 대해 알아보고 이를 어떻게 최적화하는지에 대해 공부해보겠습니다.

이번 포스팅은 아래 포스팅들을 읽고 공부하시면 더욱 효과적입니다.

https://box-world.tistory.com/29

비지도 학습(Unsupervised Learning)이란? : Clustering

시작하며 우리가 그동안 이전 포스팅에서 배웠던 Linear Regression, Logistic Regression, Neural Network, SVM은 모두 지도학습(Supervised Learning) 즉 레이블(Label)이 있는 데이터에 대한 학습이었습니다...

box-world.tistory.com

https://box-world.tistory.com/30

비지도 학습(Unsupervised Learning)이란? : K-means algorithm

시작하며 저번 포스팅에서는 비지도학습(Unsupervised Learning)의 기초 개념을 다뤄보았습니다. 이번 포스팅에서는 Unsupervised Learning의 원리를 알아보고 이것의 대표적인 알고리즘인 'K-means algorithm'에

box-world.tistory.com

K-means Algorithm : Cost 함수

우선 K-means 알고리즘의 Cost 함수를 구성하는 요소에 대해 알아보겠습니다.

K-means 알고리즘의 Cost 함수

우리는 $c^{(i)}$가 i 번째 데이터 $x^{(i)}$가 속한 Cluster 값을 의미하고, $μ_k$ 는 K번쨰 Cluster의 Cluster Centroid를 의미함을 저번 포스팅에서 배웠습니다. 그리고 새롭게 등장한 $μ_c^{(i)}$는 $x^{(i)}$가 속한 Cluster의 Cluster Centroid를 의미합니다.

K-means 알고리즘의 Cost 함수 J는 위와 같습니다. 이는 DIstortion Cost 함수라고도 불립니다. 이 함수의 Cost 값을 최소화(minimize)하기 위해서는 i 번째 데이터 $x^{(i)}$와 이 데이터가 속한 Cluster의 Centroid인 $μ_c^{(i)}$ 사이의 거리를 최소화 시켜야합니다.

K-means Algorithm

이제 방금 배운 Cost 함수를 이용하여 알고리즘을 어떻게 동작시키는지 알아보겠습니다. 우선 Cluster가 k개라고 할때, K개의 Cluster Centroids를 랜덤으로 지정합니다.

여기서 첫번째 단계인 Cluster assignment step에 의하여, 데이터들을 자기와 가까운 Cluster Centroids의 Cluster로 구분시킵니다. 그리고 두번쨰 단계인 Move Centoirds에 의하여, 그렇게 할당된 각 Cluster의 데이터들의 평균값의 위치로 각 Cluster의 Centroid들을 이동시킵니다. 이 두 가지 단계를 반복적으로 실행하여 최적의 Clustering을 하게 됩니다.

Random Initialization

Local Optima

우리는 저번 시간에 알고리즘의 시작 부분에서 랜덤으로 설정되는 Cluster Centroids의 위치에 따라 결과값이 바뀔 수 있음을 배웠습니다. 구체적으로 이렇게 초기에 위치가 잘못 설정되어 정상적인 Clustering이 되지 못한 결과를 Local optima이라고 합니다.

Multiple Random Initialization

이러한 문제를 해결하고자 나온 방법이 바로 Multiple Random Initialization입니다. 말 그대로 여러 번 알고리즘을 수행하여 이중 Cost가 가장 작은 값이 나온 Case를 채택하는 것입니다. 예를 들어 알고리즘으 100번 돌리게 되면, 각기 다른 랜덤한 Cluster Centroid에서 출발한 K-means 알고리즘의 100개의 Cost 값들은 각각 다를 것인데, 우리는 이중 가장 작은 Cost 값을 가지는 Case를 취하는 것입니다.

보통 이렇게 반복하는 횟수는 50 ~ 1000회가 적당하고, 이러한 방법은 Cluster의 갯수가 10개 이하일 때 잘 적용됩니다. 만약 그 이상의 Cluster를 가지는 dataset에 사용할 경우 Local optima가 발생할 가능성이 상대적으로 높아 좋지 않은 결과가 나올 수 있습니다.

Choosing the Number of Clusters

dataset를 구분하는 Cluster의 수는 어떻게 결정해야하는지 알아보겠습니다. 결론은 정답은 없고, 따라서 다 해봐야 한다는 것입니다. 그래서 가장 많이 사용되는 것이 Elbow Method입니다.

간단하게 Cluster 개수가 1개일 때부터 시작하여 계속 K를 늘려가며 각 K에 대한 Cost 값을 비교하는 것입니다. 이때 위와 같은 그래프를 보았을 때, 그 모양이 마치 우리가 팔을 구부린 것과 같으며, 저 중 그래프가 꺾이는 지점 즉 팔꿈치에 해당하는 K = 3를 가장 적절한 갯수로 결정하게 됩니다. 그러나 오른쪽처럼 모든 그래프에 이러한 Elbow가 나타나는 것은 아니므로 유의해야합니다.

[머신러닝 순한맛] 비지도 학습(Unsupervised Learning)이란? : K-means algorithm

Box형 — Sat, 16 May 2020 20:13:23 +0900

시작하며

저번 포스팅에서는 비지도학습(Unsupervised Learning)의 기초 개념을 다뤄보았습니다. 이번 포스팅에서는 Unsupervised Learning의 원리를 알아보고 이것의 대표적인 알고리즘인 'K-means algorithm'에 대해 다뤄보겠습니다.

이번 포스팅은 아래 포스팅을 보시고 공부하시면 더욱 효과적입니다.

box-world.tistory.com/29

비지도 학습(Unsupervised Learning)이란? : Clustering

box-world.tistory.com

Unsupervised Learning의 작동 원리

랜덤으로 Cluster Centroids를 설정합니다.

** Cluster란 하나의 **군집화된 데이터 그룹을 의미합니다. 우선 위와 같은 데이터를 두 개의 Cluster로 나눠보겠습니다.

이때 Cluster의 갯수가 정해지면 동일한 갯수의 Cluster Centroids(중심점)가 동시에 랜덤으로 지정됩니다. 이는 각 Cluster의 일종의 대표 역할을 하게 됩니다. 이렇게 Cluster의 갯수만큼 Centroids를 생성하여 위치시키는 것이 Unsupervised Learning의 첫번째 단계가 됩니다.

Cluster Centroids에 따라 데이터를 구분합니다.

이제 두번째 단계로 위치시킨 두개의 Cluster Centroids을 기준으로 나머지 데이터들을 두 개의 Cluster 중 하나로 구분합니다.

Cluster Centroids를 갱신하고 데이터를 이에 따라 새롭게 구분합니다.

다시 첫번째 돌아와서 Cluster Centroid의 위치를 조정하게 되는데, 이때는 나름의 기준을 가지고 조정하게 됩니다. 그 다음 마찬가지로 나머지 데이터들도 다시 새롭게 구분됩니다.

단계를 반복적으로 거칠수록 데이터가 안정적으로 구분됩니다.

첫번째로 Cluster Centroid를 설정하여 데이터를 나누고, 두번째로 Cluster Centroid를 조정하는 단계를 반복적으로 거치면서 점점 데이터들을 적절하게 구분이 되어갑니다. 이를 통해 학습 모델이 형성되고 적절하게 Cluster된 결과를 얻을 수 있습니다.

K-means Algorithm

K-means Algorithm은 위에서 봤던 내용과 비교했을 때, 기본적인 작동 원리는 동일하며, 어떻게 매 단계마다 Cluster Centroids를 갱신하는지 주목하면 좋습니다. 알고리즘은 두개의 입력값을 가집니다. 하나(K)는 데이터를 몇 개의 Cluster로 구분할 것인가, 다른 하나는 구분할 dataset입니다.

K-means Algorithm은 Unsupervised Learning을 다루므로 데이터의 Label을 존재하지 않습니다. 따라서 dataset은 $(x_1,y_1), (x_2, y_2)... $의 형태가 아닌 $x_1, x_2...$의 형태가 됩니다. 이어서 data가 n개라면 $x_0$를 포함하여 dataset은 $n+1$차원의 vector로 표현 가능합니다.

만약 데이터를 k개의 Cluster로 분류하게 되면, 마찬가지로 주어진 데이터 중 k개의 Clsuter Centroid를 랜덤으로 지정하게 되고 이것들은 $μ_k$로 표기합니다. 작동원리는 다음과 같습니다.

1) Cluster assignment : 초기에 랜덤으로 지정된 k개의 Cluster Centroids를 기준으로 나머지 데이터들이 어느 $μ_k$에 가까운지 체크하여 구분하게 되며 이 결과를 $c(i)$로 표기합니다. 예를 들어 $c(24) = 2$라면 24번째 데이터가 2번째 Cluster로 구분된 것입니다.

2) Move centroid : 이 단계에서는 K개의 Cluster Centroids를 새로운 위치로 갱신하게 됩니다. 구체적으로 $μ_k$는 k번째 Cluster는 k 번째 Cluster에 포함된 데이터의 평균 값을 구하여 그 위치로 이동하게 됩니다. 예를 들어 $x(1), x(5), x(6), x(7)$이 2번째 Cluster에 포함된다면, $c(1), c(5), c(6), c(7)$은 모두 2일 것이며 $μ_2$는 이 이들의 평균값인 $\frac{1}{4}(x(1) + x(5) + x(6) + x(7)$의 위치로 갱신됩니다.

알고리즘은 단계를 반복하면서, 반복해도 결과가 바뀌지 않거나(수렴), 사용자가 지정한 roop를 수행하게 되면 종료됩니다.

육안으로 보기에 분리가 쉽게 되는 경우도 있지만, 오른쪽 그래프처럼 불규칙하여 쉽게 분리할 수 없을거 같이 보이는 그래프도 Clustering이 가능합니다. 오른쪽 그래프는 T-shirt의 Size를 small, medium, large 3개의 cluster로 구분한 결과입니다.

초기값 위치에 다라 달라지는 결과값

이제 K-means Algorithm의 특징과 단점에 대해 알아보겠습니다. 우선 첫 단계에서 Cluster Centroids를 랜덤으로 설정하게 되는데 이 초기 랜덤값인 Cluster Centroids에 따라 결과값이 달라질 수 있습니다.

또한 군집의 밀도가 서로 다를 때 작동하지 않을 수 있습니다.

Box World

GPT-5가 바꾸는 LLM의 법칙: 단일 모델 시대의 종말과 새로운 전략

소개

본문

1. 거대 모델의 시대는 끝났다: 팀 스포츠로의 전환

2. GPT-5의 심장, '실시간 라우터'의 작동 방식

3. 열린 생태계와 닫힌 생태계의 공존: OpenAI의 이중 전략

4. 개발자의 새로운 현실: '바이브 코딩'과 책임의 균형

결론: 당신의 다음 행동 계획

핵심 내용 퀴즈

이제 트랜스포머의 시대는 끝날까? Google Titans 논문 리뷰

무언가가 충분히 중요하다면 확률이 당신에게 유리하지 않더라도 시작하라

- 일론 머스크 -

Introduction:

Motivation & Contribution:

Method:

실험 결과:

리뷰:

[떠먹여주는 논문] CVPR 2024 Best Paper : Generative Image Dynamics

틀린 질문에서 올바른 답이 나올 수 없다

- 최민식, 이상한 나라의 수학자 -

스펙트럴 볼륨(Spectral Volume): 움직임을 주파수로 표현하다

Frequency-Coordinated Diffusion Model 을 이용한 스펙트럴 볼륨 예측

(adsbygoogle = window.adsbygoogle || []).push({});

Image-Based Rendering

Quantitative Results

Qualitative Results

[ 떠먹여주는 논문 ] Best Paper of NeurIPS 2024, Visual Autoregressive Modeling: Scalable ImageGeneration via Next-Scale Prediction

무언가가 충분히 중요하다면 확률이 당신에게 유리하지 않더라도 시작하라

- 일론 머스크-

이미지 생성 모델의 두 가지 축: Diffusion과 Autoregressive

기존 Autoregressive 모델의 문제점

VAR: Next-Scale Prediction 기반의 새로운 패러다임

(adsbygoogle = window.adsbygoogle || []).push({});

VAR의 작동 방식

VAR의 장점

VAR의 학습 및 추론 과정

실험 결과 및 Scaling Law

(adsbygoogle = window.adsbygoogle || []).push({});

한계점 및 개선 방향

결론

데이터의 힘: 학습 이미지가 많아질수록 Accuracy와 F-1 Score가 개선되는 이유

정확도(Accuracy)란?

F-1 Score(F-1 점수)란?

학습 이미지의 양이 성능 개선에 미치는 영향

실제 사례: 의료 이미지 분석

[문과도 이해하는 선형대수 for 딥러닝] 4. 행렬 분해 (Matrix factorization)

1. 역행렬에 대한 리뷰 (Review of inverse matrix)

2. $A =LU$

3. 소거에 대한 연산량 (Complexity of Elimination)

[문과도 이해하는 선형대수 for 딥러닝] 3. 행렬곱, 역행렬, 가우스-조던 소거법 (Multiplication and Inverse Matrices)

1. Matrix multiplication

1) $C_ij=\sum(A_ik*B_kj)$

2) 행렬 $\times$ 벡터로 바라보기

3) $A$의 한 row $\times$ $B$ = $C$의 한 row

4) $A$의 한 Column과 $B$의 한 row의 곱셈으로 바라보기

2. 역행렬 (Inverse matrix)

3. 가우스-조던 소거법

[문과도 이해하는 선형대수 for 딥러닝] 2. 행렬 소거 (Elimination with Matrices)

1. 소거 (Elimination)

2. 역 대입 (Back subtitution)

3. Matrix multiplication

4. 소거 행렬 (Elimination matrix) 구하기

[문과도 이해하는 선형대수 for 딥러닝] 1. 선형 방정식 (The geometry of linear equations)

1. 선형 방정식 (Linear equation) 이란?

2. Row picture

3. Column picture (중요)

4. Non-singular ( invertible ) matrix

[ Flutter ] 앱 시작할때 나오는 로딩 화면 구현하기! (Splash Screen)

화면 준비하기

initState에 다음 화면으로 넘어가는 코드를 추가

(응용) 특정 조건을 만족시키지 않으면 Navigate 막고 앱 종료하기

[ Flutter ] PageView 자동 스크롤 기능 넣기!

PageView 준비하기

자동 스크롤 기능 넣기

[머신러닝 순한맛] LSTM의 모든 것

RNN으로 긴 시퀀스 다루기

LSTM(Long, Short-Term Memory)

핍홉 연결

GRU