꺼내먹는지식 준

groupby, size, reset_index 조합

알 수 없는 사용자 — Fri, 27 Oct 2023 11:47:44 +0900

groupby 메소드 자체는 그룹을 생성하기만 하고, 실제로 어떤 연산을 수행하지는 않는다.

그래서 groupby만 단독으로 사용하면 그 자체로는 큰 의미가 없다.

일반적으로 groupby 뒤에 다른 연산 메소드(예: sum, mean, size, max, min 등)를 붙여서 그룹별로 어떤 계산을 할지 지정한다.

예를 들어, df.groupby(['date', 'positive']).size().

data_df.groupby(['date', 'positive', 'free']).size()

size() 를 붙여서 지정한 각 그룹에 대한 개수를 얻어올 수 있다. free 라는 column 이 추가 되자 더 세분화된 것을 알 수 있다.

data_df.groupby(['date', 'positive']).size().reset_index()

다음과 같이 index 가 새로운 column 이 되고, index 는 초기화 된다. 기존에 size() 없이 reset_index() 를 한다면, 앞단의 index 가 새로운 column 이 되고 index가 초기화 된다. 보통 drop = True 를 파라미터로 주어 초기화 되도록 많이 사용한다.

data_df.groupby(['date', 'positive']).size().reset_index(name='count')

다음과 같이 name 을 설정하는 경우가 많다.

간단하게 자주 사용하는 groupby size count 에 관한 용례를 정리해봤다.

Vue 기본기

알 수 없는 사용자 — Tue, 4 Apr 2023 20:22:19 +0900

Vue 찍먹

NodeJS 를 설치하는 이유는 Terminal CLI 에서 npm 을 이용하기 위함이다.

npm은 각종 웹 개발 라이브러리 설치 도우미이다.

App.vue 파일에 메인 화면을 작성하면 된다.

App.vue 파일을 html 파일로 컴파일해주기에 가능한 것이다.

컴파일은 main.js가 한다.

node modules 프로젝트를 위한 모든 라이브러리

src 실제로 소스 코드 짜는 공간

public html, 기타 파일 보관

package.json 라이브러리 버전 기록

DOM 이란?

Document Object Model

즉, 웹 문서(페이지)를 객체화한 개념

문서 객체란?

<html>이나 <body> 같은 html문서의 태그들을 JavaScript가 이용할 수 있는 객체(object)로 만든 것

좀 더 쉽게 설명하자면

각 언어마다 처리하는 방법이나 규칙, 즉 문법이 있다. JavaScript와 HTML은 서로 다른 언어이므로 각각 다른 '문법'을 사용한다. 이런 차이 때문에 JavaScript는 HTML을 직접적으로 이해하거나 변경할 수 없고, DOM (문서 객체 모델)은 이런 문제를 해결하는 역할을 한다. DOM은 웹 페이지의 HTML을 JavaScript에서 사용할 수 있도록 "객체"라는 형태로 변환합니다.

객체는 JavaScript의 주요 데이터 타입 중 하나로, 속성과 메소드를 가질 수 있다. 속성은 객체의 특성을 나타내고, 메소드는 객체가 수행할 수 있는 동작을 나타낸다.

예를 들어, HTML의 <p> 태그는 DOM을 통해 Paragraph 객체로 변환되고, 이 객체는 텍스트 내용을 변경하는 메소드를 가질 수 있다.

JavaScript는 이 메소드를 사용해 웹 페이지의 텍스트를 동적으로 변경할 수 있다. 이처럼 DOM은 JavaScript가 HTML을 '이해'하고 조작할 수 있게 만드는 통역사 같은 역할을 한다. 즉, '객체'라는 형태로 변환된 HTML 태그 (문서 객체)는 JavaScript의 문법으로 조작이 가능하게 된다. JavaScript는 이 문서 객체를 통해 웹 페이지에 동적인 기능을 추가하거나 사용자의 상호작용에 반응하는 등의 작업을 수행할 수 있다.

DOM의 형태

DOM은 tree 구조의 형태를 가지고 있다. DOM 에 포함 된 <p>를 더 자세히 살펴보자. <p> 태그도 트리형태의 구조를 형성하고 있다. DOM 객체에 접근하고 또 키워드로 필요한 노드에 접근하여 목표한 작업을 할 수 있다.

JavaScript로 문서객체를 생성한다는 것은 어떤 의미인가?

문서 객체는 두 가지 방법으로 생성된다.

웹 브라우저가 HTML 페이지에 적혀 있는 태그를 읽으면 생성 된다.

이런 과정을 정적으로 문서 객체를 생성한다고 말한다.

단순히 적혀져 있는 그대로 문서객체가 생성 되는 것을 표현한다.

Object Model이 필요한 이유

스크립트로 사람이 document(화면 요소)를 조작하기 위해서 웹 문서가 스크립트의 객체 형식으로 표현되어야 했다.

Javascript 뿐만 아니라 python이나 다른 스크립트 언어로도 DOM을 조작할 수 있다고 한다.

Web API 의 사용 예시를 보면 아래와 같다.

DOM의 노드들 중에서 특정 노드를 선택하고, 선택한 노드의 색을 변경하거나, viewport의 높이를 찾는다거나, DOM을 조작하는 데 사용되는 스크립트 메서드들이 저 공식에 부합하는 web API 라고 불리게 된다.

데이터 바인딩

JS 데이터를 HTML에 꽂아넣는 것이 가능해진다.

자바스크립트가 변수에 저장을 한다면, vue는 데이터 보관 통이 존재한다.

ㄴ

data() 안에 모든 데이터를 포함해야한다.

data() 안에 object 형식으로 데이터를 저장하고, html 안에 JS 데이터를 꽂아 넣었다.

데이터바인딩 왜 할까?

HTML에 하드코딩으로 그냥 값을 꽂아 넣으면 수정이 어렵다.

그러나 JS 데이터로 꽂아 넣으면 가변적일 때 쉽게 변경할 수 있기 때문이다.

Vue의 실시간 자동 렌더링 기능을 사용하려면 데이터바인딩을 해야만 한다.

Vue는 data()를 변경하면 데이터와 관련된 HTML 에도 실시간으로 반영된다.

이에 따라 웹앱 같은 사이트를 만들 수 있다. (쇼핑몰에서 가격 필터를 사용하거나 할 때 HTML 이 자동으로 변경하게 하기 위하여)

당연한 말이지만, 실시간 변할 필요가 없는 데이터들은 데이터바인딩을 할 필요가 없다. 그냥 하드코딩하면 된다.

java script 의 array

var 어레이 = [10, 20, 30];

를 vue 에서

어레이 : [10,20,30], 으로 작성 가능하다.

데이터 바인딩은 아래와 같이 표현식도 사용 가능하다.

<h1>{{ message.split('').reverse().join('') }}</h1>

이중 중괄호를 사용한 데이터 바인딩은 텍스트 삽입에만 사용된다.

속성을 동적 값에 바인딩 하려면 v-bind 디렉티브를 사용한다. 이를 HTML 속성 안에서 데이터 바인딩이라고 이해해도 된다.

워낙 자주 사용 되므로 v-bind: 를 : 로 축약해서 사용한다.

반복문

HTML 의 반복적 요소를 vue 의 반복문으로 축약해서 작성 가능하다.

우선 HTML <template> 즉, 전반적인 template 을 만들고 CSS <style> template에 style을 더하고, 두가지로 해결 안되는 기능 및 추가적 요소들을 <script > 를 통해 해결한다는 것을 기억하자.

ChatGPT 의 응답에 따르면 아래와 같이 좀 더 직관적으로 정리해준다. 즉, 상호보완적 관계라고 이해하면 된다.

다음을 반복문으로 좀 더 간단하게 작성해보자.

간단하게 완료 되었다.

    메뉴들: ['Home', 'Shop', 'About'],

for 문 안에서는 어차피 string 이 들어갈 수 없으므로 따로 데이터 바인딩이 필요가 없으나, i 는 데이터 바인딩이 없으면 char 형인지 변수인지 알 수 없으므로 데이터 바인딩이 들어간다.

key의 용도는 반복문을 돌린 요소를 컴퓨터가 구분하기 위해 쓴다.

이는 파이썬의 enumerate 와 같은 용도이다.

    <a v-for="(a,i) in 메뉴들" :key="i"> {{i}} </a>

HTML 속성 안에서 데이터 바인딩은 : 이다.

Event Handler

  <button>허위매물신고</button> <span>신고수 : 0</span>

다음과 같은 버튼이 있다고 가정해보자.

※ span

기존에 javascript는 button 을 사용하기 위해 아래와 같은 형태로 사용했다.

  <button onclick="">허위매물신고</button> <span>신고수 : 0</span>

그러나 Vue 방식은 아래와 같다.

  <button v-on:click="">허위매물신고</button> <span>신고수 : 0</span>

v-on 디렉티브는 이벤트 리스너이다.

자주 사용되기 때문에 @로 단축해서 사용한다.

즉, v-on:click 은 @click 으로 축약해서 쓸 수 있다.

버튼을 누르면 오른쪽 숫자를 증가하도록 설정해보자.

기존 자바스크립트는 버튼 누르면 숫자 찾아서 +1, 그리고 HTML 에 반영하는 수순이었다.

하지만 Vue는 마치 processing 처럼 실시간 재랜더링이 되기 때문에 신고수만 더해주면 자동으로 html 이 바뀌도록 반영 된다. (Vue의 가장 강력한 특징)

<button v-on:click= "신고수++">허위매물신고</button> <span>신고수 : {{신고수}} </span>

@mouseover 
@drag 
@... 
등등 다양한 이벤트핸들러 기능이 많다.

함수를 쓰는 이유는 긴 코드를 짧고 편리하게 재사용하기 위해서이다.

Vue 에서도 함수가 존재한다.

간단하게 methods 안에 선언만 해주면 된다.

유의 사항은 data 의 변수를 참고하는 경우 꼭 this.데이터명 을 선언해줘야 한다.

    <button v-on:click= "increase">허위매물신고</button> <span>신고수 : {{신고수}} </span>

그리고 @click 에는 따로 던져주고 싶은 매개변수가 없을 때 "increase" 특별히 뒤에 () 를 붙이지 않는다는 점, 함수지만 동일하게 " " 를 사용한다는 점 유의하자. 함수가 아니어도 : 뒤에 따라오는 데이터 바인딩은 " " 이다.

당연히 매개변수를 던질 수도 있다.

img 삽입

    <img src = "./assets/room0.jpg">

보통 이미지는 assets 폴더에 저장한다.

유의사항으로 시작은 무조건 ./ 으로 시작한다.

화면 내에 UI 를 제작할 때 다음만 기억하면 된다.

1. UI는 디자인이 선수적으로 되어 있어야 하고 특정 조건에 따라 나타난다.

2. UI 상태가 저장되어 있어야 한다.

3. 데이터에 따라 UI 어떻게 보일지 작성

modal_status 가 true 일 때만 팝업 혹은 UI를 보여주자.

버튼하나를 추가하여 팝업 UI를 닫을 수 있게 했는데, button 도 class 를 지정해서 위치를 바꿔줄 수 있다. 하지만 이게 직관적인 방법인지는 모르겠다.

데이터를 받아서 반영

데이터를 보내고자 하는 java script 파일에서 데이터를 export 한다.

그리고 App.vue 파일의 <script> 안에서 import를 수행한다.

import 시 export 변수명과 동일하지 않아도 괜찮다.

만약 여러개를 export 하는 것도 가능하고,

export {apple,apple2}

함수를 export 하는 것도 가능하다.

받을 때는

import {apple} ~ 

import {apple, apple2} ~

로 받고 싶은 것을 골라 받을 수 있으나, 중괄호를 사용해야한다.

폼 바인딩

input 에 들어가는 초기값을 " "로 설정

input에 들어가는 초기값을 데이터바인딩 된 text 로 설정

<@input = "onInput">

input이 들어오면 onInput 함수 호출

결론적으로 <v-model> 은 함수 호출 없이 input 이 바로 text 에 들어가도록 설정 된 기능

심지어 : , 즉 이벤트 핸들러도 사용할 필요 없다.

조건부 렌더링

v-if 는 ture일 때 렌더링 되었다면, v-else 는 false일 때 렌더링 된다.

<h1 v-if="awesome">Vue는 굉장해! 엄청나!</h1>
<h1 v-else>오 안돼  </h1>

아래와 같이 v-else 만으로도 v-if 에서 tracking 하는 상태를 반영하는 듯 하다.

함수 (methods)

특별한 유의사항

export default {
  data() {
    return {
      awesome: true
    }
  },
  methods: {
    toggle() {
      this.awesome = false
    }
  }
}

data() 에서는 데이터 값 배정을 : 로 했지만, method에서는 = 로 한다.

해당 이유는 아래와 같다.

Vue 에서 data binding 과 method parameters 의 syntax 가 다르게 이용된다.

ChatGPT 는 다음과 같이 대답한다.

<form>

The <form> element is used to group and organize multiple input elements into a form that can be submitted to a server for processing. It defines the boundaries of the form and specifies the destination URL where the data should be sent when the form is submitted. A form can contain various types of input elements such as text fields, checkboxes, radio buttons, dropdown menus, and buttons.

<form> 은 원래 아래와 같이 사용 되며, action 에 적힌 URL 로 정보를 보낸다고 한다.

<form action="/login" method="post">
  <label for="username">Username:</label>
  <input type="text" id="username" name="username"><br><br>
  <label for="password">Password:</label>
  <input type="password" id="password" name="password"><br><br>
  <input type="submit" value="Login">
</form>

그러나 prevent 를 이용하면 URL 을 보내는 defult 기능으로 사용되지 않고, 대신 custom action 을 할 수 있다.

여기서는 그 action 이 "addTodo" 이다.

<form> 안에 input, button 이 포함된다.

input이 newTodo 데이터에 바인딩 되고 button 을 누르면 addTodo 가 호출된다.

 <form @submit.prevent="addTodo">
    <input v-model="newTodo">
    <button>할 일 추가</button>
  </form>

button이 form @submit.prevent 를 trigger 한다는 어떠한 clue 도 적혀있지 않아 헷갈렸는데 이는 <form> element 안에 있기 때문에 trigger 로 동작한다.

      this.todos = this.todos.filter((t) => t !== todo)

todos의 elemet 중 todo 와 다른 것들만 모아 todos 에 재배치하는 함수

즉, todo 만 제거

동적 바인딩

조건이 true경우 클래스이름이 바인딩 되고 false경우 바인딩된 클래스이름이 제거 된다.

:class="{ '클래스이름' : '조건' }"

보통 class 에 거는건 CSS styling 을 위해서인데, 조건이 false 면 style이 반영되지 않는다.

Computed

사실상 methods로 모두 대체할 수 있지만, 보통 템플릿의 데이터 표현을 더 직관적이고 간결하게 도와주는 속성이다.

일단 계산이나 데이터 처리가 반복 될 경우를 위해 cache 하고 만약 데이터 속성에 변화가 있으면 이를 감지하고 자동으로 다시 연산하여 cache 한다. 또한 가독성도 높게 해준다. 가독성은 methods 와 computed 로 logic 이 seperate 되어있다보니 getFullname 이런 식으로 안하고 그냥 Fullname 이런 식으로 해도 된다.

데이터 속성의 변화를 자동 감지하고 연산하다보니 HTTP 통신같이 컴퓨팅 리소스가 많이 필요한 로직은 정의하지 않는다.

  computed: {
    filteredTodos(){
       return this.hideCompleted
         ? this.todos.filter((t)=> !t.done)
    		: this.todos
    }
  },

hideCompleted 가 True 면 !t.done filter, false 면 todos return

생명주기 훅 ref

이해한 바에 따르면 Vue는 DOM 을 최대한 직접 건드리지 않고 반응형, 선언적 렌더링으로 처리하고자 한다. 하지만 그 외의 경우 DOM을 수동으로 접근하여 처리하는 경우가 있다. 이 때, $ref 를 이용한다.

<script>
export default {
  mounted(){
  this.$refs.p.textContent = "마운트"
  }
}
</script>

<template>
  <p ref="p">안녕</p>
</template>

ref 는 this. + $refs 로 접근한다. 또한 mounted() 선언을 통해 component가 렌더링 된 후에 접근이 가능해진다. mounted 는 life cycle hook 을 명시할 때 사용한다. 보통 fetching data from API, setting up event listeners, initializing third party libraries 에 사용한다.

정확한 용례는 component 가 처음 rended 되는 순간에 딱 한번 call 된다.

Java script의 DOM node에 접근 가능한 property list 는 다음과 같다.

textContent
innerHTML
setAttribute()
getAttribute()
removeAttribute()
style
className
classList

Dom Node

Watcher

지금까지 공부한 Vue 의 강점은 reactivity system 이다. 이로 인해 data property 에 변화가 있으면 감지하여 업데이트한다.

그럼에도 불구하고 watcher 를 쓰는 이유는 뭘까?

watcher란?

mechanism for reacting to changes in a specific data property or expression

일단 data가 변경될 때 마다 추적하는 건 너무 큰 computation resource 가 사용된다. 가령, watcher를 사용하면 복잡한 시스템이면 특정 dependency가 변경되었을 때만 trigger 되도록 할 수 있다.

또한 비동기 처리가 가능하다고 한다. 또한 property가 변할 때 특정 action 이나 side effect가 있도록 하기에 watcher 는 잘 설계 된 logic 이다. 또한 만약 property 들이 서로 의존적이며 업데이트가 같이 되야 한다면, watcher 를 사용하는 것이 답이다.

Watcher의 사용법을 살펴보자.

먼저 watch 하고 싶은 데이터 propety 를 결정한다.

 data() {
    return {
      todoId: 1,
      todoData: null
    }

todoID 라고 할 때, Watcher 는 다음의 두가지 방법으로 비동기적으로 todoID 의 변화를 추적할 수 있다.

watch: {
    todoId() {
    
    
watch: { 
	todoID: function(){

Data property 의 todoID 와 watcher의 함수 todoID() 는 당연히 다르다.

side effect

wacher 를 통해 데이터 변화가 추적 된 순간 하고 싶은 특정 action 등 ex) 날짜가 1일이 되면 월의 count를 ++ 하라.

개발자들은 watcher 에는 다음과 같이 watcher function 만 놓고 side effect 는 따로 methods 에 빼놓곤 한다. 이는 두번째 용례였던 todoID: function() 과 같이 callback function 으로 사용하면 접근이 불가능하나 side effect 만 따로 method 에 빼놓게 되면 this. 로 접근이 가능하다.

예시는 다음과 같다.

<script>
export default {
  data() {
    return {
      todoId: 1,
      todoData: null
    }
  },
  methods: {
  },
  mounted() {
    this.fetchData()
  },
  watch: {
    todoId: async function() {
      this.todoData = null
      const res = await fetch(
        `https://jsonplaceholder.typicode.com/todos/${this.todoId}`
      )
      this.todoData = await res.json()
    }
  }
  
  
}
</script>

<template>
  <p>할 일 id: {{ todoId }}</p>
  <button @click="todoId++">다음 할 일 가져오기</button>
  <p v-if="!todoData">로딩...</p>
  <pre v-else>{{ todoData }}</pre>
</template>

watcher 안에 call back 함수를 선언하다보니 mounted() 에서 call 하고자 했던 fetchData 가 전혀 call 되지 못했다.

이로 인해, 처음 코드가 돌아갈때는 this.fetchData() 가 call 되지 못해 error 가 발생한다. 그러나 그 다음부터 "다음 할 일 가져오기" 버튼을 눌렀을 때는 아무일도 없었던 것 처럼 동작한다.

위 코드는 아래와 같이 methods 에 함수를 나눠 적음으로써 유연하게 코드를 짤 수 있다.

<script>
export default {
  data() {
    return {
      todoId: 1,
      todoData: null
    }
  },
  methods: {
    async fetchData() {
      this.todoData = null
      const res = await fetch(
        `https://jsonplaceholder.typicode.com/todos/${this.todoId}`
      )
      this.todoData = await res.json()
    }
  },
  mounted() {
    this.fetchData()
  },
  watch: {
    todoId() {
      this.fetchData()
    }
  }
}
</script>

<template>
  <p>할 일 id: {{ todoId }}</p>
  <button @click="todoId++">다음 할 일 가져오기</button>
  <p v-if="!todoData">로딩...</p>
  <pre v-else>{{ todoData }}</pre>
</template>

Component

component를 불러와서 작업할 수 있다.

import ChildComp from './ChildComp.vue'

export default {
  components: {
    ChildComp
  }
}
</script>

<template>
  <ChildComp />
</template>

import 는 <script> 안에서 이뤄져야 하고, component 를 사용하기 위해서는 <Componet name /> 을 언급해줘야 한다.

Component 란?

vue file 에 작성 된 block 들은 모두 component 이다. 코드의 재활용이 용이한 형태로 되어있고 자식 component를 가져오는 이유이기도 하다. 이러한 의미에서 vue file 자체를 component 라고 할 수도 있다.

Vue 는 parent 가 child component 의 consumer 이다. 즉, child component 를 import 한다. 보통 언어들에서 parent 가 자식 class 에게 inheritnace 를 제공한다는 점에서 terminology가 특이하다.

Props

자식 컴포넌트는 props 를 통해 부모로부터 데이터를 받을 수 있다. 우선 허용할 props 를 선언해야 한다.

일단 선언되면 msg prop이 this 에 노출 되고, 자식 컴포넌트에서 템플릿 사용이 가능해진다.

부모는 속성을 사용하는 것처럼 자식에게 prop을 전달할 수 있고, 동적 값을 전달하기 위해 v-bind 문법을 사용할 수도 있다.

여기서는 또 자식 컴포넌트가 부모로부터 데이터를 pass down 받는다는 점에서 충분히 햇갈린다. 용례를 아래서 살펴보자 .

(Child 도 Parent Component 를 사용할 수 있는 방법이 있긴한데 지향되는 것으로 보인다.)

ParentCompoent.vue

<template>
  <div>
    <h2>{{ title }}</h2>
    <ChildComponent v-for="item in items" :key="item.id" :item="item" />
  </div>
</template>

<script>
import ChildComponent from './ChildComponent.vue';

export default {
  components: {
    ChildComponent
  },
  data() {
    return {
      title: 'List of Items',
      items: [
        { id: 1, name: 'Item 1' },
        { id: 2, name: 'Item 2' },
        { id: 3, name: 'Item 3' }
      ]
    };
  }
}
</script>

ChildCompoent.vue

<template>
  <div>{{ item.name }}</div>
</template>

<script>
export default {
  props: ['item']
}
</script>

One by One 으로 살펴보자.

ChildComponent tag 를 갖는 Parent Component, message 를 ChildComponet에 pass down 한다.

Parent Component 에서는 Child Component 를 사용 가능하다. Child에게 보낼 message 를 설정했다.

Child Component 는 props 선언을 통해 Parent Component로 부터 data 를 받는다.

받은 데이터를 사용한다.

Emits

child에서 이벤트와 데이터를 parent 로 발송할 수 있다.

Child

export default {
  // emit할 이벤트 선언
  emits: ['response'],
  created() {
    // 인자와 함께 emit
    this.$emit('response', '자식 컴포넌트로부터  를 받았어요!')
  }
}

emits 은 button 처럼 단순하고 emit 할 event 가 1개밖에 해당될 수 없는 경우를 제외하면 미리 선언해주어야 한다.

emits: ['response']

button 같은 경우는

<button @click="$emit('my-event', {data: 'some data'})">Click me</button>

Parent에서도 이렇게 심플하게 사용가능하다.

Parent

<ChildComp @response="(msg) => childMsg = msg" />

created()

created() 도 lifecycle hook 의 일종이다.

component instance 가 생성 되었지만 아직 mount 되지 않았을 때 call 된다.

다른 components 들은 접근 가능하지만, DOM elements component 는 아직 mount 되기 전이라 접근 불가하다.

이에 대한 chatGPT 의 답변은 다음과 같다.

Slot

Parent component 는 이미 child component 를 직접 access 할 수 있기 때문에 slot 기능이 필요 없지만, 반대로 child 는 필요한 순간이 꽤 된다. Parent의 compoent를 동적으로 child component에 render 할 수 있다.

예를 들어, parent component는 서로 스타일이 다른 여러개의 child component를 가질 수 있다. 각각의 child component가 동일한 text content를 보여야 한다면, slot 을 사용하여 child component가 unique style을 유지하도록 할 수 있다.

예시는 아래와 같다.

Parent

<script>
import ChildComp from './ChildComp.vue'

export default {
  components: {
    ChildComp
  },
  data() {
    return {
      msg: 'Vue는 개발자에게 정말 유용하죠!  '
    }
  }
}
</script>

<template>
  <ChildComp>부모로부터: {{ msg }}</ChildComp>
</template>

Child

<slot>대체: 부모로부터 컨텐츠를 못 받았어요!  </slot>

이렇게 기본기는 마무리한다.

Docker ce 설치 on windows

알 수 없는 사용자 — Fri, 31 Mar 2023 21:38:34 +0900

다음의 과정을 걸친다.

WSL 설치, ubuntu 설치, Docker, Cuda toolkit 설치

WSL, ubuntu, Docker 관련 내용은 WSL, Docker 글을 살펴보자.

WSL 설치

https://www.lainyzine.com/ko/article/how-to-install-wsl2-and-use-linux-on-windows-10/

[Windows 10] WSL2 설치 및 사용법

Microsoft에서는 2020년 5월 리눅스를 윈도우와 통합해서 사용할 수 있는 WSL2를 발표했습니다. 이 글에서는 WSL2를 설치하고 사용하는 방법을 소개합니다

www.lainyzine.com

위 글이 워낙 내용을 잘 정리하고 있어, 실전 설치 내용만 간략하게 아래 정리한다.

WSL 설치를 위한 사전 진행 사항

Windows 업데이트 (안전빵)

Powershell 관리자 모드로 실행

DISM으로 WSL 관련 기능 활성화

DISM(배포 이미지 서비스 및 관리) 명령어로 Microsoft-Windows-Subsystem-Linux 기능을 활성화합니다.

$ dism.exe /online /enable-feature /featurename:Microsoft-Windows-Subsystem-Linux /all /norestart
버전: 10.0.19041.844

이미지 버전: 10.0.19043.928
기능을 사용하도록 설정하는 중
[==========================100.0%==========================]

DISM명령어로 VirtualMachinePlatform 기능을 활성화

$ dism.exe /online /enable-feature /featurename:VirtualMachinePlatform /all /norestart
배포 이미지 서비스 및 관리 도구

이미지 버전: 10.0.19043.928

기능을 사용하도록 설정하는 중
[==========================100.0%==========================]
작업을 완료했습니다.

재부팅 진행 (안해도 문제 없긴 했지만 안전빵)

WSL 설치

WSL2 Linux 커널 업데이트

https://learn.microsoft.com/ko-kr/windows/wsl/install#step-4---download-the-linux-kernel-update-package

WSL 설치

wsl --install 명령을 사용하여 Linux용 Windows 하위 시스템을 설치합니다. Ubuntu, Debian, SUSE, Kali, Fedora, Pengwin, Alpine 등 원하는 Linux 배포판에서 실행되는 Windows 머신에서 Bash 터미널을 사용할 수 있습니

learn.microsoft.com

wsl --install

한 줄이면 설치가 끝나나, 설치 외 부가 정보를 얻고 싶으면 위 링크를 살펴보자.

버전이 1인지 2인지 확인하고 싶으면, powershell 을 닫았다가 다시 관리자 모드로 킨 후 wsl -l -v 를 쳐서 확인해보자.

ubuntu 는 마이크로 소프트 스토어에서 설치

ubuntu가 켜지면 사용자 이름과 패스워드를 설정한다.

powershell을 다시 실행 한 후 아래와 같이 나오는지 확인해보자.

$ wsl -l -v
  NAME      STATE           VERSION
* Ubuntu    Running         2

Docker 를 설치해보자.

https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/install-guide.html#docker

Installation Guide — NVIDIA Cloud Native Technologies documentation

On RHEL 7, install the nvidia-container-toolkit package (and dependencies) after updating the package listing: Restart the Docker daemon to complete the installation after setting the default runtime: Note Depending on how your RHEL 7 system is configured

docs.nvidia.com

위 글에 대부분의 내용이 있지만, 실수하기 좋은 부분을 아래에 작성한다.

curl https://get.docker.com | sh \
  && sudo systemctl --now enable docker

systemctl 에서 오류가 나는 경우가 많다.

여러 해결법이 많이 제시되지만, 성공적이었던 방법은 아래와 같다.

(출처: https://github.com/microsoft/WSL/issues/8883 답글이 워낙 많아 아래에서 제시하는 해결법을 찾기 어렵다.)

WSL에 로그인

wsl

/etc폴더 wsl.conf 파일 생성

sudo nano /etc/wsl.conf

파일 안에 다음의 내용을 추가해준다.

[boot]
systemd=true

cntrl + s로 저장하고 cntrl + x 로 파일 종료

shell 종료

exit

wsl shutdown

wsl --shutdown

wsl 재시작

wsl

package repository 를 setup 하고 GPG key 를 넣어줘야한다. 마찬가지로 여러 방법이 있지만 아래 코드를 입력하는 것이 가장 수월하다.

distribution=$(. /etc/os-release;echo $ID$VERSION_ID) \
      && curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg \
      && curl -s -L https://nvidia.github.io/libnvidia-container/$distribution/libnvidia-container.list | \
            sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' | \
            sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list

Nvidia container toolkit 설치

sudo apt-get update

sudo apt-get install -y nvidia-container-toolkit

sudo nvidia-ctk runtime configure --runtime=docker

sudo systemctl restart docker

마지막으로 글에서는 나와있지 않지만 유의해야 하는 부분이있다.

아래 명령어를 보면 cuda 의 버전이 11.6.2, ubuntu 의 버전이 20.04 이다.

sudo docker run --rm --runtime=nvidia --gpus all nvidia/cuda:11.6.2-base-ubuntu20.04 nvidia-smi

아무생각 없이 복사하다보니 버전을 안맞춰서 한참 고민했다. 버전을 꼭 맞춰주자.

cuda 버전 확인은 nvidia-smi 로 확인할 수 있고, 우분투의 버전은 lsb_release -a 로 확인할 수 있다.

혹시 gpu 드라이버가 설치되어 있지 않다면 설치가 선행이다.

만약 root user 가 아니라 docker 사용이 거부된다면 아래 내용을 참고하자.

https://stackoverflow.com/questions/48957195/how-to-fix-docker-got-permission-denied-issue

How to fix docker: Got permission denied issue

I installed Docker in my machine where I have Ubuntu OS. When I run: sudo docker run hello-world All is ok, but I want to hide the sudo command to make the command shorter. If I write the command

stackoverflow.com

WSL 개념 정리

알 수 없는 사용자 — Fri, 31 Mar 2023 17:24:08 +0900

Linux, Window

Linux와 Window 는 다양한 차이가 있지만, 결정적으로 몇가지 구조적 차이가 있고, 그 중 kernel에 대해 정리해보자.

kernel 이란?

간단하게 예를 들어보자.

MS word 에서 프린트 icon을 클릭하면 프린터기에서 인쇄가 된다.

사실, 프린터기는 프린트를 위한 특별한 언어도 있고, 컴퓨터와 소통하기 위한 protocol이 존재하나 우리는 그런걸 몰라도 된다.

이는 kernel 이 하드웨어와 os 간에 추상적인 layer를 놓아 소통할 수 있도록 하기 때문이다.

즉, kernel은 os의 brain 이다.

Window kernel

Window의 kernel은 hybrid형이다. 즉, 두가지 다른 kernel architectures을 결합해서 만들었다

Monolithic kernel

모든 코드와 드라이버를 하나의 큰 kernel 공간에 배치한다. 이에 따라 높은 퍼포먼스와 효율을 제공하는 크고 통합된 프로그램이라는 장점이 있다.

Micro kernel

마이크로 kernel은 코드와 드라이브를 여러 독립 공간에 분산한다. 이에 따라 쉽게 더하거나 빼는 것이 가능하다보니 더 유연하고 커스터마이징 가능하다는 장점이 있지만 추가적인 com,munication layer가 필요하다보니 덜 효율적이다.

window의 kernel은 둘다 차용해서 어느정도의 수정 가능성을 남겨 놓아 유연함과 커스텀 기능을 확보했다.

Linux kernel

반면, Linux는 monolithic kernel로 속도가 빠르고 효율이 좋다. 하지만 더 복잡하고 수정하기 힘들다.

Why Linux?

Linux는 오픈소스이기에 소스코드가 공개되어있다. 즉 os를 커스텀하거나 수정이 쉽다. 이로 인해 오픈 소스 프로젝트에 기여하고 싶은 개발자에게 최적의 platform 이다.
Linux는 window 보다 더 강력한 CLI를 제공한다. 즉, 파일 깔거나 정리하거나. 디버깅 등등에서 훨씬 유용하다.
여러 개발 툴, 컴파일러, 디버거, 에디터가 리눅스에서는 무료다.
더 안전하다. 소스 코드가 공개되었기에 많은 사람들에게 취약점들이 검증 되었다. privilege가 root user 와 regular users 들 사이에 차이가 있어 시스템의 중요 파일에는 접근 못하게 할 수 있다.
다양한 환경에 설치 가능하다. 디폴트로 사용하니 docker 같은 개념이 등장할 수 있었다고 생각한다.

Linux on Window

리눅스를 Window에서 사용하는 방법은 크게 두가지가 있다.

Virtual Machine 사용

Virtual Machine 은 분리된 virual 환경을 만들고, physical computer의 하드웨어와 소프트 웨어를 emulate 한다. VM은 CPU, memory, storage를 할당 받기 때문에 resource intensive 하다. Mac 에서 윈도우를 쓰기 위해 부트캠프를 깔았을 때 생각해보면 쉽다.

WSL 사용

WSL은 VM 필요없이 Window의 kernel 위에서 Ubuntu 가 돌아간다. 즉 Linux binaries와 tool 들을 윈도우 시스템에서 바로 쓸 수 있기 때문에 performance overhead나 하드웨어 요구사항이 없다. WSL 은 Linux 와 Window의 workflow를 seamless 하게 통합하여 두 OS간의 파일 공유, 리소스 공유가 자유롭다.

WSL 을 부연설명 해보자면, WSL 설치 순간 Ubuntu distribution의 subset에 기반한 가벼운 리눅스 환경이 생성된다. 이 환경은 기본적으로 제한적인 기능을 갖는다.

WSL은 Windows NT Kernel Proxy 라는 기술을 통해 Ubuntu 환경에서 생성하는 Linux 시스템의 calls 을 interpret하여 Window system에 던져준다. 이를 통해 Linux application과 tools들이 file system, network interface, hardware devices와 같은 Window resource에 접근 가능해진다.

WSL distribution (linux distribution)를 생성하면 VM 처럼 system resource가 사용되긴 한다. distribution의 종류, distribution 위에서 쓰이는 application, worload 등등에 따라 정도는 차이가 있다. WSL의 리소스 사용량은 Window Task Manager 에서 볼 수 있다.

How does the resource consumption of WSL differ from that of VMs?

WSL 은 VM 과 다르게 full os 를 필요로 하지 않는다. 즉, CPU, memory 등을 적게 쓸 수 밖에 없다. 또한 추가적인 full kernel 이 필요하지 않은 것도 이에 해당한다. (WSL도 kernel 이 필요하긴 하다. 그러나 window에서 필수적으로 동작하기 위한 가벼운 kernel 이다.)
WSL은 host Windows 와 resources 를 share 한다. VM이 통상적으로 생성 시기에 자원을 배분해줘야하는 것과 대조적이다.
WSL 은 여러 distributions 을 최소한의 overhead 로 운용 가능하다. VM 으로 하려면 .. 상상하기 싫다.
그렇지만 WSL 는 window 와 소통하기 위한 기본적 layer + linux distribution 이 설치되다보니 약간의 overhead가 존재하긴 하다. 그래도 워낙 장점이 많아서 좋다.

용어 정리

Linux binaries: executable 파일들, WSL은 Windows 환경에서 linux binaries 가 동작하도록 한다.

Layer in WSL: container 같은 추상화 개념. filesystem 과 system resource 를 관리한다. 우분투와 데비안 같은 복잡한 리눅스 환경을 WSL distribution을 통해 제공하기 위한 필수적인 foundation이 바로 layers이다. 이 위에 지어진다. linux distribution이 window operating system위에서 돌아가기 위해 필수적인 기능과 인터페이스를 제공한다.

Linux distribution: 다양한 버전의 linux

Hyper-V: Hyper-V 는 말하자면 큰 박스고, 작은 박스(VM)을 그 안에 넣을 수 있다. 각각의 작은 박스는 컴퓨터처럼 OS와 개별 application 을 가지고 있다. Hyper-V 덕분에 여러개의 VM 을 같은 physical machine에서 운용 가능하다.

Hyper-V 는 WSL2 아키텍쳐의 중추역할을 한다. WLS2는 가벼운 Linux kernel을 운용하기 위해 가벼운 Hyper-V VM 을 만든다. 해당 Linux kernel은 windows 10 에서 linux application 이 돌아가도록 하는 layer이다.

WSL2는 virtualized linux 환경을 windows 10 위에서 돌리지만, full-blown VM 의 overhead는 피한다. Hyper-V는 virtualized 환경을 생성하고 관리하는 필수적인 리소스를 제공한다.

WSL1 vs WSL2

WSL1은 translation layer를 사용하여 Linux system의 call을 Window 에 맞게 변환시켰고 Linux user-mode code를 Windows kernel에 바로 올렸다. 이 접근법은 linux를 window 위에서 가볍게 돌릴 수 있도록 했으나, 몇가지 한계가 존재했다.

WLS2 의 가장 큰 강점이 WLS1 의 한계를 해결했다고 보면 된다.

WLS2는 VMware와 공존하여 Docker를 사용하려면 Docker legacy를 써야했던 과거에서 벗어나, WLS2가 있으면 MS store 에서 설치한 OS를 캐치하여 docker, docker compose, warm, kubernetes를 사용할 수 있다.

Python Flat sequence, Container sequence

알 수 없는 사용자 — Sat, 18 Mar 2023 14:58:40 +0900

파이썬에는 두가지 sequence 가 존재한다.

Container 는 objects 의 reference 를 hold 하는 반면, flat sequence 는 실제 값을 저장한다.

Container sequences:

list: a mutable sequence that can hold any type of object

tuple: an immutable sequence that can hold any type of object

collections.deque: a mutable sequence optimized for adding and removing items from both ends

Flat sequences:

str: an immutable sequence of Unicode characters

bytes: an immutable sequence of bytes

bytearray: a mutable sequence of bytes

Container sequence example

이 말인 즉슨, container 는 주소값을 포함하므로

my_list[0]

와 같이 주소값에 들어가서 수정이 가능하다.

반면, Flat Sequence는 아래와 같이 직접 값을 저장하고 있다.

이에 따라 주소값에 들어가서 값을 수정하는 것이 불가능하다.

그러나 id() 라는 기능을 제공하여 string 전체에 대한 특정 interger 값을 제공해줄 수는 있다.

이는 주소값과 관련 없고, character 을 one by one 지칭하는 것은 아니지만 만약 동일한 string 이 존재한다면 두 string 이 같은 주소에 저장 된 같은 값인지 아닌지 확인할 때 사용할 수 있다.

머신러닝 정리 4.5(5) - XGBoost

알 수 없는 사용자 — Wed, 1 Mar 2023 14:00:17 +0900

XGBoost

* 영상 출처: https://www.youtube.com/watch?v=OtD8wVaFm6E

XGBoost 는 EXTREME Gradient Boost의 약자이다.

즉, Gradient Boost와 굉장히 유사하다.

관련 내용이 상당히 많으나, Regression 관련 어떻게 동작하는지만 간단하게 살펴보자.

(02:44)

초기값은 아주 간단하게 0.5로 보통 설정한다.

초기값을 average로 설정했던 Gradient Boost와 다르다.

(03:40)

또다른 다른 점으로, Gradient Boost는 MSE Regression Tree를 사용하여 RSS(예측과 실제의 오차의 제곱합) 기반으로 분기점을 선택한 반면 XGBoost는 Similarity Score 이라는 것을 사용한다.

Similarity Score

(04:19)

Similiarity Score은 square of sum of residuals 이 아니라 sum of residual의 sqaure 값이다. 그리고 lambda 는 regularization term이다.

일단 initial guess 가 0.5 이므로, -10.5, ..., -7.5 총 4개의 similiarity score은 4이다.

(05:29)

(04:47)

유의할점은 만약 데이터가 대칭의 위치에 있다면 서로 값을 cancel out 한다.

즉, similarity score은 높을 수록 cancel out 되는 일이 없다는 것을 뜻한다.

데이터를 분류하기 위한 트리는 regression 트리와 유사하나 다르다.

(06:26)

데이터 샘플 2개의 평균값을 나누는 기준으로 설정한 후, 여러 기준 중 가장 적절한 것을 선택하는 것은 동일하나, RSS 로 선택하는 것이 아니라 Similarity Score을 이용한다.

(07:42)

먼저 각 값에 대한 similarity score을 구한 후 (regularization term lambda는 0으로 한 상태이다.)

(08:51)

Left Similiarity + Right Similarity - Root Similarity를 수행하여 Gain 값을 구한다.

(09:36)

(10:24)

다른 값을 root node 로 할 때의 Gain 도 구해보았다. 각각 4, 56.33를 얻었다.

비교 결과 <15 일 때 Gain 값이 가장 높아 tree로 사용하기 좋다.

(11:56)

이 후, Dosage < 22.5 로 구분한다.

이 때 Dosage < 22.5 의 Gain 은 28.17이다.

(12:21)

(12:26)

Dosage> 30 으로 하면 Gain이 140.17이다.

이에 따라 Dosage<30 을 tree로 선정한다.

Gradient Boost와 달리 XGBoost 는 tree 자체를 Prune 하는 기능이 있다. 이를 통해 성능 나쁜 Tree는 버려버리는 것이다. 굉장히 타당한 생각이다.

여기서 gamma 라는 term이 등장한다. 지정한 gamma 값으로 Gain - gamma 를 하여 값이 negative가 되면 해당 tree를 prune 한다. (실제로는 XGBoost가 module 내에서 자동으로 값을 iterate하며 cross validation 을 수행하고, 그 중 가장 좋은 값으로 선택한다.)

(14:10)

여기서 유의할 점은 만약 자식 노드의 Gain - Gamma 가 양수라면 부모노드 - Gamma 가 음수여도 Tree를 prune하지 않는다.

(15:29)

아까 잠시 나왔던 lambda 값이 0이 아닌 값이 주어진다면 어떻게 될까?

(15:44)

(15:55)

(16:05)

leaf에 있는 Sample 개수에 따라 값이 조정 정도가 다르다. 작을 수록 조정 되는 정도가 크다.

(16:50)

당연히 이로인한 Gain 값도 크게 작아진다.

정리하자면 regularization term을 통해 Gain 값을 조정하고 결국 트리가 prune 되도록 할 수 있다. 이 또한 사용자가 manual 하게 주거나, cross validation 과정을 통해 자동으로 XGBoost가 선택할 수 있다.

(19:43)

Output Value 를 구하는 방법은 Similarity 와 거의 유사하나, square을 하지 않는다.

(22:03)

이 후, Output * learning Rate + initial Guess 로 guess을 업데이트 한다.

(22:53)

이 후, 반복해서 트리를 만든다.

(23:40)

끝.

머신러닝 정리 4.5(7) - 특이값 분해 (SVD)

알 수 없는 사용자 — Sun, 26 Feb 2023 01:06:32 +0900

본 글은 https://angeloyeo.github.io/2019/08/01/SVD.html

특이값 분해(SVD) - 공돌이의 수학정리노트

angeloyeo.github.io

내용을 이해하되, 중간중간 기본적 개념을 조금 더 추가한 글입니다.

특이값 분해(Singular Value Decomposition, SVD)는 임의로 $m /times n$ 차원의 행렬 $A$에 대하여 다음과 같이 행렬을 분해할 수 있다는 '행렬 분해' 방법 중 하나이다.

차원 축소 기법 PCA 에 대해 살펴보았었는데, SVD 도 차원 축소 기법 중 하나이다. (차원 추출)

추천 시스템 관련 글에서 SVD 즉 특이값 분해를 다뤘었기에 그 글만 참고해도 좋다.

$$A = U \Sigma V^T$$

A 라는 행렬을 다음과 같이 $U, V^T$ 로 분해 가능

orthogonal: 직교

orthogonal matrix는 모든 column vector가 자기 자신을 제외한 나머지 모든 column vector들과 직교이면서 크기가 1인 단위 벡터들로 구성된 행렬

벡터가 서로 직교할 때, 우리는 직교벡터라 한다. 이 때 각 벡터의 내적은 0 이다.

정규직교(orthonormal)벡터: 두 벡터가 직교벡터이면서 각 벡터의 길이는 1인 방향성분만을 나타내는 벡터

단위 벡터는 자기 자신과 곱하면 즉 내적하면 결과값이 1이다. (단위벡터의 norm이 1이기에 당연한 결과이다.)

자기 사진을 제외한 나머지 모든 벡터들과는 직교한다.

즉, 자기 자신을 제외한 나머지 벡터들과의 내적 결과가 0이 된다.

sin과 cos 으로 이루어진 벡터를 나타낸다. 이들 벡터 a,b의 길이는 각각 1이며 둘 사이의 각도는 90도 이다. 두 벡터가 직교하며 각 벡터의 길이는 1로써 방향성분만 나타내므로 이들은 정규직교벡터이다.

이러한 정규직교벡터들은 행렬의 column vector에 삽입하면 직교행렬이 된다.

즉 Q 를 직교행렬이라고 했을 때 orthonormal vector들의 Q의 정규직교기저가 되는 것이다. 아래의 그림 같이 말이다.

이러한 정규직교기저는 선형대수의 행렬 계산에 있어 좋은 결과를 보여준다.

$q_1 ... q_n$: 각각은 orthnormal vector

즉, $q_i$ 는 자기 자신을 제외한 나머지 벡터들과 직교하다.

Q transpose와 Q 를 곱하면 Identity matrix가 나타난다.

(직교 벡터끼리의 곱은 0이고, 자기자신의 곱은 단위벡터의 내적이기에 1)

정리하자면 정규직교 벡터를 column으로 갖는 직교행렬을 배웠다. 정규 네임이 orthonormal matrix 여야 할 것 같지만, orthogonoal matrix 라 한다.

직교행렬의 특성

1. 정방행렬인 직교행렬은 transpose 가 역행렬과 동일하다.

단위 행렬의 각 column vector는 자기 자신을 제외한 나머지 벡터와 90도의 각도를 이루면서 크기가 1이어야 한다. 이를 시각화하면 아래와 같다.

아까 살펴보았듯이, 정방행렬인 상황에서는 자기 자신과 곱해진 경우는 1, 이외에는 직교로 0이 되므로 단위행렬을 만들어내고, 이는 결국 역행렬의 특성과 동일하다.

2. 모든 colum이 직교 벡터를 가지나 각 벡터의 크기가 1이 아닐 때 직교 행렬을 만드는법

벡터의 크기로 행렬 원소 전체를 나누어주면 된다.

여기서는 column $q_1, q_2$의 크기가 같아서 동일하게 나눠줬지만, 다를 경우에는 각자의 크기로 나눠주면 된다.

직교 행렬을 만드는 방법으로 그람-슈미트 과정이 있다. 본 내용은 추후 다시 다룬다.

직교 행렬 사용의 장점

추후 읽어보자

https://twlab.tistory.com/37

https://twlab.tistory.com/34

단위 벡터:

크기가 1인 방향만이 의미를 갖는 벡터

※Diagonal Matrix

대각 행렬 : 행렬은 선형 변환이다. 이 중, diagonal matrix 는 벡터의 크기를 조정한다.

scaling factor를 0으로 하면 차원을 축소하는 것도 가능하다.

SVD의 기하학적 의미

직교하는 벡터 집합에 대하여, 선형 변환 후에 그 크기는 변하지만, 여전히 직교할 수 있게 만드는 그 직교 벡터 집합은 무엇이고, 변형 후의 결과는 무엇인가?

이 말의 뜻이 이해가 잘 안간다면

https://angeloyeo.github.io/2019/08/01/SVD.html

특이값 분해(SVD) - 공돌이의 수학정리노트

angeloyeo.github.io

위 글에서 직접 시각화 툴을 선형 변환하며 직교가 유지되는 경우를 살펴보면 이해에 도움이 된다.

직교하는 벡터 x, y 가 있다고 할 때, 두 벡터가 선형 변환 한 결과 Ax, Ay 도 여전히 직교하는지 살펴보자.

위 경우에는 Ax, Ay가 직교하지 않는다.

하지만 위 그림과 같이 잘 조정하다보면 어떤 경우에는 x,y 도 직교하고 Ax, Ay 도 직교한다.

이 경우 우리는 벡터 x,y 를 가지고 singular vector decomposion 을 했다고 할 수 있다.

기하학적 의미를 다시 살펴보자.

직교하는 벡터 집합에 대하여, 선형 변환 후에 그 크기는 변하지만, 여전히 직교할 수 있게 만드는 그 직교 벡터 집합은 무엇이고, 변형 후의 결과는 무엇인가?

벡터 집합이란, 결국 column 벡터를 갖는 행렬을 말한다.

결국 정리하자면,

직교하는 벡터 집합: $V$

선형 변환: $A$

크기는 변하지만 여전히 직교할 수 있게 만드는 직교 벡터 집합: $\Sigma$

변경 후의 결과: $U$

이다.

$U = AV \cdot \Sigma$

$U \Sigma^T = AV$

$U \Sigma^T V^T = A$

$A = U \Sigma V^T$

(선형변환을 한 직교하는 벡터 집합(행렬)에 orthogonal한 벡터 집합을 곱해도 여전히 직교하는 벡터 집합이 존재한다)

U, V 계산법은 eigenvalue decomposition 이라는 기법을 이용해야 한다. 추후 정리하자.

위 결과물을 보면, sigma가 마치 각 항에 weight 의 역할을 하는 것을 알 수 있다.

즉 이 scaling fator 가 A가 가지고 있는 matrix 의 정보량을 결정해준다.

즉, SVD 방법을 통해 A 라는 임의의 행렬을 여러개의 A 행렬과 동일한 크기를 갖는 여러개의 행렬로 분해해서 생각할 수 있는데, 분해된 각 행렬의 원소의 값의 크기는 sigma 의 값의 크기에 의해 결정된다.

다시말해 SVD를 이용해 임의의 행렬 A 를 정보량에 따라 여러 layer로 쪼개서 생각할 수 있게 한다.

특이값 분해의 활용

특이값 분해는 분해되는 과정보다는 분해된 행렬을 다시 조합하는 과정에서 그 응용력이 빛을 발한다.

기존의 $\Sigma, U, V^T$ 로 분해되어 있던 A 행렬을 특이값 p개만을 이용해 $A^'$ 라는 행렬로 부분 복원 할 수 있다. 위에서 말했던 것 특이값의 크기에 따라 A 의 정보량이 결정되기 때문에 값이 큰 몇개의 특이값만을 가지고도 충분히 유용한 정보를 유지할 수 있다.

즉, 이를 통해 차원을 축소할 수 있다.

정보를 다 반영 안해도 상당한 정보를 얻을 수 있다.

(입출력의 차원이 다른 변환의 경우에도 사용 가능하다.)

아래 블로그 참고

https://angeloyeo.github.io/2019/08/01/SVD.html

특이값 분해(SVD) - 공돌이의 수학정리노트

angeloyeo.github.io

마지막으로 해당 개념은 추천시스템에서도 활용된다.

User item 정보를 User, Item 그리고 차원을 맞춰주며 동시에 중요도에 따라 scaling 하는 $\Sigma$ 행렬로 분해할 수 있다.

여기서 User, Item 의 행렬은 orthogonal 행렬이다. $\Sigma$ 는 diagonal matrix 이다.

분석 후, 중요도에 따라 K의 factor만을 선정하여 $\hat{R}$을 복원한다.

계산방법은 아래의 블로그 내용을 참고하자.

https://ys-cs17.tistory.com/52

SVD의 기본 이론과 이해 및 활용

SVD (Singular Value Decomposition) 정의: 임의의 $m * n$ 차원 행렬 A에 대하여 다음과 같이 행렬 분해를 할 수 있다는 행렬 분해 방법 중 하나이다. $$ A = U\Sigma V^T $$ $A: m \times n$ rectangular matrix $U: m \times n$ or

ys-cs17.tistory.com

머신러닝 정리 4.5(6) - PCA

알 수 없는 사용자 — Fri, 24 Feb 2023 21:12:35 +0900

들어가며

feature의 개수가 1, 2개인 경우에는 시각적으로 표현하기가 쉽다.

하지만 feature 개수가 많아지면 시각적으로 표현이 불가능하다.

또한 feature 개수가 많아지면, 데이터를 학습의 sparsity 도 높아지고, 이로 인해 저장 공간, 학습 속도 이슈를 마주한다.

직관적으로 생각해도 feature간 중요도 차이가 있다.

이로 인해 차원 축소를 하게 되는데, 차원 축소는 feature 선택과 feature 추출 두가지 방식이 있다.

이 중 feature 선택에 해당하는 PCA 를 간단하게 설명해본다.

본 내용은 StatQuest 의 https://www.youtube.com/watch?v=FgakZw6K1QQ 영상을 직접적으로 참고하여 작성하였다.

본문

결과를 미리 보자면 다음과 같이 feature가 4개인 데이터가 주어졌을 때, PCA 를 통해 주성분 2개를 골라내고, 그 두개가 데이터를 얼마나 설명하는지 수치적으로 표현할 수 있다.

feature 가 두개인 데이터로 내용을 쉽게 살펴보자.

먼저 각 feature 에 평균 값을 구하고, 평균값에 해당하는 좌표를 찾는다.

그 좌표를 기준으로 데이터를 평행이동한다.

평행 이동한다해서 데이터의 특성이 망가지는 일은 없다.

그 후 데이터를 가장 잘 설명하는 선을 찾는다.

보통 데이터 샘플과 선과의 거리를 최소화 하기 위하여 'b' 를 작게 만들어야 한다고 생각하나,

실제로는 계산의 편리함을 위하여 c 의 길이를 최대한으로 방식으로 한다. (c 가 길수록 b가 짧아진다.)

SS 를 최대화 하는 선을 찾자.

데이터를 설명하는 해당 선을 Principle Component 1의 약자 PC1 이라 한다.

PC 1 의 slope 가 0.25라는 의미는 x 좌표로 4만큼 갈 때, y 좌표로 1만큼 올라간다는 뜻이다.

진한 글씨로 적힌 부분을 우리는 linear combination이라 한다.

가장 긴 길이를 1 로 scale 길이들을 scale 한다.

즉, 0.97 과 0.242의 선형 결합으로 한다.

0.97과 0.242로 구성되는 unit vector 를 바로 Eigenvector, 혹은 Singular Vector라 한다.

그리고 각 feature 의 비, 즉 0.97 : 0.242 를 Loading Scores 라 한다.

그리고 SS 를 eigenvalue 라 한다.

PC 1 에 perpendicular 한 vector를 PC2 라 한다.

보통 feature가 2개 이상일 때는 perpendicular 하면서 동시에 SS 가 가장 긴 vector 가 PC2 이다.

그 후 PC1이 x축이 되도록 회전한다.

PC1 과 PC2 를 기준으로 새롭게 데이터를 시각화한다.

SS (eigen value 즉, 선이 얼마나 데이터를 잘 표현하는가) 를 데이터 샘플 개수로 나눈 값을 variation이라 하고, 이 값을 기준으로 데이터를 얼마나 설명하는지 결정한다.

데이터의 차원 수가 더 커져도 마찬가지다.

예를 들어 feature 가 3개라면, PC1 에 perpendicular 하면서 SS 가 가장 긴 PC2,

PC1, PC2 와 perpendicular 하면서 SS가 가장 긴 PC3 를 찾고,

PC1, PC2, PC3 중 Variation이 가장 높은 2개를 선택 하고, PC1 을 x축이 되도록 회전한다.

그럼 2차원으로 표현 가능하다!

머신러닝 정리 4.5(4) - Gradient Boost

알 수 없는 사용자 — Wed, 22 Feb 2023 16:06:09 +0900

Gradient Boost는 굉장히 다양한 분야에 적용 가능하도록 디자인 된 알고리즘이다. 하지만 주로 continous value를 예측하는 모델로 사용되고, 나머지도 분류 모델 정도로 사용된다.

본 글에서는 먼저 회귀 모델로의 Gradient Boost를 다루고 분류 모델로의 Gradient Boost를 다뤄본다.

회귀 모델로의 Gradient Boost

AdaBoost 와 Gradient Boost의 차이

AdaBoost를 잘 모르면 이 글을 읽고오자.

위와 같은 데이터 샘플들이 주어졌다고 가정해보자.

AdaBoost(왼쪽), Gradient Boost(오른쪽)

AdaBoost 는 여러개의 stump의 결합으로 의사결정을 하는 머신러닝 기법이다. 선행 stump가 잘 분류하지 못했던 샘플들에 대하여 후행 stump가 얼마나 잘 분류했는가에 따라 각자 다른 Amount of Say 가 주어지고, 새로운 input이 들어오면 내린 결정 * Amount of Say로 최종 output 을 결정한다. (투표권에 차등이 있다고 생각하면 편하다) 당연히 stump를 결정할 때도 선행 stump가 잘 분류하지 못했던 샘플을 기반한다. 사용자가 요청한 stump의 개수 혹은 완벽하게 샘플을 모두 분류해낼 때 까지 위 과정을 반복한다.

Gradient Boost는 선행 트리의 오류를 후행 트리가 반영한다는 점에서 AdaBoost와 유사하나, 주로 tree의 사이즈가 stump 보다 크다. 본 글에서는 주로 leaf 의 개수를 4개로 제한해서 설명할 예정이나, 현업에서는 주로 8~ 32개 정도로 제한한다. 즉, AdaBoost나 Graident Boost 모두 선행 트리의 오류를 반영하여 고정된 사이즈의 트리를 만든다는 점에서는 동일하나 Gradient Boost의 각 트리가 stump 보다 클 수 있다는 점이 다르다. 또한 AdaBoost와 Gradient Boost 모두 최종 output에 대한 각 트리 별 결정 발언권을 조정하나, Gradient Boost의 모든 트리는 결정권의 크기를 동일하게 본다. (즉 Gradient Boost는 모든 tree의 결정권 크기를 동시에 조정 가능)

Gradient Boost 작동 원리

Gradient Boost의 작동 원리는 반복 과정을 통해 label 예측을 개선시켜 정답에 가깝게 하는 것이다.

Initial 예측은 주어진 정보가 따로 없으므로, label (Weight)의 평균을 사용한다.

즉, Weight의 평균은 우리가 첫번째로 예측한 값이다.

예측값을 기존 관측값인 Weight 샘플 값들에서 각각 뺀다. (예측 값 - 관측 값)은 Residual이라 부른다.

Residual 값을 분류하는 Tree를 만든다. 목표는 label과 예측값의 차이인 Residual 값을 점점 작게 만드는 것이다. 내용을 끝까지 따라오면 충분히 이해할 수 있다.

다음과 같은 Tree를 통해 Residual 값을 분류한다. 해당 Tree를 만드는 방법은 Regression Tree와 동일 할 것으로 추측된다. 현재 Tree의 leaf 는 4개이나, 현업에서는 보통 8~ 32개를 사용한다는 점을 기억하자.

각 leaf 에 해당하는 값이 여러개인 경우 평균을 취한다. 왜 평균 취하는 이유는 아래 공식을 통해 유도되는 과정을 참고하자.

트리를 통해 분류한 residual 값과 Initial 예측값을 이용하여 분류 기준에 해당되었던 데이터 샘플의 weight 값을 update한다.

한번의 과정만 거쳤는데 실제 Weight값을 복원했다. 무슨 뜻일까? 안봐도 데이터에 Over-fitting 되었다는 증거다.

여기서 Learning Rate 개념이 도입된다.

Learning Rate란 한번에 큰 값을 업데이트 하지 말고, 조금씩 목표 지점에 도달하자는 개념인건 딥러닝을 하시는 분들은 바로 이해할 수 있을 것이다. 정리하자면 0~ 1 사이 값을 갖는 Learning Rate * residual 로 예측값을 업데이트 한다. 새로운 예측값 72.9 라는 값이 한번에 88까지 접근 했던 초기 방식에 비해 훨씬 더 천천히 접근하지만, initial 예측값이던 71.2 보다는 더 좋은 결과임에는 틀림없다. Graident Boost를 제안한 Jerome Friedman의 emprical 실험 결과에 따르면, Learning Rate를 통해 옳은 방향으로 조금씩 나아가는 방식이 더 낮은 Variance 즉, 타당한 예측값을 만들어낸다.

새로운 예측 값을 통해 Residual 을 업데이트해보니, 확실히 이전 Residual 보다 결과가 더 낫다.

위 과정을 반복한다. 반복 과정 중, Residual을 분류하는 Tree는 당연히 새롭게 만들어 지기도 한다. (여기서는 편의를 위해 동일한 Tree를 사용하였다.)

반복 과정에서 초기 예측 값, 이후 반복 과정에서 구한 각각의 residual X Learning Rate을 더해 예측값을 업데이트한다.

반복 과정에서 Residual 은 계속해서 작아진다.

우리가 정한 최대 반복 횟수, 혹은 resiual 값이 더이상 변화가 없을 때 학습을 멈춘다.

이후 모델에 예측을 위해 Input 데이터가 들어오게 되면,

학습과정에서 생성하였던 initial Value + 각 트리의 Residual * learning rate 를 통해 최종 예측 값을 산출한다.

Gradient Boost 이론 (Regression)

Data 샘플 $x_i, y_i$ 가 총 n 개 존재하고, Loss function은 미분 가능해야 한다.

Regression을 수행하는 Gradient Boost가 주로 사용하는 Loss function은 아래와 같다.

$\frac{1}{2} \textrm{ (Observed - Predicted)}^2$

앞에 $\frac{1}{2}$ 가 붙어있는 이유는 Gradient Boost의 Loss function을 미분하면 합성함수으로 인해

$-\textrm{Observed - Predicted}$ 가 된다. 미분 결과가 -Residual 이이 되는 것을 알 수 있다.

$L(y_i, F(x))$ 에서 $y_i$ 가 Obeserved 이고, $F(x)$ 가 predicted 이다.

(물론 Loss function은 다른 것도 있다.)

$y_i$ 는 observed, $\gamma$ 는 predicted 이다.

아래와 같은 데이터 샘플이 주어졌을 때,

i = [1 , n] 을 모두 더하면 아래와 같이 된다.

$argmin_\gamma$는 총 합을 최소화 하는 predicted 의 값이라는 뜻이다.

오른쪽 그래프와 같이, predicted 값에 따른 $F_0(x)$를 알 수 있다.

그림을 보아하니 Gradient Descent로 최소값을 찾아낼 수도 있지만, 사실 간단한 math 이니 그냥 계산해보자.

미분 값이 즉 순간변화율이 0이 되는 순간을 찾으면 된다.

구하고보니, 그냥 obeserved data의 평균값이다. 그래서 Gradient Boost model을 초기화 할 때 observed data의 평균값으로 한다. $F_o(x)$ 는 초기 예측값인 leaf라는 것을 확인했다.

m = 1
#M is usally 100
for i in range(m, M)

m 은 첫번째 tree이고, M 은 마지막 tree이다.

for i in range(1, n)
#for all samples

$\frac{\partial \textrm{ Loss function}}{\partial \textrm{ predicted}}$

즉, $-\textrm{Observed - Predicted}$ 에 - 가 붙은 형태이니 결국 $\textrm{Observed - Predicted}$ 즉, Residual이다.

$F(x) = F_{m-1}(x)$는 m = 1 일 때, $F(x) = F_0(x)$ 임을 알 수 있다.

즉, $r$ 은 Residual이고 $i$ 는 sample number 이며, $m$은 몇번째 tree인지 알려준다.

(A)는 모든 샘플의 residual을 계산한다.

(A) 과정이 Graident 를 구하는 과정이므로, Gradient Boost 라는 이름을 얻게 되었다.

그리고 Loss function은 Linear regression과 달리 $\frac{1}{2}$ 이 앞에 붙어있다. 따라서 명칭이 약간 다르다. Pseudo Residual이다.

이 말은 Residual이 terminal leaf 로 끝나는 regression tree를 만든다는 것이다. j 는 leaf 의 index이다.

$x \in R_{i,j}$ 는 i,j 번째 leaf에 존재하는 data sample 들을 뜻한다.

우변을 최소화하는 $\gamma$ 즉 residual을 찾는 것이 목표이다.

즉 미분 값이 0인, 0 = observed - (선행 예측값 + 최소화 하는 Residual) 이다.

분석하고 나니, 위에서 살펴보았던 결과와 같다.

예시로 아래와 같은 트리가 있다고 할 때,

위와 같이 계산 가능하다.

정리하자면 residual은

0 = observed - (선행 예측값 + 최소화 하는 Residual)

observed - 선행 예측값 = Residual

이 되고,

같은 leaf 여러개의 residual이 존재할 경우

각 residual 의 평균이 leaf의 residual이 된다.

$\nu$ 는 learning rate이다.

새로운 예측 값 = 이전 예측값 + learning rate X 데이터 샘플이 해당되는 leaf의 residual들

우리가 흔히 Gradient Boost를 개념화 할 때 초기 예측 값 + 트리_1 leaf residual + 트리_1에 영향받은 트리_2 leaf residual + 트리_2에 영향받은 트리_3 leaf residual .... 로 구조화 하기 때문에 (D) 공식이 이해가 잘 안갈 수도 있지만, 그냥 누적 분포처럼 $F_m(x)$은 누적 값이라고 생각하면 된다.

Gradient Boost는 예측 값과 관측 값의 차이를 최소화 하는 loss function의 미분값(Gradient)에 learning rate를 곱하여 예측 값을 관측 값과 유사하게 근사하는 기법이다.

분류 모델로의 Gradient Boost

Gradient Boost가 Classification에 사용되면 Logisitic Regression과 겹치는 부분이 많다.

logisitic regression을 잘 모른다면 이 글을 읽어보자.

사용 데이터는 아래와 같다.

회귀모델과 마찬가지로 초기 initial 예측을 생성한다. 여기서는 각 개인의 log(odds)를 사용한다.

※ odds: 발생 확률/ 발생하지 않을 확률

샘플 중 Troll 2 를 좋아하는 인원은 4명이고 싫어하는 인원은 2인이므로

$\log(\textrm{odds})$ = $\log (\frac{4}{2}) = 0.7$ 이다.

Initial Prediction

Logistic Regression recall

Logistic Regression은 이진 분류의 경우, 각 분류에 속할 확률을 계산한다.

log(odds) = X theta

즉 이항 로지스틱 모델에 범주 정보를 모르는 입력 벡터 x를 넣으면 범주가 Positive 에 속할 확률을 알 수 있다.

정보를 활용하여 Troll 2 를 좋아할 확률을 계산해보자.

사실 정확한 확률은 아래와 같다. Troll 2 를 좋아할 확률은 4/6 = 0.6667 과 동일하다.

0.5를 의사결정의 threshold로 삼으면 Training Set 의 모든 샘플은 Troll 2 를 좋아한다고 예측할 수 있다.

이제 Initial Residual을 잡아보자.

※ Residual = (Observed - Predicted)

Residual을 업데이트 하기 위해 feature로 Residual을 분류하는 Tree를 생성한다.

현업에서는 leaves 가 8 ~ 32 로 사용된다는 것을 기억하자.

※ 주의 사항

Gradient Boost 를 Regression에 사용할 때는 leaf 에 corresponding 되는 데이터 샘플이 1개라면 Output Value 를 계산할 때 별다른 처리 없이 residual 값 그대로 prediction 예측에 사용되었다.

그러나 Classification에 사용될 때는 initial Prediction 자체가 log(odds)인 반면, leaf 의 residual 은 확률이기에 바로 예측에 사용할 수 없고 변환을 해주어야 한다.

이에 따라 아래식을 활용한다. 아래 식은 아래쪽 수식 유도 과정에서 설명한다.

해당 leaf 는 데이터가 한개이므로 아래와 같이 정리할 수 있다.

처음에 모든 샘플이 1에 속할 확률이 0.7 로 사전 설정되었으므로 모두 동일하지만, update 과정에서 당연히 달라진다.

update 를 모두 마친 후, initial guess + learning rate $\times$ 각 leaf의 residual 로 새로운 prediction을 만든다.

(원할한 설명을 위해 lr 을 0.8로 잡았지만 현업에서는 보통 0.1을 사용한다.)

초기 예측값 log(odds) 를 먼저 업데이트하고,

Troll 2 를 좋아할 확률을 업데이트 한다.

※ 애초에 initial guess를 log(odds)로 하지 않고 확률로 하면 어떨까 싶지만, 애초에 logistic regression을 수행하는 이유가 linear 회귀 모델로 해결하지 못하는 부분에 odds 를 취하고 log 를 이용하여 decision boundary에서 변화를 급격화 시킴으써 명확하게 구분하기 위함이라는 것을 기억하자. 즉, tree가 분류를 수월하게 하기 위해서라도 log(odds) 과정은 필수이다.

Loves Troll 2 label이 Yes 임에도 probability 가 0.7에서 0.5로 떨어졌다. 즉 예측이 오히려 나빠졌다. tree를 하나만 만들지 않고 여러개 만드는 이유가 바로 여기에 있다.

지금부터는 iterate 과정이다.

새롭게 예측한 probabilty 를 이용하여 Residual을 새롭게 update한다.

업데이트 한 residual로 tree를 새롭게 생성하여 분류한 후,

사용자가 사전 설정한 maximum 횟수, 혹은 residual이 특정 임계값 아래로 내려갈때 까지 위 과정이 iterate 된다.

학습이 완료 된 이후, input data가 주어지면 위 과정을 거쳐 Log(odds) prediction 값을 얻게 되고, 이를 통해 probability를 업데이트 한다.

Gradient Boost 이론 (Classification)

※ log(likelihood)

각 우도를 곱하는건 너무 stressful 하다.

양 변에 log 를 취해주면

계산이 간단해진다.

우도를 모른다면 이 글을 읽어보자.

우도: 각 사건이 일어날 확률을 곱했을 때 최대가 되는 경우가 가장 일어날 확률이 높은 상황

log: log는 단조 함수이므로 log 를 취해주는 것은 문제가 없다.

설명의 간소화를 위해 sample이 3개인 데이터를 사용한다.

Likelihood는 클 수록 예측이 잘 된다는 뜻이다. 당연히 Logistic Regression의 목표도 log(likelihood)를 최대화 하는 것이다.

이에 따라 log(likelihood)를 Loss function으로 쓰려면 -1 $\times$ log(likelihood)를 사용해야 한다.

이진 분류 문제이므로, $P(x_i | \theta)$ 가 1 아니면 0 이다. 이에 따라 Loss function을 아래와 같이 정리 할 수 있다.

앞에 - 가 붙어야 한다.

함수가 미분 가능여부를 확인하자.

미분 가능을 확인하는 과정이니, sum 은 생략한다.

$y_i$ 의 readability를 위해 Observed 로 기입

$\log(p) - \log(1-p)$ 는 $\frac{\log(p)}{\log(1-p)}$ 이므로, log(odds) 이다.

그리고 $\log(1-p) 는 -\log(1+e^{\log(\textrm{odds})})$이다. 아래 유도과정을 살펴보자.

이제 5) 가 미분 가능한지 확인해보자. 추후 우리의 목표는 prediction (log(odds)) 로 미분을 했을 때 0이 되는 극저점을 찾는 것이므로 log(odds) 로 미분가능한지 확인한다.

chain rule 에 의해 미분하면 아래와 같이 정리 가능하다.

미분 가능한 것을 확인했다.

Model 을 initalize 하기 위하여 initial prediction 이 필요하다.

log(odds)은 prediction 이므로 위 식은 아래와 같이 정리 가능하다.

위 값을 minimize 하는 gamma 값을 찾아야 하므로 log(odds) 로 미분한다.

위에서 미리 구해놓았던

를 활용하여

$-1 + p + -1 + p + -0 + p = 0$

$p = \frac{2}{3}$

$\log(odds) = \log(\frac{2}{1})$

Yes: 2 , No: 1 라는 점에서 위 유도과정이 reasonable 한 것을 확인했다.

$F_0(x) = \log(\frac{2}{1}) = 0.69$

initial guess 를 구했다.

m = 1
#M is usally 100
for i in range(m, M)

m 은 첫번째 tree이고, M 은 마지막 tree이다.

for i in range(1, n)
#for all samples

Loss function의 미분은 이미 계산을 완료했다.

$F(x) = F_{m-1}(x)$ 이므로,

Pseudo Residual 을 업데이트하면 아래와 같다.

Regression Tree 를 만들어서 분류한다. 단, 아래 tree가 Stump인 것은 계산의 단순화를 위해서이다.

Loss function은 이미 알고있다.

sum은 생략한다. (데이터가 한개인 경우, 계산의 단순화)

i에 1 을 대입

gamma 에 대하여 미분 값을 찾는 것이 가장 정확한 방법이나 너무 많은 연산량이 필요하다.

이에 따라 Regression을 위해 Gradient Boost 를 사용한다.

즉, 테일러 급수를 통해 Loss function 을 근사한다.

테일러 급수

자세한 내용은 이 글의 Gradient Descent 내용을 참고하자.

$\gamma ^2$ 이하 항을 $Q(x)$ 라 할 때, $Q(x)$ 의 크기는 무시할정도로 작다고 가정하여 생략되었다.

머신러닝 정리 4.5(3) - AdaBoost

알 수 없는 사용자 — Thu, 16 Feb 2023 22:57:52 +0900

Adaboost 를 만드는 방법이 몇가지 존재하지만, 그 중 Decision Tree를 사용하는 것이 가장 일반적이다.

Decision Tree를 기반으로 하는 Adaboost 를 살펴보자.

랜덤 포레스트 내용이 필수적으로 등장하니, 잘 모르는 분들은 먼저 이 글을 읽고 오면 좋다.

랜덤 포레스트는 트리를 만들 때 마다 full-sized tree를 만든다. 그리고 max sample 개수나 특정 조건에 따라 각각의 트리의 깊이가 다르다.

반면, Adaboost는 주로 깊이가 1인, 즉 루트 노드에 두개의 leaves 만 존재한다. 이러한 형태의 Tree를 Stump 라 한다. 아래 이미지와같이 stump 들의 모임은 주로 Forest of Stumps 라 부른다.

당연히 Stumps는 feature 하나로 결정을 내리다보니 좋은 의사결정이 나올 확률이 낮다.

Stumps야 말로 "weak learners" 라 할 수 있다.

Random Forests와 AdaBoost의 차이점

Random Forests(왼쪽) AdaBoost(오른쪽)

굉장히 흥미로운 점은 Random Forests는 각 트리의 vote 능력이 동등한 반면 AdaBoost는 vote 능력이 동등하지 않다. 이와 유사한 다양한 경우에서 능력에 따라 vote 의 weight를 다르게 주는 것이 항상 성능이 향상되었던 것을 떠올려볼 때, 굉장히 당연하다.

Random Forests는 tree의 순서가 상관 없었지만, AdaBoost는 순서가 굉장히 중요한 것도 다른점이다.

선행 Stump가 판단을 잘 못 내리면 따라오는 Stump 는 영향을 받을 수 밖에 없는 구조이다.

정리하자면 AdaBoost 다음의 3가지 철학을 가지고 있다.

AdaBoost는 weak learner인 stumps를 여럿 결합하여 classifiaction을 수행한다.
Stumps 중 몇몇은 classification에 있어 더 강한 발언권을 갖는다. (weight)
각 stump는 생성될 때 선행 stump 의 실수에 영향을 받는다.

AdaBoost 생성 과정

위와 같이 데이터가 있다.

Boost 는 선행 트리가 후행 트리에 영향을 끼쳐야하기 때문에 Weight의 값이 중요하다.

초기 Weight는 전체 데이터 샘플 개수 분의 1 로 한다.

Weight는 Stump 를 만드는 과정에서 계속 update 된다.

첫 Stump 를 결정하기 위해 각 feature를 택했을 때 Gini index 를 비교해보자.

Chest Pain은 8개 중 총 3개의 incorrect한 결과를 생성한다.

Blocked Arteries는 총 4개의 incorrect한 결과를 생성한다.

Patient Weight > 176 은 총 1개의 incorrect한 결과를 생성한다.

여기서 176으로 결정하는 방법은 이글에서 설명 했었다. Iterate 과정 중, 172 180 사이에서 Gini index 가 가장 작았기 때문이다.

Patient Weight의 Gini Index가 가장 낮으므로 첫 노드로 선정 된다.

AdaBoost는 각 Tree 마다 최종 의사결정 단계에서 발언권, 즉 가중치가 다르다.

가장 먼저 Total Error 는 분류 실패한 데이터 샘플의 Weight를 모두 더한 값으로 여기서는 $\frac{1}{8}$이다.

(참고로 Sample Weight의 총 합은 1이다. Total Error 가 0에 가까울 수록 좋은 stump 이고 1에 가까울 수록 나쁜 stump이다.)

Amount of Say 를 그래프화 하면 아래와 같다. Total Eror 가 0에 가까울 수록 Amount of Say는 무한대에 수렴하고, 1에 가까울 수록 - 무한대에 수렴한다. 물론 그런 극단의 상황은 피하기 위해서 실제 application단에서는 보정을 위해 작은 error term 을 추가하여 사용한다.

정리하자면, Weight > 176 스텀프는 0.97의 Amount of Say를 갖는다.

만약 Weight가 아닌 Chest Pain 을 골랐다면 Total Error 가 $frac{3}{8}$ 이고, Amount of Say 는 아래와 같았을 것이다.

차이가 큰 것을 알 수 있다.

위 과정을 통해 잘못 분류된 샘플의 Sample Weight가 Amount of Say 에 얼마나 큰 영향을 끼치는지 이해했다.

Sample Weight 업데이트

이제 첫 Stump 분류를 통해 잘못 분류한 Sample의 Weight 를 업데이트 한다.

Sample의 Weight 을 업데이트 함으로써 다음 Stump를 위한 데이터 Sampling 과정에 영향을 끼친다.

그래프를 통해 알 수 있듯이, 기존의 Sample weight를 amount of say 값에 따라 update한다.

우리의 amount of say 는 0.97 이다.

$\frac{1}{8}$에 비해 크게 증가하였다.

해당 데이터 샘플의 weight 가 증가하였다면, 올바르게 분류하였던 샘플들의 weight는 작게 할 필요가 있다.

이번에는 Amount of Say의 - 값을 승으로 삼아 Weight를 더 작게 만든다.

이후 sample weight를 업데이트 하고, 총 합이 1이 되도록 Normalize한다.

다음 Stump 를 위해 데이터를 샘플링한다.

데이터 샘플링을 위해 0 ~ 1사이의 난수를 총 8번 뽑는다.

이 때 뽑은 8개의 난수를 아래의 기준에 맞춰 데이터 샘플링에 적용한다.

Weight 의 총합은 1이므로, 앞쪽부터 순서대로

0 ~ 0.07: 1번째 샘플

0.07 ~ 0.14: 2번째 샘플

...

0.21 ~ 0.7 : 4번째 샘플

...

0.93 ~ 1 : 8번째 샘플

데이터 샘플링 결과, weight가 높았던 4번째 sample 이 가장 많이 뽑힌 것을 확인할 수 있다.

이 후, Sample Weight 는 다시 초기화 된다.

하지만, 동일한 데이터가 4개나 있다보니 만약 이번에도 해당 데이터를 잘못 분류하게 되면 penalty가 굉장히 크다.

애초에 해당 데이터에 대해 gini index가 낮은 feature를 선택하다보니 웬만하면 분류가 잘 될 확률이 높다고 생각한다.

최종적으로 새로운 데이터가 들어오면 각 Stump들은 분류를 마친 후, 각 결과별로 Amount of Say를 총합하여 더 높은 쪽으로 결론을 내리게 된다.

약한 분류기를 직렬로 쌓는 강력한 모델 AdaBoost를 살펴보았다. 다만, 과정에서 살펴보았듯이 첫 노드가 제대로 예측하지 못했던 데이터 샘플에 치우치는 경향이 발생하기 쉬워보인다.

머신러닝 정리 4.5(2) - 앙상블이란?, Random Forests

알 수 없는 사용자 — Thu, 16 Feb 2023 17:58:51 +0900

앙상블

앙상블에 대한 General하고 Naive한 정의는 여러 약한 알고리즘의 힘을 합쳐서 하나의 강력한 의사결정을 하는 머신러닝 기법이다.

앙상블은 배깅, 부스팅, 보팅으로 나뉜다.

배깅 : 동일 알고리즘의 약 분류기를 병렬로 사용
부스팅 : 동일 알고리즘의 약 분류기를 직렬로 사용
보팅 : 다른 알고리즘의 약 분류기를 병렬로 사용

(분류기가 아니라 회귀문제일 수도 있다.)

분류문제에 입각하여 앙상블을 정의해보면 다음과 같다.

앙상블은 여러 개의 의사 결정 트리(Decision Tree)를 결합하여 하나의 결정 트리보다 더 좋은 성능을 내는 머신러닝 기법이다.

즉, 여러 개의 약 분류기(Weak Classifier)를 병렬 또는 직렬로 결합하여 강 분류기(Strong Classifier)로 만드는 것이다.

배깅(Bagging)

원본 데이터를 랜덤 샘플링(복원 추출)해, 크기가 동일한 n개의 샘플 데이터를 생성한다. 이 과정을 Bootstrapping이라 한다.
각 샘플 데이터를 기반으로 동일한 알고리즘 기반의 의사 결정 트리를 병렬적으로 학습한 뒤,
각 모델의 학습 결과를 결합하는 방식이다.
- 일반적으로 학습 결과를 결합할 때,
- 회귀 문제라면 평균(average),
- 분류 문제라면 다중 투표(majority vote)가 사용된다.
대표적인 배깅 모델로는 'Random Forest'가 있다.

Random Forest

랜덤 포레스트는 배깅의 일종이므로, 먼저 Bootstrapping을 수행한다.

원본 데이터를 랜덤 샘플링(복원 추출)해, 크기가 동일한 n개의 샘플 데이터를 생성한다. 이 과정을 Bootstrapping이라 한다.

약 분류기인 Decision Tree 를 생성하는 과정이 모델의 핵심 포인트이다.

기존 Decision Tree와 달리 모든 feature를 Tree 생성에 사용하지 않는다.

예를들어 feature이 약 30개 주어진다하면, Information Gain의 결과(거의 이것 때문) + Prunning 과정으로 인해 몇개의 강력한 feature만이 데이터를 분류하는데 적극적으로 활용된다.

강력한 feature외의 feature 들은 의사결정 과정에 직접적으로 거의 기여가 없게 된다.

이를 해결하기 위하여 각각의 약 분류기를 생성할 때 사용할 feature의 개수를 지정해놓고 feature를 random sampling하여 각각 다른 feature를 고려한 여러 약 분류기의 tree를 생성하여 의사결정 과정에 참여하도록 한다. (투표로 결정한다.)

여기까지가 Random Forest 개념의 골자였다면, 아래는 추가적인 사항이다.

- 흥미로운 점은 Bootstrapping 을 통해 각 tree의 학습 데이터셋을 만들게 되면 각각 random sampling과정에서 놓치게 되는 data가 존재하게 된다. 이를 Out of Bag Samples라 한다. Out of Bag samples은 tree 학습 과정에서 관측하지 못한 데이터이므로, 성능 점검에 적극적으로 활용할 수 있다. 또한 tree 들이 약간씩 다른 데이터셋으로 학습했다는 점에서 Overfitting도 어느정도 피하도록 돕는다.

- Out of Bag Samples로 Accuracy를 비교한다. 이후 가장 성능이 좋은 feature의 개수를 선택하기 위해 feature의 개수를 조정해가며 Out of Bag error가 가장 낮은 상황을 찾는다.

- 결측치가 존재하는 경우

위와 같이 Blocked Arteries, Weight 의 데이터가 결측된 결과표가 있다고 가정하자.

기본적으로 Random Forests는 결측치가 존재할 때, Weak Guess 를 한 후, Guess 를 강화하는 방식으로 접근한다.

첫 Guess는 Label 값을 기준으로, 동일 label을 가진 다른 데이터를 참고한다.

이에 따라 Blocked Arteries 는 "No", Weight 는 (125+210)/2 = 167.5로 Guess 한다.

Guess 를 Refine 하여 더 강력한 Guess 를 만들어보자.

Decision Tree로 분류한 결과 같은 leaf 노드에 떨어지는 데이터는 유사하다고 할 수 있다.

이러한 정보를 활용하여 Proximity Matrix 를 만들 수 있다.

데이터를 모든 Tree에 넣고 돌려보면서 나온 결과들을 matrix에 기입한다.

그 결과 다음과 같은 Proximity Matrix 를 얻을 수 있다.

Proximity Matrix를 Tree의 총 개수로 나누어 준다. (만약 모든 tree에서 동일한 결과를 얻은 두 데이터라면 matrix에는 1이 기입되게 된다.)

이제 이 정보를 활용하여 4번 데이터의 결측치를 업데이트 해보자.

4번 데이터는 1번 데이터와 0.1 , 2번 데이터와 0.1, 3번 데이터와 0.8의 관계가 있다.

결측치 Bolcked Arteries 에 대해 2번 데이터는 "YES"라 응답한다.

"YES" 는 3번 중 1번 등장했으므로, $\frac{1}{3}$ 이라 할 수 있다.

"YES" 의 weight는 $\frac{\textrm{2번 데이터의 proximity 값}}{\textrm{4번 데이터의 전체 proximity 합}}$ 으로 구할 수 있다.

결과는 위와 같이 나타난다.

동일한 방법으로 "NO"의 weight를 구하면 아래와 같고,

그 결과 NO 에 해당되는 cetainty 값은 0.6임을 알 수 있다.

이를 통해 4번 데이터의 Blocked Arteries 결측치는 "NO" 가 유지된다.

동일한 방법으로 Weight 결측치도 살펴보자.

continuous 한 값이니, 각 값에 weight 를 바로 곱해서 더해주면 된다.

이를 통해 4번 데이터의 Weight 결측치를 198.5로 업데이트한다.

이 과정을 몇번 반복하면 (5~6번), 각 결측치가 특정 값에 수렴하게 된다.

proximity matrix 는 활용도가 높다.

예를 들어 아래와 같은 proximity matrix 가 있다고 가정해보자.

1 - proximity values 의 결과 값을 각 데이터 샘플 간의 distance 라고 볼 수 있다.

이를 통해 히트맵이나 MDS plot 을 만들 수 있다. 즉, 샘플 들 간의 관계를 시각화하는 것이 간단하다.

trainig dataset이 아닌 input data에 결측치가 존재한다면 어떡해야 할까?

해당 환자는 Heart Disease 가 있을까 없을까?

먼저 두가지 경우를 모두 가정해보자.

이 후 iterate 과정을 통해 각각의 Blocked Arteries 를 채워보면 아래와 같이 된다.

그리고 그 결과를 통해 얻은 데이터 샘플들을 tree에 넣어보자.

각각의 데이터 샘플을 tree에 돌린 결과 label 이 옳게 나온 경우는 각각

Blocked Arterires "YES", Heart Disease "Yes" : 3번

Blocked Arterires "NO", Heart Disease "NO" : 1번 으로 3번이 더 많이 나왔다.

즉 최종 결과는 아래의 데이터 샘플을 선택한다.

Random Forest 는 결측지에도 강하고, Overfitting 에도 강한, 그리고 시각화도 가능한 강력한 머신러닝 Bagging 기법이다.

머신러닝 정리 4.5 -회귀 나무 (Regression Tree)

알 수 없는 사용자 — Wed, 15 Feb 2023 21:40:11 +0900

decision tree를 공부할 때 보통 이산형 데이터 즉 분류모델을 배운다.

그런데 decision tree는 연속형 데이터에도 사용가능하다.

그리고 코딩한줄이면 간단히 구현이 된다.

하지만 머리로 생각해봐도 어떤 식으로 짜여졌는지 감이 잘 안온다.

이에따라 간단히 정리해본다.

(https://www.youtube.com/watch?v=g9c66TUylZ4) 내용 기반

Linear Regression 으로 처리하기 어려운 경우 회귀 나무를 사용한다.

위와 같이 X의 범위로 간단하게 분류한 후, leaf node에는 해당되는 데이터들의 y 값의 평균을 기입한다.

위 과정을 반복하면, 쉽게 나눌 수 있다.

하지만 위와 같이 단순한 경우는 사실 그래프를 눈으로 보고 분류해도 된다. 회귀 나무가 필요 없다.

회귀 나무는 feature 개수가 1개보다 많을 때 진가가 드러난다.

여기서부터는 눈으로 구분하기 쉽지 않다.

반면 회귀 나무는 쉽게 분류할 수 있다.

회귀나무에 대해 알아봤으니, 이제 회귀나무를 만드는 법을 알아보자.

Root Node 는 어떻게 정할까?

예시를 통해 쉽게 접근해보자.

root node 의 기준을 Dosage < 3 으로 정한다고 가정해보자.

3 미만의 node 는 하나로 Average = 0 이다. 분류된 node의 개수가 적긴 하지만, 일단 잘 맞춘다.

하지만 3 초과의 node는 Aveage = 38.8 이다. 실제로 데이터를 살펴보면 상당 수의 데이터가 100% 이기도 하고, 0%이기도 하다.

38.8 이라는 수치는 전혀 데이터를 잘 설명하지 못한다.

위 차이를 시각적으로 표현하기 위하여 데이터로부터 평균 값에 점선을 그어보자.

이 점선을 Residual 이라 한다.

수치적으로 차이를 나타내려면 MSE 를 구하면 된다.

왼 오른 노드의 Residual을 모두 구하는 과정은 MSE 구하는 과정과 동일하다.

위 Residual 의 총 합은 37,468.5 로 계산되었다.

구한 값을 그래프에 표현해보자.

눈치가 빠른 분들은 위 그래프를 보고 Root Node를 결정하기 위한 과정이 interate 과정이라는 것을 알아챘을 것이다.

그 다음 Root Node 의 기준은 다음 두 데이터의 평균 값으로 결정한다.

위 과정으로 다시 분류한 후, residual 값을 계산한다.

위 과정을 반복하면 아래와 같이 그래프가 생기는 것을 알 수 있다.

이 때 Residual 이 가장 낮은 Dosage < 14.5 가 Root Node 가 된다.

Decision Tree에서 label 을 Root Node 로 사용했던 것과 사뭇 다르다.

그 이후 분류에서도 똑같이 Residual 을 구하면 된다.

분류 된 데이터가 1개일 때 leaf node 처리한다.

또한 Average = 0 으로 분류 된 데이터는 4개나 되지만 4개가 다 같은 값이므로 leaf node 처리한다.

다 좋은데 위에 처럼 하면 overfitting 될 가능성이 있다.

이럴 때는 분류할 때 최소 데이터 개수를 정하는 방법 등 다양한 방법이있다.

(보통 최소 데이터 개수 20개)

위 문제는 데이터가 애초에 개수가 적으므로 minimum 개수를 7개로 설정한다.

이 때 왼쪽 노드는 leaf 가 되고, 6개 데이터의 Average는 4.2% 가 된다.

오른 쪽은 데이터가 7개보다 많으므로 leaf 가 아니고 분류 node 가 된다.

반복하면 위와 같은 그래프가 결정된다.

당연히 분류의 기준 값은 residual 을 통해 찾는다.

feature가 Dosage 1개인 경우로 분류를 해보았다. feature 의 개수가 1개를 넘을 경우는 어떻게 될까?

먼저 Dosage의 residual 을 구해 가장 낮을 때의 threshold 를 후보로 한다.

다음은 Age로 동일하게 MSR(Minimum sum of residual)의 threshold를 후보로 한다.

Sex도 동일하게 threshold 후보를 찾는다.

이 중 가장 SSR이 낮은 Age를 첫번 째 cadidate로 한다.

그리고 나서 나무를 키워낸다.

※Age 로 분류한 후, 또 다시 분류할 때는 남은 Dosage 와 Sex 중에서 골라야 하는 것일까? Decision Tree는 애초에 한 feature로 discrete 하게 분류를 해버리고 나니 다음 분류 노드에서 사용했던 feature가 제외되지만, Regression Tree는 얼마든지 또 continuous 한 값을 사용할 수 있다. 논리적으로 생각해 봤을 때는 만약 Age feature가 또다시 SSR이 낮으면 선택될 것 같다.

Regression Tree는 딱 봐도 굉장히 오래 걸릴 것 같다. 하지만 굉장히 직관적이다.

NLP 총 정리 글

알 수 없는 사용자 — Thu, 29 Dec 2022 15:13:57 +0900

https://blog.naver.com/ha_junv

까먹을때 빨리 기억나려고 작성하는 블로그 : 네이버 블로그

자기소개가 없습니다.

blog.naver.com

NLP 는 네이버 블로그에서 정리했었다.

글을 티스토리로 옮기기가 용이하지 않아 링크

초평면이 법선벡터의 곱셈인 이유

알 수 없는 사용자 — Thu, 10 Nov 2022 16:51:43 +0900

초평면을 구하기 위해서는 단순히 법선 벡터와 한 점만 알면 된다.

그리고 w를 법선 벡터라 할 때,

$\vec{w} \cdot \vec{x} + b = 0$

라는 공식이 주어진다.

문제는 위 공식이 어떻게 유도된 것인지 감이 안온다. 인터넷을 찾아봐도 관련 자료가 생각보다 정말 없다.

이에 따라 유도 과정을 정리해본다.

$y = (x, y)$ in $R^2$

직선의 방정식 general form

$ax + by + d = 0$

우리에게 익숙한 형태

$y = -\frac{a}{b}x - \frac{d}{b}$

$x = t , -\infty < t < \infty$

$\textrm{since, } y = \vec{p} = \vec{a} + t\vec{u}$

$y = (x,y) = (x_1, y_1) + t(u_1, u_2) = (x_1 + tu_1, y_1+tu_2)$

$y = (x,y) = \bigg( t, -\frac{a}{b}t - \frac{d}{b} \bigg) = t \bigg( 1, -\frac{a}{b} \bigg) +\bigg( 0, -\frac{d}{b}\bigg)$

해당 선은 $(1, -\frac{a}{b})$ 방향으로 하여 $(0 , -\frac{d}{b})$ 를 통과한다.

$\vec{n} \cdot y + d = 0$

$\vec{n} \cdot p + d = 0$

since $d = -\vec{n} \cdot p$

$\vec{n} \cdot y - \vec{n} \cdot p = 0$

$\vec{n} \cdot(y-p) $ 이 식은 이 글에서 성립함을 확인했다. 점 - 점 = 벡터, 벡터 $\cdot$ 법선벡터 = 0

즉 d 는 $- n \cdot p$ 이다.

사실 이는 이 글 에서 확인한 직선의 방정식을 아핀 공간에서 구하는 형태와 동일하다.

법선벡터를 이용한 직선의 방정식

알 수 없는 사용자 — Wed, 9 Nov 2022 20:27:54 +0900

점 $A(x_1, y_1)$를 지나고 법선벡터가 $\vec{n} = (n_1, n_2)$인 직선의 방정식은

$n_1(x- x_1) + n_2(y-y_1) = 0$

법선 벡터는 내적하면 0 이라는 특성을 이용한 공식이다.

점 - 점 = 벡터 성질을 활용하여

(점 - 점) $\cdot$ 법선 벡터 = 0

로 구했다.

※ 2개의 점을 알아도 직선을 구할 수 있다.

$a_1 x_1 + a_2 x_2 = b$

$Ax = b$

$Ax - b = 0$

초평면

알 수 없는 사용자 — Tue, 8 Nov 2022 20:44:16 +0900

초평면

초평면 $1 + 2X_1 + 3X_2 = 0$. $1 + 2X_1 = 3X_2 > 0$은 파란 점이 모인 파란 공간이고 $1+2X_1+3X_2 < 0$ 은 보라색 점이 모인 보라색 공간이다.

p차원 공간에서, 초평면은 p-1 차원인 평평한 아핀 부분 공간이다. 아핀공간에 대한 사전지식이 없는 분은 글을 읽고 오면 좋다.

예를 들어, 2차원 공간에서 초평면은 평평한 1차원 부분공간으로 선이다. 3차원 초평면은 평평한 2차원 부분공간이며 이는 평면이다. p>3 인 경우에는 초평면을 시각화하기 어렵지만 p-1 차원인 평평한 부분 공간인 것은 여전히 유효하다.

2차원에서 초평면의 수학적인 정의는 다음의 방정식으로 정의한다.

$$\beta_0 + \beta_1 X_1 + \beta_2 X_2 = 0$$

2차원의 초평면은 1차원 선이다. 2차원 파라미터 $\beta_0, \beta_1, \beta_2$ 가 존재하며, $X_1, X_2$ 는 초평면 상 임의의 점이다.

위 식은 임의의 p차원으로 확장 할 수 있다. 즉 p차원에 대한 초평면은 아래의 식으로 정의한다.

$$\beta_0 + \beta_1 X_1 + \beta_2 X_2 + ... +\beta_p X_p= 0$$

p차원 공간의 점 $X_1 X_p$가 위 식을 만족하면 X는 초평면 상에 있다.

X가 아래 식을 만족하면 X는 초평면의 한쪽에 놓인 다는 것을 의미한다.

$$\beta_0 + \beta_1 X_1 + \beta_2 X_2 + ... +\beta_p X_p > 0$$

반면 아래 식을 만족하면 X는 초평면의 다른 한쪽에 놓인다.

$$\beta_0 + \beta_1 X_1 + \beta_2 X_2 + ... +\beta_p X_p < 0$$

따라서 초평면은 p차원 공간을 두개로 분할한다고 생각할 수 있다. X가 분리된 두 공간 중 어느 부분에 속하는지 판별하려면 초평면 식에 X를 대힙하여 0보다 큰지 작은지 확인하면 된다.

분리 초평면을 이용한 분류 (Classification Using a Separating Hyperplane)

$p$차원 공간에서 $n$개의 학습 관측값들로 구성된 $n \times p$ 크기의 행렬 $X$가 있다고 가정해보자. 그리고 이 관측값들은 두 개의 class에 속한다. $y_1 \sim y_n$이 -1 또는 1 이다. 목적은학습 셋에 기반한 test observation을 정확하게 분류하는 분류기를 만드는 것이다. 이 분류기를 분리 초평면의 개념으로 만든다.

보라 점과 파란 점을 나누는 여러개의 초평면 후보군이 검은 선으로 표기되어 있다.

Training observation이 정답 class label에 해당하도록 완벽하게 분리하는 초평면을 정의할 수 있다고 가정해보자. 위 그림에서 왼쪽 그림은 3개의 분리 초평면 예이다. 분리 초평면을 정의하고 식에 X를 대입했을 때, 0보다 큰지 작은지 판별하여 class를 할당할 수 있다.

$$\beta_0 + \beta_1 x_i1 + \beta_2 x_i2 + ... +\beta_p x_ip > 0 \textrm{ if } y_i = 1,$$

$$\beta_0 + \beta_1 x_i1 + \beta_2 x_i2 + ... +\beta_p x_ip < 0 \textrm{ if } y_i = -1,$$

이를 다르게 표현하면 분리 초평면은 모든 관측값에 대하여 아래의 식을 만족한다.

$$y_i(\beta_0 + \beta_1 x_i1 + \beta_2 x_i2 + ... +\beta_p x_ip) > 0$$

분리 초평면이 존재한다면 이것을 사용하여 자연스러운 분류기를 구성할 수 있다. test observation이 초평면의 어느 면에 위치해있는지에 따라 class를 부여하면 된다. 예를 들어 f(x)가 양수이면 x는 1에 할당, 음수이면 x = -1 에 할당한다.

f(x)의 크기도 활용하여 f(x)가 0과 멀면 x는 초평면과 많이 떨어져 있고 class를 신뢰할 수 있다. 하지만 초평면과 가까우면 클래스에 대한 확신이 덜하다.

벡터의 외적

알 수 없는 사용자 — Fri, 4 Nov 2022 20:03:25 +0900

벡터의 외적

평행하지 않은 두 벡터가 있다고 가정하자.

두 벡터에게 동시에 수직인 벡터를 구하고 싶으면 어떻게 해야할까?

$\vec{a}, \vec{b}$ 두 벡터가 만드는 평면이 있을텐데, 그 평면 위에서는 두 벡터에 동시에 수직인 벡터를 찾을 수 없다.

이에 따라 벡터의 외적은 기본적으로 3차원 공간에서 생각해야 한다.

$\vec{a}, \vec{b}$ 에 동시에 수직인 벡터 $\vec{P}$ 가 있다고 하자.

해당 $\vec{P}$ 를 쉽게 찾을 수 있는 방법을 찾아보자.

각 벡터를 성분으로 표현하고, 수직인 두 벡터를 내적하면 0이라는 성질을 사용해보자.

$$a_1x + a_2y + a_3z = 0$$

$$b_1x + b_2y + b_3z = 0$$

이 두 식을 동시에 만족시키는 $(x,y,z)$ 를 구하면 $\vec{P}$ 의 성분이다.

$z$ 성분을 없애기 위하여 아래의 작업을 한다.

$$a_1 b_3x + a_2 b_3y + a_3 b_3z = 0 - (1)$$

$$a_3b_1x + a_3b_2y + a_3b_3z = 0 - (2)$$

$(1) - (2) = (a_1b_3 - a_3b_1)x + (a_2b_3 - a_3b_2)y = 0$

만약 $x = a_2b_3 - a_3b_2$ 이고 $y = -(a_1b_3 - a_3b_1)$ 이면 자연스럽게 결과가 성립한다.

이 결과 $z = a_1b_2 - a_2b_1$ 로 얻을 수 있다.

즉, (1), (2) 번식에 모두 성립하는 x,y,z 를 찾을 수 있었고 $\vec{P}$ 는 $\vec{a}$ 와 $\vec{b}$ 모두와 수직임을 알게되었다.

$$ \vec{a} \times \vec{b} = (a_1, a_2, a_3) \times (b_1, b_2, b_3)$$

$$ = (a_2b_3 - a_3b_2, a_1b_3 - a_3b_1, a_1b_2 - a_2b_1)$$

벡터의 외적은 위에서 유도한 것이라고 생각하면 된다.

공식을 암기하지말고 다음과 같이 간단하게 계산하자.

먼저 성분을 모두 작성한 후, $a_1, b_1$ 을 지운다. 그 다음 성분끼리 X 자로 각 곱한 값들을 빼준다. ($a_2b_3 - a_3b_2$)

벡터의 외적은 내적과 달리 결과값도 벡터이다.

다만 벡터의 외적은 다음과 같이 방향이 반대인 경우도 당연히 있을 것이다. 이 때, 외적 결과값 벡터의 방향을 어떻게 알 수 있을까?

크기가 1 이다 보니 딱 떨어지는 결과가 나왔지만, 두벡터의 외적이 다른 한 벡터의 방향과 동일해진다는 것만을 확인 할 수 있다.

방향을 구할 때는 오른 손의 법칙을 기억하자!

$$ \vec{a} \times \vec{b} = (a_2 b_3 - a_3 b_2, a_1 b_3 - a_3 b_1, a_1 b_2 - a_2 b_1)$$

외적의 크기는 아래와 같다.

$$| \vec{a} \times \vec{b}|^2 = (a_2b_3)^2 + (a_3b_2)^2 - 2a_2a_3b_2b_3 $$

$$ + (a_3b_1)^2 + (a_1b_3)^2 - 2a_1a_3b_1b_3$$

$$ + (a_1b_2)^2 + (a_2b_1)^2 - 2a_1a_2b_1b_2$$

여기에 $(a_1 b_1)^2 + (a_2 b_2)^2 + (a_3 b_3)^2, - (a_1 b_1)^2 - (a_2 b_2)^2 - (a_3 b_3)^2$ 를 더해준다. (합쳐서 0)

그 후 다시 정리를 해주면

※ $\bigg( (\vec{a} \cdot \vec{b})^2 = |\vec{a}|^2|\vec{b}|^2 \cdot \cos^2\theta \bigg)$

$$= (a_1^2+a_2^2+a_3^2)b_3^2 + (a_1^2+a_2^2+a_3^2)b_2^2 + (a_1^2+a_2^2+a_3^2)b_1^2 - (a_1 b_1 + a_2 b_2 + a_3 b_3)^2$$

$$= (a_1^2+a_2^2+a_3^2)(b_1^2+b_2^2+b_3^3) - (a_1b_1 + a_2b_2 + a_3b_3)^2$$

$$= |\vec{a}|^2 \times |\vec{b}|^2 - (\vec{a} \cdot \vec{b})^2$$

$$= |\vec{a}|^2 \times |\vec{b}|^2 \, (1 - cos^2 \theta)$$

$$|\vec{a} \times \vec{b}|^2 = |\vec{a}|^2 \times |\vec{b}|^2 \, (sin^2 \theta)$$

$$(0 \leq \theta \leq \pi) \,\,\, sin \theta \textrm{ 가 양수임을 확인}$$

$$|\vec{a} \times \vec{b}|= |\vec{a}| \times |\vec{b}| \, (sin \theta)$$

벡터의 외적의 성질

1. $(\vec{a} \times \vec{b}) \cdot \vec{a} = 0$ , $(\vec{a} \times \vec{b}) \cdot \vec{b} = 0$

2. $\vec{b} \times \vec{a} = - (\vec{a} \times \vec{b})$

크기는 동일하나 방향이 반대이다.

3. $\vec{a} \times \vec{a} = \vec{0}$

외적의 크기를 구할 때 $\sin \theta(0) = 0$ 이므로

평행한 벡터들도 마찬가지다.

4. $\vec{a} \times \vec{b} = \bigg( |\vec{a}| |\vec{b}| \sin \theta \bigg) \vec{n}$

외적은 평행사변형의 넓이

출처:

해당 글의 내용은 유튜브 수악중독님의 내용을 재편집 한 포스트입니다.

https://www.youtube.com/watch?v=nxiVG22BaZk

https://www.youtube.com/watch?v=PReXlXpEdoM

아핀 공간

알 수 없는 사용자 — Fri, 4 Nov 2022 11:31:50 +0900

들어가며

벡터는 위치를 가지지 않는다.

위치와 상관 없이 동일한 크기와 방향을 가지는 벡터는 같다.

즉, 기하학에서 벡터는 '방향'과 '변화' 두가지 의미로 사용될 수 있다.

벡터의 덧셈 뺄셈

화살표의 방향을 유의해서 보자

벡터의 덧셈의 대수학적 법칙은 실수의 덧셈과 유사하다. 이는 위치를 갖지 않는다는 특성으로 인한다.

1. v + w = w + v (교환법칙)

2. u + (v+w) = (u+v) +w (결합법칙)

3. v + 0 = v (덧셈의 항등원)

4. 모든 v에 대해 v+(-v) = 0 을 만족하는 벡터 -v 가 존재한다. (덧셈의 역원)

뺄셈의 결과 벡터는 두번째 벡터의 머리에서 첫번째 벡터의 머리로 이어진다.

※ 아핀 공간:

한 6년전 그래픽스 논문을 읽다가 도대체 아핀 공간이 무엇인가! 하고 찾아봤던 기억이 있다. 당시에는 지금처럼 한국에 좋은 자료가 많지 않아서 아핀 공간을 잘 이해하기가 어려웠는데, 요새는 좋은 자료가 많다.

일반적으로 유클리드 공간은 아핀 공간이지만 벡터 공간이라고도 한다.

아핀 공간의 정의 자체가 벡터공간을 필요로하기 때문이다.

아핀 공간으로 벡터 공간을 형성할 수 있다고 알고 이해하면 된다고 한다.

일반적으로 직교좌표계에서 점은 원점으로부터 각 축에 대해서 얼만큼 떨어져 있는가 표현된다.

이렇게 정의된 점이 아핀 공간에 있다고 한다.

아핀 공간을 벡터공간이라고만 알기보다는 좀 더 정확히 정의해보자.

V라는 벡터 공간이 있을 때, 이 V 위에서 아핀 공간은 A라는 점들의 집합으로 정의된다.

※ 벡터 공간과 아핀 공간에 대한 직관적인 차이점

https://gyong0.tistory.com/68

아핀 공간과 벡터 공간의 차이점

아핀 공간과 벡터 공간의 차이점은 무엇일까? 먼저 벡터를 표현할 때는 기본 과정이 존재한다. 벡터는 그림 1과 같이 원점을 기준으로 방향과 크기를 나타낸 것이다. 하지만 그림 2에서는 원점에

gyong0.tistory.com

$$A \times V \rightarrow A$$

$$P,v | \rightarrow P+v$$

($P$는 $A$ 공간의 점, $v$는 $V$에 속한 임의의 벡터)

$V$와 $A$ 사이에는 위 2가지 두 대응이 존재한다고 한다.

※ 점과 벡터가 + 연산이 되는이유

$P$(점)에서 $v$(벡터)를 더해서 $Q$(점)이 나오는 것

$$P = (p_x, p_y, p_z)$$

$$v = (v_x, v_y, v_z)$$

$$Q = P + v $$

$$ = (p_x, p_y, p_z) + (v_x, v_y, v_z)$$

$$= (p_x + v_x, p_y + v_y, p_z + v_z)$$

즉, 아핀 공간에서 덧셈 연산을 할 때는

벡터와 벡터의 연산인지, 점과 벡터의 연산인지에 유의해서 정확하게 봐야한다.

또한 3가지 성질이 있다.

1. $A$에 속한 모든 점 $P$에 대해서 $P + \vec{0} = P$ 이다. 영 벡터$(\vec{0})$는 벡터 공간 $V$의 항등원이다.

2. $A$에 속한 모든 점 $P$와 $V$에 속한 임의의 벡터 $v,w$에 대해 $P + (v + w) = (P+v)+w$ 가 성립한다.

3. $A$에 속한 점 $P,Q$가 있을 때 $P + v = Q$를 만족하는 단 하나의 벡터 $v$가 존재한다.

3번이 좀 헷갈리니 살펴보자. 점 2개를 찍어놓고 두 점 사이에 존재하는 벡터는 하나라는 것을 쉽게 확인할 수 있다. (방향 크기 동일)

즉 이에 따라 $Q-P = v$ 점 $Q$ 에서 점 $P$를 빼면 벡터 $v$를 얻는다는 것을 알 수 있다.

벡터와 벡터의 연산은 벡터

벡터와 점의 연산 점

점과 점의 뺄셈 연산 벡터

위의 조건을 만족하는 공간이 바로 아핀 공간이다.

점 다음으로 선을 살펴보자.

2차원에서 선을 표현하는 것은 가능하지만, 3차원에서 선을 표현하는 것이 불가능하다.

실제로 불가능하다기 보다는 $ax + by + c = 0$ 형태로 표현이 불가능하다.

성분이 늘어나기에 사실상 평면의 방정식이 되어버린다.

이에 따라 3차원에서는 매개변수 방정식(parameteric equation)을 통해 선을 표현한다.

어떤 방향벡터와 점이 선을 표현할 수 있게 된다.

위 방향벡터는 점과 점을 뺀 결과이다.

t는 음의 무한대~ 양의 무한대의 실수 범위를 가지고 있다.

$$L(t) = P + t \cdot v $$

$$= P + t \cdot(Q - P)$$

$$= P + t \cdot Q - t\cdot P$$

$$= (1-t) \cdot P - t \cdot Q$$

위와 같이 직선을 표현하는 과정에서 $(1-t)$ 와 $t$ 를 주목하며 봐보자.

점에다가 스칼라를 곱하고 이를 더한다.

아핀 공간에서 점과 점의 덧셈은 안되는 줄만 알았는데 벡터 공간의 선형 조합처럼 아핀 조합이라는 것이 존재한다.

※ 벡터공간의 선형 조합

$ <v_1, ... v_n> = \{ a_1 v_1 + ... + a_n v_n | a_i \in F \}$

벡터들에 스칼라배를 해서 더함으로서 수많은 벡터를 만들 수 있고, 이를 통해 공간 자체를 span 할 수 있다는 뜻

선형 조합들이 벡터들에게 임의의 스칼라 값을 곱해서 새로운 벡터를 만든다면,

아핀 조합은 점들에게 특정 조건을 만족하는 스칼라 값을 곱해서 더하면 새로운 점이 나온다.

다만, 벡터는 임의의 스칼라지만, 점은 특정 스칼라의 곱이다.

아핀 조합은 점과 벡터의 덧셈연산에서 나온다.

점에다 벡터를 더하면 아래와 같다.

$$P = P_0 + v $$

$$P = P_0 + (a_1 \cdot v_1 + ... + a_n \cdot v_n)$$

쉽게 생각하기 위해서

P0가 중심이라고 생각하면

$v_1 \sim v_n$ 은 기저벡터라고 볼 수 있다.

그리고 기저벡터는 다시 아래와 같이 다르게 표현할 수 있다.

점 - 점 = 벡터

$$v_1 = P_1 - P_0$$

$$v_1 = P_2 - P_0$$

$$v_1 = P_3 - P_0$$

$$\cdots$$

$$v_i = P_i - P_0$$

위 결과를 통해 아래와 같이 정리할 수 있다.

$$P = P_0 + (a_1 \cdot v_1 + \cdots + a_n \cdot v_n)$$

$$P = P_0 + a_1 \cdot (P_1 - P_0) + a_2 \cdot (P_2 - P_0) + \cdots + a_n \cdot (P_n - P_0)$$

$$P = (1 - a_1 - a_2 - a_3 - \cdots - a_n) \cdot P_0 + a_1 \cdot P_1 + a_2 \cdot P_2 + \cdots + a_n \cdot P_n$$

위 식이 바로 새로운 점을 만드는 아핀 조합이다.

각 스칼라값만 뽑아보면 아래와 같이 된다.

$$(1 - a_1 - a_2 - a_3 - \cdots - a_n) + a_1 + a_2 + a_3 + \cdots a_n = 1$$

아핀 조합의 스칼라 조건

모든 점에 대해서 스칼라 값의 합이 1이 된다.

기저벡터들의 조합으로 벡터공간이 형성되듯이 $P_0 ~ P_n$ 점들의 조합으로 아핀 공간이 생긴다.

아핀 조합에 참여한 점들은 임의의 점이 아니라 서로 아핀 독립(affinely independent)하다.

아핀 독립이란 쉽게 말해서 점 집합에서 임의의 한 점이 나머지 점들을 아무리 아핀 조합을 한들 만들어질 수 없다는 것을 의미한다.

(기저벡터와 유사 y 와 x 벡터를 아무리 조합해도 x 벡터를 만들 수는 없다. )

각 점들이 아핀독립인지 확인하는 방법은 벡터를 이용하는 방법이다.

정렬된 점들이 서로에게 아핀 독립이면 이 점들을 차례대로 두 개씩 골라서 만들어지는 벡터 또한 선형 독립이 되는 것을 이용한다.

이 벡터들이 한 벡터 공간의 기저 벡터가 된다는 점을 이용하는 것이다.

아핀 독립인 점들의 집합을 단체, simplex 라고 하고, 아핀 조합에 등장하는 스칼라값들을 아핀 조합으로 생성되는 점의 무게중심좌표, barycecntric coordinate이라고 한다.

위에서 살펴보았던 매개변수 방정식은 아핀 조합임을 알 수 있다.

$$L(t) = P + t \cdot v $$

$$= P + t \cdot(Q - P)$$

$$= P + t \cdot Q - t\cdot P$$

$$= (1-t) \cdot P - t \cdot Q$$

PQ 벡터는 유일한 기저벡터가 된다.

이 아핀 조합은 1차원 아핀 공간을 생성하고 이것이 바로 선이 되는 것이다.

직선이 아니라 선분을 표현하고 싶다면 t 값의 범위를 정해주면 선분이 된다.

예를 들어 t = [0, 1] 범위라면 P 와 Q를 잇는 선분이 만들어질 것이다.

점, 선 다음으로 면을 알아보자.

선을 만들 때 두점의 아핀 조합을 통해 만들었다.

면을 만들 때는 세점의 아핀 조합을 통해서 만든다.

면도 매개변수 방정식으로 표현된다.

한 평면에 점 3개 A,B,C 가 있다면 아래와 같이 표현할 수 있다.

$$P(s,t) = (1 - s - t) \cdot A + s \cdot B + t \cdot C$$

$$= A + s \cdot (B - A) + t \cdot (C - A)$$

$$= A + s \cdot u + t \cdot v$$ (햇갈리니 벡터는 벡터표시를 해주자)

$$= A + s \cdot \vec{u} + t \cdot \vec{v}$$

점과 점의 뺄샘 계산으로 벡터를 만들어서 점 하나와 2개의 벡터 계산으로 바꿀 수 있다.

3차원 공간에서 선을 표현할 때는 매개변수 방정식으로 많이 표현하지만,

3차원 공간에서 면을 표현할 때는 매개변수 방정식과 함께 일반화 표현을 많이 사용한다.

(3D 게임에서 평면을 다룰 때는 매개변수보다 일반화 방정식이 더 이해하기 수월하다.)

고등학교에서는 한 점과 법선벡터가 주어졌을 때 평면을 모두 만들 수 있다고 배웠다.

한 점 : P, 법선벡터: n

$$P = (p_x, p_y, p_z)$$

$$n = (a,b,c)$$

임의의 평면의 점 Q에 대해서 성립해야 그것이 평면이다.

$$Q = (x,y,z)$$

$$v = Q - P$$

$$v = (x - p_x, y - p_y, z - p_z)$$

어떤 Q를 잡아도 그 벡터와 법선벡터를 내적하면 0이 나와야 한다.

$n \cdot v = 0$

$(a,b,c) \cdot (x - p_x, y - p_y, z - p_z) = 0$

$a \cdot (x - p_x) + b \cdot (y - p_y) + c \cdot (z - p_z)$

$a \cdot x + b \cdot y + c \cdot z - (a \cdot p_x + b \cdot p_y + c \cdot p_z) = 0$

$a \cdot x + b \cdot y + c \cdot z - n \cdot P = 0$

우리가 알던 평면의 방정식을 얻게 된다.

매개변수가 기하학적으로 해석이 되었다.

여기서 n 과 p 의 내적을 d 로만 고치면 우리가 알던 평면의 방정식을 얻는다.

$$ax + by + cz + d = 0$$

법선 벡터는 단위벡터인게 좋다. 점과 평면 직선거리를 쉽게 구할 수 있기 때문이다.

(정규화 시키려면 크기로 나누면 된다. 나머지 성분들도 변한다는 것 유의 )

평소에 한점과 법선 벡터로 평면의 방정식을 구했다.

그렇다면 세 점으로는 어떻게 평면을 구하는지 알아보자.

간단하게 설명하면 세점으로 2개의 벡터를 만들고 외적을 하면 법선벡터가 나올 것이다.

또 나머지 한점으로 위 과정을 반복하면 된다.

$$v = Q - P$$

$$w = R - P$$

$$n = v \times w = (a,b,c)$$

$$d = -n \cdot P$$

하지만 여기서 법선 벡터가 2개를 얻을 수 있다.

앞으로 나올지, 뒤로 나올지는 외적의 계산 순서에 따른다.

다만, 공간의 임의의 점이 평면의 앞에 있는지 뒤에 있는지를 평면의 방향 기준으로 정하기 때문에 평면의 방향을 중요한 의미가 있다.

다음과 같이 6개의 평면이 닫힌 공간이 있을 때, 법선 벡터의 방향에 따라 겉과 안을 구분하게 된다.

대입을 해보면 수식적으로 앞인지 뒤인지 알수 있다.

$$ax + by + cz + d$$

계산해서 양수가 나오면 앞에 있고

음수가 나오면 뒤에 있다.

당연히 0이 나오면 평면 상에 있다.

매개변수가 아니라 일반화 방정식을 쓰는 이유가 바로 대입하면 어디 있는지 바로 확인할 수 있기 때문이다.

법선 벡터가 단위벡터라면 그 점을 대입한 값에 절대값을 취하면 바로 그 점과 평면 사이의 거리가 된다. (아니면 법선 벡터의 크기만큼 나눠주면 된다.)

임의의 점이 주어졌을 때 같은 평면 상에 존재하는지 구별하는 법을 알았으니 여기서 그만 멈추도록 하자.

점 A, B , C ,D 가 주어졌을 때, 각 점을 이용하여 벡터를 만든다.

$$ u = B - A$$

$$ b = C - A$$

$$ w = D - A$$

4 점이 다 같은 평면상에 있다면 3 개 중 2개의 벡터는 외적하고 그 결과를 나머지 남은 벡터와 내적해서 0이 나오면 그 3개의 벡터는 동일 평면 상에 존재한다고 말 할 수 있다.

벡터의 외적

마지막으로, 컴퓨터 그래픽스에 많이 사용되는 삼각형에 대해 공부해보자.

아래를 읽기 전에 이 글을 읽고 오면 배경 설정에 도움이 된다.

https://math-development-geometry.tistory.com/44

평면(Plane) 에 대한 이야기

기하학에서 평면은 매우 중요한 요소입니다. 점, 선, 면과 같이 각 차원에서 기본적인 요소가 되는 것들이죠. 이중에서 평면에 대해 이야기를 하도록 하겠습니다. 평면은 평평한 면으로 곡률이

math-development-geometry.tistory.com

사각형은 삼각형 두개로 표현된다. 가장 작은 도형이 삼각형이고, 삼각형 보다 꼭지점이 많은 도형들은 3각형으로 모두 쪼갤 수 있다.

또한 삼각형은 세점이 항상 동일 평면 위에 존재할 수 있는 유일한 도형이다.

(마치 삼각대의 다리 3개가 평면을 만들어 중심을 잡는 것과 같은 맥락이다.)

삼각형에 색을 칠하면 그제서야 우리는 볼 수 있다.

아래 모델을 살펴보자.

선들로 닫혀진 공간이 바로 삼각형이 된다. (주로 polygon 이라 부른다.)

이 폴리곤을 이루는 점을 vertex, 삼각형은 볼록다각형, convex polygon 이라 한다.

※ 볼록 다각형

1. 이어진 두 선분이 이루는 각이 180도 보다는 작거나 같다.

2. 임의의 두 꼭지점을 이은 선은 다각형의 내부에 있거나 다각형을 이루는 선 중에 하나다.

저번에도 평면의 앞 뒤 여부가 중요했듯이,

삼각형도 특정 점이 삼각형 내부에 있는지 외부에 있는지가 중요하다.

A,B,C는 삼각형의 점이고 삼각형 안에 점 D가 있다고 가정하자.

동일 평면상에 있는지는 위에서 4개의 점에 대해 확인하는 법을 배웠다.

다음의 4점으로부터 다시 벡터 6개가 정의된다.

D 중심

$$u_1 = D - A$$

$$u_2 = D - B$$

$$u_3 = D - C$$

반시계 방향

$$v_1 = B - A$$

$$v_2 = C - B$$

$$v_3 = A - C$$

아래는 외적의 결과이다.

$$w_1 = u_1 \times v_1$$

$$w_2 = u_2 \times v_2$$

$$w_3 = u_3 \times v_3$$

만약 점 D 가 삼각형 안에 있다면 외적한 결과값 $w_1, w_2, w_3$ 가 같아진다.

모두 시계방향의 외적 순서이다.

하지만 점 D 가 삼각형 밖에 있다면 외적한 결과값 중 한 벡터의 방향이 반대로 된다.

위 설명은 아래 글로 대체

https://hwanggoon.tistory.com/114

삼각형 안에 점이 있는지 확인하는 방법

삼각형 안에 점이 있는지 확인하는 방법 삼각메쉬 안에 버텍스가 포함되어 있는지는 외적과 내적을 이용하면 확인 할 수 있습니다. 다음 삼각 메쉬에 파란색 점이 밖에 있습니다. ab = A점에서 B

hwanggoon.tistory.com

(외적한 결과는 외적하는 순서에 따라 결정된다. 오른손의 법칙 기억)

외적이 기억나지 않는다면 해당 글을 참고하자.

외적한 결과가 달라지므로 구분할 수가 있게 된다.

즉 아래 조건을 만족하면 벡터의 방향이 모두 같으므로 삼각형 안에 점이 존재한다.

$$w_1 \cdot w_2 > 0$$

$$w_2 \cdot w_3 > 0$$

$$w_3 \cdot w_1 > 0$$

면을 표현할 때는 일반방정식이 더 편리했지만, 삼각형 내부범위 조사는 매개변수가 더 편리하다.

세점으로 식을 유도하자.

$$P(s,t) = (1 - s - t) \cdot A + s \cdot B + t \cdot C$$

$$= A + s \cdot (B - A) + t \cdot (C - A)$$

$$= A + s \cdot u + t \cdot v$$ (햇갈리니 벡터는 벡터표시를 해주자)

$$= A + s \cdot \vec{u} + t \cdot \vec{v}$$

직선의 방정식을 매개변수에 범위를 주어 선분으로 만들거나 했던 것을 생각하자.

즉, 면의 방정식도 매개변수에 범위를 주어 삼각형으로 만들 수 있다는 것이다.

s+t < 1 의 조건을 만족하면 점 A, B ,C 가 이루는 삼각형이 되고

삼각형 안의 모든 점들을 점 A 와 어떤 벡터와의 합으로 표현된다면

그 벡터는 s = B - A, t = C - A 벡터가 된다. (기저벡터 $\rightarrow$ 아핀조합)

즉 D 가 삼각형 안에 점이 있으면

점 D 를 표현했을 때가 A 와 기저벡터의 덧셈이다.

s+t 의 합이 1보다 작게 나올 것이다.

$$D = A + s \cdot + t \cdot v$$

$$D - A = s \cdot u + t \cdot v$$

$$w = s \cdot u + t \cdot v$$

하지만 s,t 를 구하는 것은 쉽지 않다.

때문에 식에 각각 u 와 v 벡터를 내적한다.

s,t 에 대해서 정리하면 이렇게 나온다.

해당 글의 출처:

https://luv-n-interest.tistory.com/807

아핀 공간, Affine Space - 2 [게임수학]

저번 시간에는 선을 배웠으니 이제 면을 배워볼 시간이다. 선을 만들 때 두 점의 아핀 조합을 통해 만들었다. 면을 만들 때는 세 점의 아핀 조합을 통해서 만든다. 알아보자 면도 매개변수 방정

luv-n-interest.tistory.com

아래 블로그를 이해하며 적었습니다.

머신러닝 정리 9 - Naive Bayes vs Logistic Regression

알 수 없는 사용자 — Wed, 2 Nov 2022 10:43:40 +0900

들어가며

머신러닝에서 learning 이란?

parameter inference, 즉 파라미터를 특정 데이터에 맞춰 최적화

강한 hypothesis 를 기준으로 참과 거짓, rank, category, 군집 등을 결정하는 등의 목적이 있는데, 이를 위하여 데이터 셋을 기준으로 특정 모델의 parameter 조정한다. (다시 말하면 모델이 정해져있기 때문에 우리가 조정할 수 있는 건 parameter 밖에 없다.)

logistic regression 에서 probability likelihood 를 최대한 높히기 위하여 gradient ascent 를 통해 $\theta$ 를 업데이트 하여 $P(Y|X)$ 계산식이 도출되었기 때문에 learning 이 되었다.

이번 글에서는 Naive Bayes의 개념을 점검할 겸, Logistic Regression 과의 관계를 확인해보려고 한다.

Gussian Naive Bayes

Naive Bayes 는 그냥 사용하면 logistic regression 과 비교할 수 없다.

Naive Bayes 는 categorical input을 받는다. (해당 input은 0,1 로 정의를 했었다.)

반면, logistic regression 은 housing information 을 사용했었기에 numerical variable 이 많았다.

그렇기 때문에 Naive Bayes 를 continuous features 를 활용하는 방식으로 수정한다.

Naive Bayes Classifier

$f_{NB}(x) = argmax_{Y=y} P(Y=y)\prod_{1 \leq i \leq d} P(X_i = x_i | Y = y)$

(d 는 Input feature 개수)

Continuous random feature

일단 어떤 분포를 따를지를 결정해야 한다. (ex. Poisson ...)
$X_i | Y$가 Gaussian distribution 을 따른다고 가정

$(X_i = x_i |Y = y)$ 개별 class variable 로 sorting 한 상태에서 mean 과 variance 를 가진다.

1. $P(X_i | Y, \mu, \sigma^2) = \frac{1}{\sigma\sqrt{2\pi}}e^{\frac{(X_i-\mu)^2}{2\sigma^2}}$

※ $P(X_i | Y)$ 는 확률, 확률 밀도함수에서 뽑아낼 수 있음이 당연

어차피 하려는 건 결국 classification 이다. 이에 따라 Y 는 categorical value 가 된다.

이에 따라 prior 부분은 Guassian distribution 처럼 만들지 않아도 된다.

2. $P(Y=y) = \pi_1$ 로 표현한다.

1, 2 번 공식을 Naive Bayes Classifier 공식에 대입하여 다음과 같이 정리할 수 있다.

(feature 개수만큼 곱한 형태)

※ 다음 개념을 들어가기 전에

Logistic Regression 은 discrimitive mode, Naive Bayes 는 generative model 이다. (아래 글 참고)

https://itforfun.tistory.com/253

머신러닝 정리 7.5(1) - Discriminative model vs Generative Model

Naive Bayes Model은 Generative Model 이고 Logistic Regression 은 Discrimitive Model 이다. Generative Model은 GAN 과 Diffusion 으로 접해봤는데 Naive Bayes 가 Generative 라니 어떤 의미인지 직관적으로 와닿지 않았다. 이에

itforfun.tistory.com

https://itforfun.tistory.com/254

머신러닝 정리 7.5(2) - Naive Bayes는 Generative Model

Naive Bayes 가 Generative model 인 것을 확인하기 위하여 이전 글 에서 Generative Model에 대한 간략한 소개글을 작성했다. 해당 글을 원할하게 읽기 위해서는 이전 글을 간단하게 살펴보는 것을 추천한다.

itforfun.tistory.com

Naive Bayes 가정과 함께

Logisitic Regression 에서는 $P(Y = y|X)$ 형태 자체를 모델링 하려고 했었다. (참고글)

P(Y|X) 가 logistic function의 모양을 따르겠다는 가정하에 logistic function에다가 regression을 하는 형태로 logistic regression model을 설계했었다. 즉 별다른 작업을 거칠 필요가 없었다. (Discriminative Model 자체가 컨셉이 더 간단하다보니, 유도 과정 자체도 더 단순해질 수 밖에 없는 것 아닌가 하는 생각이 든다.)

반면 Generative Model 은 위 공식유도와 같이 Bayes theorem 형태로 바꿔서 적용하려고 노력한다.

보통 $P(X)$ 는 normalize constant term 으로 제하고서 $P(Y =y |X) \propto {P(X|Y = y)P(Y=y)}$ 로 본다.

그리고 이 중 $P(Y=y)$ prior 로, $P(X|Y = y)$ 를 likelihood로 보곤한다. 여기서 $P(X|Y = y)P(Y=y)$ 부분을 추정해서 classification model 을 만든다. 이것이 Naive Bayes 모델의 기본 형태이다.

하지만 지금은 equal 관계를 모델링 하는 것이기 때문에 분모 부분을 생략하지 않고 deriviation 한다.

여기서는 categorical value 가 아니라 numerical, continuous value 를 다룬다. 여기에 Gaussian 가정을 덧붙여서 Gaussian Naive Bayes 로 만들었다.

정리하자면 Generative model 은 $P(Y|X)$ 를 bayes theorem 을 활용해 prior 와 likelihood로 만들어준 다음에 posterior 를 그대로 측정하는 것이 아니라 prior 와 likelihood를 개별적으로 learning 하거나 parameter 를 넣어 만드려고 한다. (만들고나니 MLE, MAP 와 유사해보인다.)

지금 여기서의 목표는 Naive Bayes 에서 Logistic Regression 이 유도가 된 다는 것을 보이고자 하는 것이다.

물론, Bayes theorem 에 의해 성립이 되긴 하지만, $f_{NB}(x) = argmax_{Y=y} P(Y=y)\prod_{1 \leq i \leq d} P(X_i = x_i | Y = y)$ 형태, 여기서도 Gaussian 가정이 가미 된 아래 형태에서

logistic regression 으로 바꿔주면 어떻게 될지 살펴보자.

$P(X)$ 는 아래와 같은 모든 X를 포함해 줘야 하므로 Y 가 포함 될 때의 X, Y가 포함 되지 않을 때의 X 모두 더해준다.

$P(X|Y = y)P(Y=y)$ 는 X 가 여러개가 되었을 때 parameter 의 수가 exponential 하게 증가하기 때문에 Naive Assumption 을 이용해서 개별 feature 들의 multiplication 형태 $P(Y=y)\prod_{1 \leq i \leq d}P(X_i |Y=y)$로 만들어주었다. 분모도 동일하게 적용해 주었다.

또한, Gaussian 가정을 했기에, 이에 맞춰 모델 형태를 변화시킨다.

((Y= y, n) 인걸 통해서 X 가 continuous variable 인 것과 관련없이 output 이 Yes, No 로 나뉘는 classifier 인 것임을 기억하자.)

분자와 분모가 겹치는 부분이 있어서 약분해주고 아래와 같이 정리한다.

또 추가적으로 가정을 해본다. $a_2^i = a_1^i$

총 가정이 3가지이다.

1. Gaussian Assumption

2. Naive Assumption

3. input feature 가 나타내는 각 클래스간의 variance 가 동일

이로 인해 부분적으로 더 간략하게 정리가 되었다.

$e^1 \cdot e^2 = e^{1+2}$ 지수의 곱이 합이 되는 특성을 이용하여 정리

prior 파트인 $\pi_2, pi_1$ 도 내부로 넣게되면 log 가 붙는다.

지수함수의 나눗셈은 뺄셈이므로 아래와 같이 더 정리 가능하다.

$\sum$ 이 같은 형태이므로, 합쳤다.

$a_2^i = a_1^i$ 로 가정이 되었으므로 통일한다.

그 후 식을 다 정리한다.

다 정리하고 나니, logistic regression 에서 쓰이는 logistic function과 형태가 똑같아졌다.

$\sum_{1 \leq i \leq d}\{ 2(\mu_2^i - \mu_1^i)X_i + \mu_1^{i^{2}} - \mu_2^{i^{2}}\} + \log \pi_2 - log\pi_1$

$\rightarrow X\theta$ 의 linear term 하고 동일하다.

위 증명은 어떤 의미가 있을까?

Gaussian Naive Bayes 라는 모델은 class 로 sorting 한 경우(여기서는 Yes or No)에 같은 feature 들에서는 같은 level의 variance 를 갖는다고, 두개의 class 를 설명하는 추가 가정을 달면 그 것 자체가 즉 logistic regression 과 동일해진다는 것을 확인했다.

결론적으로 살펴보자면 Naive Bayes는 Logistic Regression에 비해 몇가지 더 가정을 걸었다. (물론 Logistic Regression의 가장 하나가 Naive Bayes 의 가정들보다 더 좋다고 단정할 수는 없다.)

하지만 학계에서의 정론은 logistic regression이 Naive Bayes 보다 성능이 더 좋다고 한다.

Naive Bayes는 Logistic Regression 보다 오히려 찾아야하는 parameter 의 개수도 많다.

$\mu$ 에 대해 2개, input feature $d$ , variance 에 대해 2개 (가정으로 인해 1개로 처리)

= 2 X 2(1) X d + 1 = 4d(2d) +1(prior)

반면 Logistic Regression은 d + 1(prior) 으로 수가 훨씬 적다.

그렇다면 Logistic Regression은 모든 상황에서 항상 더 좋을까?

Naive Bayes 는 Bayes Theorem 을 기반으로 하기 때문에, prior 정보를 파라미터 추정 과정에서 추가해줄 수 있다.

즉 조작할 수 있는 레버가 좀 더 많다. 즉, 좋은 사전 정보가 있다면 Naive Bayes 가 더 좋을 수 있는 것이다.

이에 따라 주어진 문제 상황에 대해서 가장 적절한 모델이 무엇일까 생각하고 적용하는 것이 굉장히 중요하다.

그렇기에 이러한 비교 과정을 follow up 하며 내용을 알고있는 것이 중요하다.

Generative - Discriminative Pair

Generative model, P(Y|X) = P(X,Y) / P(X) = P(X|Y)P(Y)/ P(X)

Generative model 은 P(Y|X) 를 굳이 위와 같이 표현을 한다.

Full probabilistic model of all variables

데이터로부터 P(X|Y), P(Y) 의 파라미터를 측정한다.

Characteristic: Bayesian, Prior, Modeling the joint probability
Naive Bayes classifier

Discriminative model P(Y|X)

관측 된 변수들의 분포를 모델링 할 필요가 없다.

데이터로부터 얻은 P(Y|X) 의 파라미터를 측정한다.
Characteristics: conditional probability 를 모델링한다.
Logistic Regression

Pros and Cons

Logistic Regression is less biased

Probably approximately correct learning: Naive Bayes learns faster

위 과정을 통해 90년도 중후반까지 사용했던 classic model 들을 살펴보았다.

다음 게시물부터는 20년도 초반에 많이 활용된 SVM 에 대하여 다뤄본다.

머신러닝 정리 8.5(2) - Naive Bayes는 Generative Model

알 수 없는 사용자 — Tue, 1 Nov 2022 13:59:40 +0900

Naive Bayes를 classification task 로 사용하는 것은 익숙하나, data 생성용으로 사용된다는 것은 익숙하지 않다.

하지만 놀랍게도 Naive Bayes는 데이터 생성에 가장 일찍 사용된 모델 중 하나이다. 물론, 복잡한 이미지 데이터에는 사용할 수 없었다.

해당 글에서는 Naive Bayes가 어떻게 generative model 이며, 왜 해당 모델로 복잡한 데이터인 이미지나 글 생성에 사용될 수 없는지 정리한다.

인스타그램에서 #패션스타그램 을 한다고 상상해보자.

https://www.oreilly.com/library/view/generative-deep-learning/9781492041931/

위 사진을 보라, 당신은 피드에 패션스타그램으로 많은 글을 올렸다. 신규유입을 위해 계속해서 색다른 착장을 올리고 싶으나 적절하며 새로운 착장이 안떠오른다. Naive Bayes를 사용한 generative model이 적절하며 유니크한 조합을 당신에게 제시해줄 수 있을까?

정답은 물론이다!

※ 다음을 읽기 전 아래 두가지를 전제조건으로 하고 넘어가자

1. 위 이미지에서 관측한 착장 외에 새로운 아이템은 없다. 아래 주어진 것들만이 'features' 이다.

7(hairstyles) x 6 (hair color) x 3(specs) x 4 (tops) x 8 (colors)=4032 unique combinations 이다.

그리고 training dataset은 당연히 이미지를 입력으로 바로 받는 것이 아니라, tabular data 의 형식으로 받는다.

2. 상단 이미지는 아주 강력한 힌트를 제공한다 : 특정 카테고리의 몇몇 아이템을 고를 확률이 같은 카테고리의 다른 아이템을 고를 확률보다 더 높다. 예를 들면, silver-grey curly hair 를 다른 요소보다 선호할 수 있고, 유사하게 white tops 를 green tops 보다 선호할 수 있다. 모델이 내 선호도를 반영하면 좋겠다.

2번째 전제조건이 수학적으로 어떤 의미가 있는가?

모든 착장이 동일한 확률을 갖지 않고 어떠한 p_data 분포를 따른다는 것이다. (당연히 uniform 한 형태는 아니기에 pdf라고 부른다 ) 당신은 당신의 옷장에 있는 몇몇 아이템을 다른 아이템보다 선호한다.

여기까지만 읽어도 뭔가 generative model 과 관련이 있어보인다.

pdf 추정: 어떠한 pdf 에 사용된 p_data: 위 tabular data(dataset X)가 주어졌을 때의 p_model
추정된 pdf: p_model을 사용하여 새로우며 적절한 combination을 생성하여 새로운 인스타 이미지를 업로드한다.

parametric modeling 사용하여 pdf:p_data 를 추정하려면 이 p_data 분포를 나타낼 수 있는(represet) parameter 를 추정해야한다. (말이 복잡하지만, p_data 분포를 나타내는 paramter 를 추정하는 것이 곧 최적화 된 p_model을 찾는 것). 현재 가장 novel 한 방식은 샘플 공간(sample space)의 가능한 모든 포인트를 파라미터로 고려하는 것이다. 그러므로 우리는 샘플 공간의 포인트들의 확률인 4032 (모든 combinations) - 1 =4031 개의 포인트를 parameter로 넘긴다.

※ 왜 1을 뺄까?

4032 개의 포인트의 확률이 모두 합쳐 1이 되어야 하므로, 4031 개만 알면된다. 마지막 포인트는 1 - (4031 포인트 확률의 합) 으로 구할 수 있다.

4031 개의 포인트의 확률은 어떻게 구할까? (여기서는 각 포인트가 하나의 착장)

P(아무 착장) = 샘플 data에서 관측된 착장의 빈번도 / 총 샘플

만약 Red round Top 과 white hair & no glasses 착장을 100번의 인스타 이미지 중 4번 입었다면,

P(Red & Round Top & White hair & No glasses) = 4/100

그럼 본적 없는 combination 에 대해서는 어떨까? 그냥 확률이 0인걸까?

물론 아니다.

combination이 데이터에 등장한 적 없었던 경우에 분자와 분모에 엡실론을 더하는, additive smoothing 을 수행하고, 이로 인해 unseen combinations 의 확률은 0이 아니다.

그러나 숨겨진 문제는 여전히 존재한다.

1. 앞에서 언급된 것과 같이, silver hair & white tops 을 선호한다. 그러므로, 논리적으로 따지면 silver hair 나 white topes, 혹은 둘다를 갖는 unseen combinations 높은 확률이어야 한다.

2. 만약 옷장에 흰색과 굉장히 유사한, 달걀껍질 흰색의 옷이 있으면 어떻게 처리해야 할까? 흰색과 다름에도 굉장히 유사하다는 이유로 달걀껍질 흰색 옷을 포함하는 combination이 초록색이나 노랜색보다 조금 더 높은 확률을 가져야 할까?

일단 문제 1에만 집중을 해서 해결해보자.

위 시나리오에서 모든 combination의 확률은 다음으로 같이 계산된다.

its total occurrence / total images else some 'k'

샘플 공간(sample space)의 모든 착장에 대하여 확률을 배정해주는 상단 접근방식은 모든 unseen combination 에 특정 확률 'k'를 부여하게 될 것이고 이는 우리가 원하는 pdf: p_data 가 아니다. unseen combination중 더 선호하는 아이템이 포함된 것이 모델로부터 더 높은 확률을 부여받아야 한다.

좀 더 자세히 보면, 이러한 확률 부여 방식이 곧 모든 파라미터가 100% dependent 하다고 직접적으로 가정한 것을 의미한다. 하지만 실제로는 그러기도 하고 그렇지 않기도 하다. 이는 다음과 같은 큰 문제점을 갖는다.

당신이 silver hair, white round tops, glasses 를 좋아 할 수 있지만, 안경을 쓰지 않고 나가는 combinations 착장은 생각도 못해봤을 수 있다. 이 착장의 (silver hair, white round tops, NO glasses) 선호도를 한번 계산해보자. 이전 접근 방식으로 계산하면 관측 되지 않았던 랜덤 hair, random 색상의 top, glass 유뮤와 동일한 확률을 부여한다. 보통 5개의 아이템 중 4개는 선호하는 것을 사용하는 취향을 고려했을 때 말도 안된다. 선호 하는 feature 중 그냥 하나의 feature (여기서는 no glasses)만 빠졌을 뿐인데, 왜 이 combination이 다른 어떤 random combination 같은 것처럼 보이게 만드는 걸까? 그런 random combination 보다는 확률이 높아야 정상이다!

문제는 우리가 아래와 같이 가정할 때 발생한다.

$P(A,B,C,D,E) = P(A \cap B \cap C \cap D \cap E) - 1번 식$

all or nothing. 즉, 모든 것이 한번이라도 동시에 일어나지 않으면, 확률은 'k' 이다. (unseen combinations 에 대한 상수)

아래는 어떨까?

$P(A,B,C,D,E) = P(A) \times P(B) \times P(C) \times P(D) \times P(E) - 2번 식$

이 방식은 우리가 위에서 마주한 문제를 해결한다: 즉 all-or-nothing을 피하게 한다. 위에서 언급한 것과 동일한 상황을 가정해보자. 5개 중 4개의 attributes 가 선호도 높은 아이템 일 때, random combination 보다 해당 combination 이 더 높은 확률을 가능성이 높다.

이 것이 바로 Naive Bayes 가 기능이다. 모든 features 이 독립이라고 가정함으로써 hair style 을 고르는 것은 top color 를 고르는 것과 무관하고, top style 은 악세사리 등 뭐를 착용하던간에 그 것과 독립이다. 그러므로 우리의 확률 분포 함수는 1번 식에서 2번 식으로 변경된다.

P(Black hair, long curly hair, pink top, round top, no glasses) = P(Balck hair) x P(long curly hair) x P(pink top) x P(round top) x P(no glasses)

P(any element x) = X의 등장 수 / total samples 이므로

P(Balck Hair) = (Black hair)의 빈도/ Total insta images이다.

Naive probability distribution function 을 사용하는 것만으로도 4031개의 파라미터를 23 개로 줄일 수 있다!!

어떻게 가능한가?

Naive Bayes 는 모든 feature 가 독립이라고 가정한다. 즉, pdf 의 total parameters 개수는 아래와 같다.

7(Hair style) -1 + 6(hair color) - 1 + 3(glasses) - 1+ 4(clothing type) - 1 + 8(clothing color) - 1 = 23

※ 왜 모든 feature에 대하여 a-1 을 할까?

위에서 -1 을 했던 것과 동일하게 a-1 개의 확률이 정해지면 나머지 1개는 $1 - \sum_{i=1}^{a-1}(P(i))$ 로 정해지기 때문이다.

※ 왜 총 파라미터의 개수가 곱셈이 아니고 덧셈일까?

각 feature 가 독립이므로, 확률은 다음과 같이 계산된다.

P(Black hair| pink top) = P(Black hair) x P(pink top)

& P(Balck hair|round top) = P(Black hair) x P(round top)

P(Black hair) 는 상수이므로, 아까의 경우 parameter들이 dependent 하다고 가정했던 것과는 달리 위 두가지 경우를 계산할 때 모두 활용된다. 첫번 째 pdf 에서는 P(Black hair $\cap$ pink top) & P(Black hair $\cap$ round top) 를 계산하되 features를 dependent 하다고 보아 P(Black hair) 만으로는 계산이 불가능했다. 풀어 말하자면, Black hair 를 포함한 모든 착장의 확률이 개별적으로 계산되었다.

여기까지 살펴본 것을 통해서 Naive Bayes 가 주어진 샘플(단순한)에 대하여 유사한 새로운 데이터를 생성하는 데 어떻게 도움이 되는지 알게 되었다.

두줄 정리

Discrimitative 모델이었다면 주어진 입력이 어디 카테고리에 속하는지 나누는 것이 목적이라면, Naive Bayes 는 당신이 인스타 그램에 새롭게 업데이트 할 옷을 추천해줄 수 있다.
다만 Naive Bayes 는 conditional independence 를 가정하는데, 해당 글은 마치 marginal independence 를 가정한 것 처럼 작성되어 있어서 읽을 때 유의가 필요할 것 같다.

Naive Bayes 를 활용하여 이미지를 생성할 수는 없을까?

단순히 combinations 을 제안하는 것을 넘어 mock picture 를 생성하여 어떤 착장을 입을지 아이디어를 얻어보려고 한다. 또한 이번에는 tabular data로 학습하지 않는다. 이번에는 계정의 instagram에 올라왔던 원본 사진으로 학습시켜서 model 이 dress combination 을 제안시켜 보려 한다.

Naive Bayes Model을 다음 이미지로 학습시킨다.

https://www.oreilly.com/library/view/generative-deep-learning/9781492041931/

그러나 결과물은 아래와 같이 생성된다.

https://www.oreilly.com/library/view/generative-deep-learning/9781492041931/

뭐가 잘 못 된 것일까?

이전 시나리오에서 Naive Bayes 를 [n x 7] 행의 데이터로 학습시켰다. (n = 샘플 개수 / image - 즉 50개). feature 값들은 직접적으로 tabular data로 제공되었다.

반면 이번 시나리오에서 데이터는 복잡해졌다. 이번에 우리는 Naive Bayes를 [n x 64 x 64] 크기의 데이터로 학습시켰다. (64x 64 는 이미지의 차원이다). 관측한다면, 이 이미지들은 hair style 이나 top style 혹은 color 에 대해 어떤 힌트도 제공하지 않기에 Naive Bayes 로서는 특징을 뽑아내는 것이 굉장히 어렵다.

이런 상황에서 Naive Bayes 를 사용하는 것은 아래와 같은 어려운 점이 있다.

Naive Bayes 는 모든 features 가 독립이라고 가정하였다.

이러한 가정은 다른 combinations 을 생성할 때 선호도등을 반영하고자 했던 첫번째 시나리오에는 적절하다. 하지만 이게 이제는 Bottle Neck이 되어버린다. 왜일까? 이제는 'top' 영역의 인접 pixels 이 하나의 독립체에 속하고 유사하게 보여야 한다는 것을 알 방법이 없다. (위 결과 사진을 보면 'top' 의 pixel의 중구난방한 것을 볼 수 있다.) 그러므로, training dataset을 통하여 얼굴 색이나 입술 색을 묘사하는 것은 꾀나 정확하나, 'tops' 의 색상은 이미지마다 계속해서 빠르게 변하므로 최종 결과물이 다소 pixels 들이 섞이게 된 것이다. 얼굴과 입술은 트레이닝 데이터 샘플에서도 일정하다보니 비교적 나을 수 밖에 없다. 재밌게도, training dataset에 존재하는 top colors 들이 거의 유사한 확률로 섞여가지고 최종 결과물의 'top' 영역에 드러났다. 비슷한 패턴이 머리 안경 등에서도 나타났다. 한마디로 관계나 상황을 따로 학습시킬 방법이 없다.

첫번째 케이스에서 샘플 공간(sample space)이 4032 points 로 굉장히 작았고 각 포인트가 가능한 유효한 combination을(선호 되지 않는 것도) 생성했다. 이미지를 고려할 때 각 픽셀이 255개의 고유한 값을 가질 수 있고 64 X 64 = 4096 픽셀까지 하면 샘픙 공간이 엄청나진다. 당연히, 모든 결합이 valid image가 되지는 못한다. 그러다보니 1) 샘플 공간에서 특정 파트를 딱 정해서 valid image가 생성되게 하는 것 자체가 어렵고 2) Naive Bayes 로 인해 픽셀간의 관계가 무시되어서 더 어렵다. 이미지의 pixels들은 주로 작은 patches 로 연관되어있다. (top, faces, lips 등). 이러한 연관관계는 절대 무시되면 안된다.

이러한 한계를 극복한 방법은 Autoencoders 와 Generative Modeling 의 아주 큰 주춧돌인 VAEs 를 통해 추후 알아보자.

머신러닝 정리 8.5(1) - Discriminative model vs Generative Model

알 수 없는 사용자 — Mon, 31 Oct 2022 20:30:15 +0900

Naive Bayes Model은 Generative Model 이고 Logistic Regression 은 Discrimitive Model 이다.

Generative Model은 GAN 과 Diffusion 으로 접해봤는데 Naive Bayes 가 Generative 라니 어떤 의미인지 직관적으로 와닿지 않았다.

이에 따라 Generative Model 과 Discrimitive Model 을 기본개념부터 비교해보며 정리해본다.

Discriminative Model & Generative Model

Discriminative Model

해당 모델들은 training data 중 클래스들을 구별하는데 도움이 되는 unique features 들만 학습한다. 이러한 특성으로 인해 주로 classification algorithm에 주로 사용된다. (ex. SVM, Random Forests, etc.) 해당 모델들은 feature X가 주어졌을 때의 feature Y의 확률인 $P(y|x)$ 를 측정한다.

예를 들어, 만약 주어진 이미지 데이터셋에서 말과 얼룩말을 구분해야하는 경우를 보자. Discriminative Model 은 두 샘플을 구별하는 특징들만 학습하고자 한다. (얼룩말의 줄무늬가 구분되는 특징일 수 있다.) 그러나 얼룩말과 말이 어떻게 생겼는지는 절대 이해할 수 없다.

Generative Model

해당 모델들은 클래스들을 구별하는데 도움이 될만한 unique features 이해하기 보다는 전체를 이해하고자 한다.

예를 들어, 분류를 돕는 unique feature만을 이해하려 하기 보다는 말과 얼룩말이 어떻게 생겼는가에 집중한다. 이러한 모델들은 실제로 data 를 이해하고, discriminative model 이 할 수 없는 data 생성이라는 엄청난 이점을 제공한다.

생성 모델들은 다음을 측정하고자 한다.

unsupervised data: sample 'x' 를 관측할 확률 즉, 주어진 데이터셋 X의 p(x)
supervised data: 주어진 데이터 셋 X에서 label 'y' 가 주어졌을 때 sample 'x' 를 관측할 확률

생성 모델의 몇가지 특징

1. 분포의 측정

목표는 training samples이 생성되는 분포를 결정하는 것이다. 만약 해당 분포가 측정되면, 수 많은 samples 을 생성하는 것은 굉장히 쉽다. (평균과 표준편차가 주어진 정규분포에서 샘플을 생성하는 것이 얼마나 쉬운지 떠올려보자.) 분포를 추정함으로써 분포의 parameters를 추정한다. (정규분포의 평균과 표준편차같은 느낌)

2. 통계적 본질 (Stochastic Nature)

좀 어려운 부분이다. 통계적으로 랜덤인 요소를 측정한다. 이러한 알고리즘은 자연적으로 통계적이라(stochastic in nature) 주어진 한 input에 대해 다른 결과물들을 생성한다. 이러한 특성은 마치 determisnistic(주어진 input에 fixed 된 결과물) 인 것처럼 필수적이다, 모델은 일부 공식을 학습하여 생성 능력이 소진 될 수 있다. 즉, 고유한 입력이 한번 반복되면, 고유한 출력이 반복된다. 이는 주어진 샘플 데이터 셋에 대하여 수십만장의 이미지를 생성하고자 하면 큰 문제가 될 수 있다.

3. 평가하기 어려움

사실이다. discriminative model은 accuracy, F1 Scores, 등의 metric을 갖는 것과 비교하여 생성 된 인공 샘플의 질을 평가하는 것은 어렵다. True, False 혹은 좋다 나쁘다의 기준 같은 것이 없다. 생성 된 샘플의 질은 정성적인 영역이다. (실제로 논문에서도 정성 평가를 사용하곤 한다.)

4. 복잡한 데이터의 잠재 표현에 대한 의존성 (Dependence on Laten representation for complex data)

잠재 표현(Laten representaion)은 주로 높은 차원의 복잡한 데이터를 낮은 차원으로 표현한 것이다. 이는 데이터 생성에서 굉장히 중요한 역할을 한다. 잠재 공간(latent space)에 데이터의 중요한 특성만 보존하여 원본 객체에 근사하도록 역추적을 한다. 확률적 요소가 더해져 생성된 이미지가 데이터 셋 X의 주제/내용 (theme/content)와 유사하면서도 학습 데이터와 동일한 복사본이 되지 않도록 한다.

원기둥의 잠재 공간(latent space) 를 만들고자 한다고 가정해보자. 원기둥을 더 낮은 차원인 '잠재 공간(latent space)' 표현하면, 잠재 공간은 모든 작은 디테일을 기억하지는 않고 원기둥을 결정짓는 중요한 요소들인 기본 특성만(원기둥 같은 높이, 반지름, 길이, 그 외 보통 원기둥을 결정 짓는 요소들) 기억할 것이다. 잠재 공간에 저장 된 이러한 기본 지식들에 작은 인공적 디테일을(ex. 질감, 원기둥 색상) 더하여 데이터셋에 적합해 보이면서 한번도 본적 없는 새로운 샘플들이 생성되는데 사용한다.

회색 도형: samples, 점선 도형: input N이 주어졌을 때, 잠재 공간으로 생성 할 수 있는 본적 없는 결과물

그러나 놀랍게 세상은 주로 Discriminative modelling 에 집중한다.

이는 Discriminative model이 실제 세상 문제들에 적합하기 때문이다. 인공 샘플을 생성하기 위하여 샘플이 생성 된 분포를 알아야 되는 상황은 드물다 - 즉 주로 '분류(classification)' 가 실제 세상 문제와 연결된다.

아래 상황을 살펴보자.

의료 이미지를 병감지 센터로부터 받았다. 여기서는 모델이 의료 이미지를 더 생성하는 것보다는 그냥 악성 종양을 잘 분류하거나 잡아내기를 원할 것이다. 분포를 학습하는 것이 여기서는 의미가 없다.
email 을 스펨으로 분류하기 위해서 모델은 spam, no-spam 으로 분류해야 한다. 이를 위해서는 이러한 이메일이 생성된 분포를 이해하기 보다는 내용으로 분류하는 것이 중요하다.

최근 GAN 및 텍스트 생성의 발전으로 인해 generative modelling 이 실제 세상 문제에 적용될 여러 새로운 기회를 얻고 있다. 그러나 여전히 커리어의 초기단게에서는 generative model이 주로 사용되는 경우가 적다.

Generative Model Framework는 어떻게 생겼는가?

dataset X가 있다.

이 X 가 어떤 분포 P_data 에서 샘플링 되었다고 가정한다.

generative model 인 P_model 은 P_data 와 유사하게 행동하여 비슷한 샘플을 생성한다. 목표는 P_model을 P_data와 최대한 유사하게 학습시킨 후, P_model을 이용하여 같은 타입 샘플을 더 많이 생성하는 것이다.

P_model 이 보기 좋은 모습은?

P_model이 유사한 샘플을(dataset X에 봤던 것과는 같지 않은) 생성할 때, '주제(theme)' 는 같도록 유지되지만, 다른 특성(features)은 상당히 변화한다. 만약 'X' 가 얼굴 데이터라 하면, 성공적인 P_model은 다음과 같은 얼굴 이미지를 생성할 수 있어야 한다.

P_data의 copy_paste 가 아닌 샘플 (dataset에서 본적 없는 face) (오타가 아닌가 싶다 P_data 가 아니라 X_data 아닌가? )
샘플들은 얼굴과 닮아야 한다. (말이 아니어야 한다.)

아래 예제는 이상적인 경우다.

위 세계 지도를 살펴보자. '검은 점'이 generative model을 만들 때 학습한 데이터 셋이라 가정해보자. 학습 데이터 셋은 다음의 특징을 갖는다.

각 점은 '육지' 지역에 있고 바다 지역에 있지 않다.
육지 선택에 특별한 조건은 없는 듯 해 보인다. 전 대륙에 걸쳐 넓게 퍼져있다.

generative model 'a', 'b', 'c' 를 학습시킨다고 가정해보자. 각 모델은 한 점씩 생성한다.

'a' 는 점 'A' 를 생성했다. 하지만 바다 위에 점을 생성했기에 이상적인 generator 가 아니다. 이 모델은 학습 데이터에서 가장 중요한 특성중 하나인 '각 점은 육지 지역에 있다'를 이해하지 못했다.

'b' 는 점 'B' 를 생성했다. 그러나 B는 overfit 된 것 처럼 보인다.

'c' 는 점 'C' 를 생성했다. 점이 육지위에 찍혔고, 기존 데이터와 너무 유사하지도 않아서 좋아보인다. 'C' 가 이상적인 generator이다.

몇가지 용어 정리

※ Sample Space:

The pool of values from which samples in training dataset ‘X’ can take values. For example: In the above world map scenario, the collection of all points on ‘land’ constitute the sample space

※Probability Density Function (pdf):

It’s the function that maps the probability of picking up a sample from a sample space.

예를들어, 물위에 있는 점은 probability = 0 이다. 육지에 있는 점은 상수 'k' 이다.

※ Parameteric modeling:

Representing any distribution using a set of parameters is called Parameter modeling (정규분포에서 평균과 표준편차가 있으면 sample 을 뽑을 수 있다. 삼각형의 경우 꼭지점 3개로 결정된다. 즉 모든 샘플은 (A,B,C) 좌표로 측정 될 수 있다.)

※ Likelihood:

데이터 셋 X 가 주어졌을 때, 분포의 paramters $\theta$ 가 관측될 확률. 즉, $P(y|X, \theta)$ 이다.

※Maximum likelihood:

$P(y|X, \theta)$ 를 최대화 하기 위한 최적의 parameter $\theta$ 를 maximum likelihood라고 한다.

샘플 공간(sample space)의 모든 샘플의 확률의 합은 1이다. P_data & P_model도 물론 pdf 형태로 나타난다. P_data의 유일한 차이점은 dataset X의 true pdf 이고, 그러한 pdf 는 하나만 있다는 것이다. 반면에 추정하고자 하는 P_model은 P_data에 의해 여러개로 추정 될 수 있다. 우리는 P_data 를 추정하는 best P_model 얻을 방법을 찾아야 한다. (알아듣기 쉽게 설명하자면, true pdf 는 당연히 하나밖에 없다. true pdf 를 추정하는 모델은 당연히 여러개 생길 수 있다. 이 중 true pdf를 가장 근사하는 모델이 우리가 찾고자 하는 모델이다.)

머신러닝 정리 7 - Decision Boundary, logistic regression, Gradient Descent

알 수 없는 사용자 — Fri, 28 Oct 2022 17:35:57 +0900

지금까지 Traditional 한 기법인 Decision Tree, Linear Regression, Rule base 기법 등을 알아보았다.

그리고, 가장 최근 글에서는 conditional independence 를 가정한 Naive Bayes Classifier 를 알아보았다. Navie Bayes Classifier 는 MAP 기법으로 간단하게 구현된다.

하지만 Navie Bayes Classifier 는 Naive 한 가정으로 인해 feature 간의 interaction을 전혀 반영하지 못한다는 점에서 문제가 있었다.

이러한 문제를 탈피한 여러 방법론들을 앞으로 알아보려고 한다.

그 중, 가장 기본적인 것 부터 알아보자.

Logistic Regression

Logisitc Regression 도 Bayes risk (error)를 최소화 하는 형태로 구현되었다.

이글에서는 Logisitic Model 을 구현 한 후, parameter 를 optimize 하는 MLE(극점 이용) 기법을 통해 parameter $\theta$ 를 inference 하는 과정을 다루고, 마지막에 Naive Bayes 와 Logistic Regression 을 비교해본다.

위 이미지는 이미 그전 글들에서 너무 여러번 다뤘던 내용이므로 간단하게 요약만 해보자.

Binary Classification 문제에서 postive 일 확률이 0.7 이면, negative 일 확률은 0.3이다.

0.3 만큼이나 negative 가 될 bayes risk 를 안게된다. (위 그림에서는 색칠 된 영역)

위 점선으로 모델링 된 확률을 실선처럼 모델링 하여 bayes risk 자체를 최소화 하는 방법이 있다면, 그렇게 하는 것이 가장 이상적이다.

$x_m$ 을 기준으로 왼 쪽이면 y을 갖고, 오른 쪽이면 y을 갖는다. 이 $x_m$ 의 위치를 Decision Boundary 라고 부른다. Decision Boundary 를 기준으로 각 y, y 가 될 확률이 급격하게 증가하여야 이상적으로 구분되었다고 할 수 있다.

이 두가지를 만족하는 것이 위의 실선이다. 이 실선을 지금부터 S 커브 혹은 Sigmoid function 이라고 부르자.

Likelihood 를 어떤 형태로 만들어야 sigmoid 형태가 될 수 있을지 지금부터 살펴보자.

사용 데이터 셋: Credit Approval Dataset

http://archive.ics.uci.edu/ml/datasets/Credit+Approval

UCI Machine Learning Repository: Credit Approval Data Set

Credit Approval Data Set Download: Data Folder, Data Set Description Abstract: This data concerns credit card applications; good mix of attributes Data Set Characteristics: Multivariate Number of Instances: 690 Area: Financial Attribute Characteristics

archive.ics.uci.edu

690 Instances total
307 positive instance

credit card 신청인 총 690 인 중, 307 명만 허가된 데이터 셋이다.

A1 ~ A16 features

class C 에 대하여, 총 16개의 feature가 존재한다.

이 중 A 15 attribute 를 사용하여 예측을 해보자.

Y axis 는 P(Y|X) 이다. (응답 C)

Decision Boundary 는 회색 줄로 표시되었다.

왼쪽 그림은 X = A 15, Y = C 이고,

오른쪽 그림은 X = log(A15), Y = C 이다.

물론 왼쪽 그림을 보면 Decision Boundary 보다 아래에 있어도 응답이 positive인 사람들이 있지만, negative 인 사람들이 모두 Boundary 보다 아래에 있다.

X 를 linear 하게 보니 생각보다 clear 하게 보이지 않아, log 를 씌운 후 결과값을 본게 오른쪽 그림이다.

※log 를 씌운다는 것 자체가 급격한 값의 차이를 좀 누그려 뜨려서 보겠다는 것이다.

1, 10, 100, 1000 $\rightarrow$ 1, 2, 3, 4

그 결과 Boundary를 기준으로 label의 나뉘는 경향성이 비교적 잘 보인다.

A 15를 linear regression 으로 fitting 해보자. 물론 discrete 한 label을 fitting 한다는게 말은 안되지만 한번 해보자.

왼쪽 그림을 살펴보자. 빨간 선으로 linear 하게 fitting 이 되었다. 그리고 초록색으로 logistic regression도 해보았다. (logistic regression에 대해 아직 설명하지 않았다 뒤에서 설명한다. 다만, logistic regression 은 오른쪽 그림과 같이 S 의 형태를 띈다는 것만 알아두자.)

워낙에 데이터가 모여있어서 초록색 fitting 된 커브가 잘 눈에 안들어오지만, 동그라미 친 부분을 확대하면 오른쪽 그림과 같이 S 자 인 것을 확인할 수 있다. (오른 쪽 그림의 검은 선은 decision boundary를 임의로 표시해놓은 것이다. 원점이 아니다.)

좀 더 변화를 넓게 보기 위하여 A15 에 log 를 취해보자.

Blue = $(X, Y_{true})$

Red = $(X, P_{lin} (Y|X))$

Green = $(X, P_{log} (Y|X))$

(X가 log 가 씌어진 형태이므로, 일반적 linear 한 형태가 아니라 증가하는 형태를 띄게 되었다.)

logistic regression이 자신의 decision boundary 근처에서 부드럽고 급격하게 올라가고 그 후 그 상태를 유지하는 S 커브 형태를 만들어낸다는 것을 알 수 있다.

linear regression 은 0.5 를 지나는 지점이 logstic regression 보다 훨씬 앞지점이다.

대충 봐도 logistic regression이 사실에 근접하게 정확해 보인다.

linear regression 이 0.5 를 지난 지점 전 부분의 positive data 는 모두 에러처리가 되어버린다. (빨간 원)

반면, logistic function 에러 처리되는 부분이 훨씬 적다. (초록 원)

negative data에서도 마찬가지다.

눈으로 봐도 S 커브를 사용하는 것이 더 효율적이다.

Sigmoid

S 커브를 좀 더 전문적으로 sigmoid 형태라고 한다.

sigmoid function 이란?

bounded 되었다.
differentiable 하다.
Real function 이다.
모든 input 에 대해서 output이 특정 boundary 내에서 정의가 되어있어야 한다.
positive derivative 즉, 증가하는 형태여야 한다.

Logistic Function

Logistic function 의 정의된 Y 영역을 보면 0 ~ 1 이다.
다른 sigmoid function들을 보면 -1 ~ 1 이라는 차이가 있다.
보통 국가의 경제력과 같이 정체 중에 어떤 계기로 갑자기 성장하고 다시 정체되는 상황에 많이 사용된다.
sigmoid function 의 특징을 모두 가지고 있어서 사용하기 좋다.
당연히 미분도 쉽다. 그러다보니 미분하여 극점 찾기도 용이하다.

Logistic Function 의 역함수는 Logit function 이다.

$$f(x) = \log (\frac{x}{1-x})$$

logit function의 정의역 범위는 [0, 1]이다. 이에 따라 x 를 확률 값으로 보아 p 로 치환할 수 있다.

$$ f(x) = \log (\frac{x}{1-x}) \rightarrow x = log(\frac{p}{1-p})$$

또한 logistic function 은 logit function의 역함수 이므로, p가 치역이 된다.

$$x = log(\frac{p}{1-p}) \rightarrow ax+b $$

logistic function 을 classification 하고자 하는 분포에 맞춰서 fitting을 해야 한다.

fitting은 decision boundary의 위치를 이동 시키거나, 변화 과정을 압축하거나 넓힌다.

변화 과정을 압축, 넓힘: a

decision boundary 이동: b

즉, 해당 정보들을 control 하기 위한 매개변수이다.

$$\rightarrow ax+b \rightarrow X \theta$$

$\theta$ 의 첫번째 paramter 는 특정 bias 에만 움직이도록 설정하였기에 b 가 반영되고 나머지는 a 부분을 반영한다.

(이 부분이 이해가 안간다면 그 전 글들을 읽고오시면 좋습니다.)

해당 부분은 linear regression 과 생김새가 굉장히 닮았다.

이에 따라 linear regression의 방법으로 fitting을 해보자.

linear regression의 방식으로 $P(Y | X)$ 를 fitting 하려고 한다.

이때 $X\theta = \log(\frac{p}{1-p})$

X가 주어진 상황에서 Y가 될 확률을 어떻게 정의할 수 있을까?

사실상 p는 우리가 관심있는 확률값 (inference 혹은 optimization을 하고자 하는) P(Y|X) 라고 써줘도 무방하다.

$X \theta = \log(\frac{P(Y|X)}{1 - P(Y|X)})$

즉, $X \theta$ 를 통해 regression 임을 알 수 있는데, 모양을 살펴보면 logistic 한 형태임을 확인 할 수 있어서 logistic regression 임을 알 수 있다.

※ 위 작업에서 왜 굳이 logit function으로부터 logsitic function fitting을 유도할까?

f = theta * x 형태의 linear regression에서 linear function f를 근사하고 싶은 것처럼 logistic regression은 그 아래에 있는 logit 안의 p를 근사하는 과정 이라고 생각하면 된다.

Logistic Regression

Binomial, Multi-nomial 모두 가능

Bernoulli 실험을 상기해보자.

관측값 x 가 주어졌을 때,

다음의 확률을 따른다.

$P(y|x) = \mu (x)^y (1 - \mu(x))^{1-y}$

$\mu(x)$ 를 logistic function으로 모델링 해보자.

$\mu(x) = \frac{1}{1+e^{-\theta^{T} x}} = P(y = 1 | x)$

(범위가 1에 속할 확률)

위에서 살펴보았던 logistic regression의 p 값을 $\mu(x)$ 혹은 $P(y|x)$와 동일하게 놓고 regression 한다.

$-\theta^T x$ 는 그냥 $X \theta$ 이나, 한 instance에 대한 것이기에 $x \theta$ 로 표기한다.

$X \theta = \log(\frac{P(Y|X)}{ 1 - P(Y|X)})$ 이고 이 것을 다시 써보면

$P(Y|X) = \frac{e^{X\theta}}{1 + e^{X\theta}}$ 로 정리된 것이다.

학습시 X, Y는 주어졌으므로 우리가 모르는 $\theta$ 를 알아내는 방법이 logistic function 을 학습하고 paramter 를 inference 하는 과정이다.

(※추가적으로 $\frac{P(Y|X)}{ 1 - P(Y|X)})$ 형태는 Odd의 형태이기도 하다.)

Parameter $\theta$ 찾기

(이항 로지스틱 회귀의 경우)

Maximum Likelihood Estimation (MLE) of $\theta$

관측 데이터의 확률을 최대화 하는 $\theta$ 를 찾는 법

$\hat{\theta} = argmax_{\theta} P (D|\theta)$

Maximum Conditional Likelihood Estimation of $\theta$ (MCLE)

$$\hat{\theta} = argmax_{\theta} P(D|\theta) = argmax_{\theta} \prod_{1 \leq i \leq N} P(Y_i | X_i ; \theta)$$

$$= argmax_{\theta} \log(\prod_{1 \leq i \leq N} P(Y_i | X_i ; \theta))$$

$$= argmax_{\theta} \sum_{1 \leq i \leq N} \log(P (Y_i|X_i ; \theta))$$

순차적으로 살펴보자면, 각 $X_i$ 는 독립 시행이기에 곱셈으로 $argmax_{\theta}$를 구한다.

log 를 취해줌으로써 덧셈으로 연산 과정을 간소화하였다.

베르누이 모델

$$P(Y_i | X_i ; \theta) = \mu(X_i)^{Y_i} (1 - \mu(X_i))^{1-Y_i}$$

양변에 log 를 취해준다.

$$\log(P(Y_i|X_i ; \theta)) = Y_i \log(\mu (X_i)) + (1 - Y_i) \log(1 - \mu(X_i))$$

$Y_i$로 묶어준다.

$$= Y_i\{\log(\mu(X_i)) - \log(1 - \mu(X_i)) \} + \log(1 - \mu(X_i))$$

$$= Y_i \log (\frac{\mu(X_i)}{1 - \mu(X_i)}) + \log(1 - \mu(X_i))$$

※ recall

$X \theta = \log(\frac{P(Y|X)}{ 1 - P(Y|X)})$

$\mu(x) = \frac{1}{1+e^{-\theta^{T} x}}$ (분자 분모에 $e^{X \theta}$ 를 곱한다.) $= \frac{e^{X\theta}}{1 + e^{X\theta}}$

$$= Y_i X_i \theta + \log(1 - \mu(X_i)) = Y_iX_i\theta - \log(1 + e^{X_i \theta})$$

위 과정들은 연속형 숫자가 아닌 2개의 범주로 결과가 나와야 하기에 logistic regression이 필요한 것이고, 이를 적용하기 위해 최적화하여 추론할 $\theta$ 의 형태로 수식을 정리한 것이다.

$$\hat{\theta}= argmax_{\theta} \sum_{1 \leq i \leq N} \log(P (Y_i|X_i ; \theta))$$

$$ = argmax_{\theta} \sum_{1 \leq i \leq N} \{ Y_iX_i\theta - \log(1 + e^{X_i \theta}) \} $$

미분을 통해 극점을 찾아 최적화를 해보자.

$$\frac{\partial}{\partial \theta_j} \{ \sum_{1 \leq i \leq N} \{ Y_iX_i\theta - \log(1 + e^{X_i \theta}) \}$$

$$ = \{ \sum_{1 \leq i \leq N} Y_i X_{i,j}\} + \{ \sum_{1 \leq i \leq N} -\frac{1}{1+e^{X_i\theta}} \times e^{X_i \theta} \times X_{i,j} \}$$

$\theta$ 의 개별 element 로 미분을 취하기에 X 도 $X_{i,j}$ 로 표기한다. 즉 $\theta_j$가 역할을 하는 term에 대해서만 미분이 가능 하기에 $X_{i,j}$는 $\theta_j$와 연결된 X tern만 살린다. $X_i$가 $\theta_j$와 연결된 term이면 1, 아니면 0을 대입하여 수식을 이해하면 된다.

$\log(1+e^{X_i \theta})$ 의 미분은 log 의 합성 함수, $e^{x_i \theta}$ 에서 합성함수이므로 정리하면 $ \frac{1}{1+e^{X_i \theta}} \times e^{X_i \theta} \times X_{i,j}$ 이다.

$$= \sum_{1 \leq i \leq N} X_{i,j} (Y_i - \frac{e^{X_i \theta}}{1 + e^{X_i \theta}}) = \sum_{1\leq i \leq N} X_{i,j}(Y_i - P(Y_i = 1|X_i ; \theta)) = 0$$

문제는 미분을 통해 $\hat{\theta} = $ 의 형태가 깔끔하게 딱 떨어지지 않는다.

즉, 이 방식을 통해 $\theta$ 를 closed form solution 을 구하는 것이 굉장히 어렵다.

이에 따라 open form solution 인 즉, approximation (근사)를 해야하는 형태로 나오게 되었다.

$\theta$ 의 잘 fitting 된 값을 구하기 위해 근사를 해보자.

※ recall

logistic regression 은 regression 을 통해 classification 즉 범주형 문제에서 사용하는 모델이다.

$\theta$ 의 근사법으로 딥러닝에서 잘 알려진 gradient descent 가 등장한다.

Gradient Descent

Taylor Expansion

Taylor series 는 하나의 함수에 대한 표현이다.

테일러 급수에 관한 내용은 아래 글을 참고하자.

자세한 내용은 생략하나, 다루기 어렵거나 잘 모르는 함수를 다루기 쉽고 이해하기 쉬운 다항함수로 근사하기 위해 사용한다는 점 정도만 알아두자.

https://darkpgmr.tistory.com/59

테일러 급수의 이해와 활용 (Taylor series)

테일러 급수(Taylor series)에 대한 내용은 이미 인터넷에 좋은 글들이 많습니다. 그럼에도 이렇게 다시 글을 쓰는 이유는 스스로도 애매한 부분이 많기 때문입니다. 그래서 공부하는 셈치고 관련

darkpgmr.tistory.com

Taylor series

$$f(x) = f(a) + \frac{f'(a)}{1!}(x-a) + \frac{f''(a)}{2!}(x-a)^2 + ... + $$

$$= \sum_{n=0}^{\infty} \frac{f^{(n)}(a)}{n!} (x-a)^n$$

a 가 0 일 때, $e^x$ 함수를 표현해보자.

$$e^x = 1 + \frac{e^0}{1!}(x-0)^1 + \frac{e^0}{2!}(x-0)^2 + ...$$

(1 은 0차항이라서 1이 된 것이다. 사실은 같은 형태)

n 의 차원에 따라 근사도가 달라진다.

log function 은 아래와 같이 근사된다.

즉, taylor expansion(확장)으로 만약 무한대 합을 볼 수 있는 가정 하에서는 원하는 함수를 동일하게 근사할 수 있다.

taylor expansion 이 가능한 경우

infinitely differentiable 한데, real 혹은 complex number 로 만들어질 때

이 Taylor Expansion 으로 gradient descent 알고리즘을 정의해볼 수 있다.

Gradient Descent, Ascent

미분 가능한 함수 f(x) 가 주어지고, 초기 파라미터 $x_1$ 이 주어져야 한다. (여기서 $x_1$ 은 파라미터들의 초기 값이라는 뜻 벡터의 첫번째 값이 아니다.)
파라미터를 반복적으로 f(x) 를 더 크게 하는 쪽 혹은 더 작게 하는 쪽으로 이동시킨다.
f(x) 를 음 혹은 양의 방향의 기울기로 이끈다.

딥러닝에서 워낙 여러번 정리 했던 내용이기에 부담은 없다.

방향과 속력이 중요하다.

$f(x) = f(a) + \frac{f'(a)}{1!}(x-a) + O(\big\rvert |x-a| \big\lvert^2)$

여기서 Big-Oh notation 이 등장한 이유는 다음과 같다.

Big-Oh notation: x가 a에 가까워질 때, f(x)가 어떤 양수 M과 함수 g(x)에 의해 제한될 때를 의미한다. 이를 $ f(x)=O(g(x))$ 로 나타내고, 식으로 정의를 표현하면, $|f(x)| \leq Mg(x) $ for $ x \rightarrow a$ 로 나타낸다.

해당 함수에서는 3 제곱 이후 영향력이 작아지기 때문에 x 가 a에 가까워질 때, $\big\rvert |x-a| \big\lvert^2$ 안에 제한될 수 있는 것이다.

보통 여러 값들을 Big-oh notation의 g(x) 로 사용 가능하지만, 가장 간단하거나 tight 한 값을 사용한다.

taylor 급수는 특정한 지점 a 에 대한 deriviative 를 알 수 있어야 한다.

$a = x_i$ 로 초기값을 잡는다.

$x = x_1 + hu$, $u$ 는 unit direction vector 로 즉 특정한 속력 h 를 가지고서 특정 u 방향으로 진행해 나가는 것이 gradient descent 의 핵심이다.

h 는 learning rate 라 사람이 manual 하게 정한다. 사실 정말 중요한 건 u 이다. 일단 방향이 맞아야 한다. 이 u 는 어떻게 정할까?

$f(x_1 + hu) = f(x_1) + hf'(x_1)u + h^2 O(1)$

($a = x_1, x-a = hu$, 3번째 항은 unit vector 의 제곱을 제외한 $h^2$ 만 살아남았다.)

$f(x_1 + hu) - f(x_1) \approx hf'(x_1)u$

$h^2 O(1)$ 여기서 h 즉, learning rate 는 주로 굉장히 작다. 굉장히 작은 h의 제곱 수는 더 작다. 이에 따라 해당 값은 무시한 후 $\approx $ 처리가 가능하다.

$$u^* = argmin_u \{ f(x_1 + hu) - f(x_1) \} = argmin_u hf'(x)u = - \frac{f'(x_1)}{|f'(x)|}$$

해당 함수는 f function 을 한번 움직였을 때 감소 값을 최대화 해서 이동시키는 것이 목표이다.

$f(x_1 + hu) - f(x_1)$ 값이 최소가 되도록 하는 $u$ 를 찾는 것이 목표이다. 위에서 근사한 값인 $hf'(x_1)u$ 대입한다. 여기서 확인할 수 있는 $h f'(x) u$ 가 바로 우리의 눈에 익숙한 gradient descent 의 편미분과 방향 벡터, learning rate 의 관계이다.

u는 단위벡터이기 때문에 크기가 1이라는 사실을 알고 있다. 이때, $h f'(x_1)u$ 를 최소화를 어떻게 할까? h는 일단, 상수이기 때문에 아무런 영향을 주지 못하고 오직 u에 의해서 결정된다.

그렇다면, u 값을 통해 $h f'(x_1)u$ 를 최소화 해야 한다. 이는 둘의 방향이 180도가 되면 된다. 즉, 내적의 값이 최소가 되도록 180도의 방향을 만들어주면 된다. 그러면 u의 값은 방향만 정 반대이고 크기는 동일한 $-f'(x_1)$이 된다. 하지만, u는 단위벡터로 크기가 1이니 $|f'(x_1)|$으로 나누어주면 주어진 $u* = -f'(x_1)/|f'(x_1)|$ 이 된다. (크기만 나눔으로써 방향만 유지)

이를 좀 더 수식적으로 자세히 설명해본다면 아래와 같다.

$f(x_1 + hu) \leq f(x_1)$ $\overrightarrow{a} \cdot \overrightarrow{b} = \overrightarrow{|a|} \overrightarrow{|b|} \cos{a}$

이 글을 읽는 사람들이라면 이미 익숙하겠지만 당연히 $\overrightarrow{|a|} \overrightarrow{|b|} \cos{a}$ 는 내적이다.

$\cos $ 은 1에서 극대화 되고 -1 일 때 극소화 된다. 즉 -1 이 되는 180 도 지점, 기존 derivative 방향과 정 반대 방향이어야 한다. 이에 따라 $u* = -f'(x_1)/|f'(x_1)|$ 이 된다.

이제 이동 방향은 정해져 있고, 이동 속력은 우리가 정하면 된다.

결과적으로 아래와 같은 식을 얻을 수 있다.

$x_{t+1} = x_t + hu^* = x_t - h f'(x_1)/|f'(x_1)|$

직관적이어서 한번도 궁금해 하지 않았던 gradient descent 는 사실 taylor 확장으로부터 유도될 수 있었던 것이었다. (여기서 h 는 learning rate )

※ learning rate 는 step size 라고 하기도 한다.

이와 관련하여 좀 더 자세한 내용이 궁금하면 아래 글을 읽어보면 좋다.

해당 글의 내용에 gradient descent 내용까지 잘 정리되어 있다.

https://angeloyeo.github.io/2020/08/16/gradient_descent.html

경사하강법(gradient descent) - 공돌이의 수학정리노트

angeloyeo.github.io

또한 아래 글은 gradient descent 의 실제 적용 사례를 정리한 글이다. 위 글의 내용들이 정리 된 부분도 있다.

https://itforfun.tistory.com/250

머신 러닝 정리 6.5 - Gradient Descent 가 정말 잘 동작할까?

Gradient Descent 에 대해 이론적으로 살펴볼 기회는 정말 많다. 하지만, 이게 정말 잘 동작하는지 눈으로 직접 비교하며 확인할 기회는 잘 없다. 그런 의미에서 간단하게 정리해놓는다. 본 내용은 모

itforfun.tistory.com

결론적으로 unit direction vector X stepsize(learning rate) 로 점을 업데이트 한다.

이제 logistic regression 으로 돌아오자.

미분을 통해 극점을 통해 closed form 을 찾으려던 시도는 실패였다.

이에 따라 gradient descent 를 통해 해결하고자 한다.

(실제 실생활의 많은 모델들은 closed form 으로 찾기 어렵다. 또한 미분 계수를 구하기보다는 비교적 구현이 쉬운 gradient descent 를 택할 일이 많다.)

$$\hat{\theta} = argmax_{\theta} \sum_{1 \leq i \leq N} \log(P(Y_i | X_i ; \theta))$$

여기서는 gradient descent 가 아니라 gradient ascent 이다.

$P(Y_i | X_i ; \theta)$ 의 값을 키우면 된다.

즉, $u = + \frac{f'(x_1)}{|f'(x_1)|}$ 가 된다.

초기 parameter $\theta$ 의 값을 결정한다.
반복적으로 $\theta_t$ 를 이동시켜 더 높은 $f(\theta_t)$ 값을 얻는다.

$$f(\theta) = \sum_{1 \leq i \leq N} \log(P(Y_i | X_i ; \theta))$$

$$\frac{\partial f(\theta)}{\partial \theta_j} = \frac{\partial}{\partial \theta_j} \{ \sum_{1 \leq i \leq N} \log(P(Y_i | X_i ; \theta))\} = \sum_{1 \leq i \leq N} X_{i,j} (Y_i - P(y=1 | x ; \theta))$$

편미분 과정은 위에 자세하게 나와있으므로 참고

$f'(x)$ 를 이미 알고 있으므로 경사 상승법을 적용해보자.

$$x_{t+1} = x_t + hu^* = x_t + h \frac{f'(x_t)}{|f'(x_t)|}$$

$$\theta_j^{t+1} \leftarrow \theta_j^t + h \frac{\partial f(\theta^t)}{\partial \theta^t_j}$$

$$\theta^t_j + h \{ \sum_{1 \leq i \leq N} X_{i,j} (Y_i - P(Y=1 | X_i ; \theta^t)) \}$$

$$ = \theta^t_j + \frac{h}{C} \{ \sum_{1 \leq i \leq N} X_{i,j} \bigg( Y_i - \frac{e^{X_i\theta^t}}{1+e^{X_i \theta^t}} \bigg) \}$$

C: C 는 unit vector 로 normalize 하는 값 (h 값이 작기때문에 없어도 큰 영향력이 없기도 하다.)

$\theta^0_j 의 초기값은 임의로 선택하면 된다.$

여기까지 Logistic Regression 에서 최적 해를 구하기 위한 방법인 gradient descent 가 무엇인지, 왜 gradient descent를 해야하는 이유와, 그리고 어떻게 하는지 알아보았다.

하지만 사실 Gradient descent 미분을 통해 closed form을 쉽게 찾을 수 있는 경우에도 사용 되곤 한다.

왜일까?

Revisit Linear Regression

linear regression 의 최적 parameter $\theta$ 는 아래와 같은 것을 확인했었다.

$\theta = (X^T X)^{-1} X^T Y$

closed form 으로 구할 수 있어 간단하지만, 문제는 데이터셋의 크기가 너무 커지면 적용하기 어렵다는 것이다.

dimension 이 큰 X 의 역행렬을 구하는 것도 어렵지만, 큰 X 와 큰 Y 의 matrix multiplication 을 하는 것도 쉽지 않아진다.

그렇기에 큰 규모의 linear regression 을 할 때는 $\theta$ 를 approximation 한다.

워낙 수식도 간단하고, 편미분 과정도 위에서 충분히 언급했으므로 생략한다.

머신 러닝 정리 7.5 - Gradient Descent 가 정말 잘 동작할까?

알 수 없는 사용자 — Fri, 28 Oct 2022 00:04:27 +0900

Gradient Descent 에 대해 이론적으로 살펴볼 기회는 정말 많다. 하지만, 이게 정말 잘 동작하는지 눈으로 직접 비교하며 확인할 기회는 잘 없다. 그런 의미에서 간단하게 정리해놓는다. 본 내용은 모두 카이스트 문일철 교수님의 수업을 기반으로 하고 있음을 밝힌다.

다음의 Rosenbrock 함수가 있다.

워낙 간단한 함수라 미분으로 극점을 찾을 수 있다.

편미분 결과 global minimum = 0 at (1,1) 을 알 수 있다.

비교를 위해 위 함수를 approximation 인 gradient descent 방법을 통해 알아낼 수 있을지 확인해 보자.

먼저

초기 parameter 값을 정한다.

$x^0 = (x_1^0, x^0_2) = (-1.3, 0.9)$

derivative 의 반대방향으로 움직인다.

(기울기의 정도가 극점으로부터 떨어진 거리의 정도임으로 )

$f'(x^0) = \bigg(\frac{\partial}{\partial x_1}f(x_1, x_2), \frac{\partial}{\partial x_2}f(x_1 ,x_2) \bigg) = (-415.4 , -158)$

작은 scale 로 편미분 값의 음의 방향으로 점을 업데이트 한다.

h = 0.001

$x^1 \leftarrow x^0 - h \frac{f'(x^0)}{|f'(x^0)|}$

$444.4335 = \sqrt{(-415.4)^2 + (-158)^2}$

= (-1.2991, 0.9004)

※ $f'{x^0}{|f'(x^0)|}$ 가 정말 unit vector 인지 확인해보자.

$(-415.4/444.4335)^2 + (-158/444.4335)^2 $

$0.8736 + 0.126 \approx 1$

위 과정들을 수렴할 때 까지 반복한다.

(-1.3, 0.9) 지점에서 시작하여 점차적으로 (1, 1) 로 다가간다.

하지만 주어진 iteration 으로 (1, 1) 전에 다가지 못하고 멈췄다.

iteration 수를 늘리거나, step size 를 키워야 한다.

iteration 수를 키우자 점차적으로 근처에 다가간다.

그렇다면 step size 를 무지성으로 키우면 어떨까?

사실, step size 를 키워서 빠르게 다가가도록 하는 것도 좋은 방법 아닐까?

하지만 간과하면 안되는 점이 있다.

gradient descent 를 유도하는 과정에서

$f(x) = f(a) + \frac{f'(a)}{1!}(x-a) + O(\big\rvert |x-a| \big\lvert^2)$

$f(x_1 + hu) = f(x_1) + hf'(x_1)u + h^2 O(1)$

$f(x_1 + hu) - f(x_1) \approx hf'(x_1)u$

$h^2$ 를 step size 즉 learning rate 가 작다고 가정하고 제거하였는데 크기를 키우는 순간 무시할 수 없는 크기가 되어 버린다.

이렇기에 이론적으로 우리는 step size 를 항상 작게 유지하는 것이다.

이와 같이 실제로 예상치 못한 상황들이 발생할 수 있으므로 항상 많은 실험이 필요하다.

넛지, 넛징

알 수 없는 사용자 — Tue, 25 Oct 2022 21:21:04 +0900

UX 를 벗어난 영역에서 공부를 하다보니 소통 시 용어부터 부족하다는 것을 점점 깨닫게 된다.

이에 따라 오늘부터 UX 용어들을 follow up 하고 정리하는 시간을 종종 가지려한다.

넛지 (Nudge)

행동경제학에서 파생 된 용어로 '어떤 행동을 하도록 옆구리를 슬쩍 찌르는' 용어에서 파생되었다. 넛지를 활용한 기획을 통해 인간의 행동을 더 선한 쪽으로 유도하자는 선택 설계의 의미이다.

[넛지 사용의 세가지 원칙]

1. 모든 넛지는 투명해야 하고 절대로 상대방을 오도해서는 안 된다.

2. 넛지에 참여하고 싶지 않다면 쉽게 빠져나올 수 있어야 하고, 마우스 클릭 한번만으로 그럴 수 있다면 가장 좋다.

3. 넛지를 통해 유도된 행동이 그 영향을 받은 사람들의 삶을 더 낫게 만들 수 있다고 믿을 만한 충분한 근거가 있어야한다.

소변기 위의 파리가 넛지의 대표적 용어이다.

손톱을 물어뜯는 사람들을 대비하여 쓴맛 나는 매니큐어도 넛지의 대표사례이다.

시카고에서는 사고를 줄이기 위해 커브 구간 진입시 도로에 가로 선을 긋 되, 점차적으로 그 간격을 줄여 그려서 운전자로 하여금 속도가 오르고 있다고 착각하게 만들었다. 이로 인해 사고가 36% 감소했다.

넛지는 인간이 합리적인 존재라는 걸 부정하는 것부터 시작한다. 즉, 종종 감정적인 선택을 하며 때로는 오류도 저지른다고 믿기에 넛지를 통해 더 나은 선택으로 이끌 여지가 생긴다는 것이다.

똑똑하고 이기적인 존재라고 믿는 주류 경제학과 대비된다.

그렇기에, 가로 간격을 줄이는 것만으로도, 소변기 위의 파리만으로도 선한 방향으로 이끌 수 있다는 것이다. (누가봐도 인간을 낮게 판단한 것으로 보인다.)

기준점 효과(Anchoring Effect)

기준점 효과는 넛지를 이해하기 위한 중요한 심리적 용어이다.

사람이 최초에 무엇인가를 접하였을 때 그것에 대한 정보가 적어 똑똑한 판단을 내리기 어렵다는 것이다.

즉, 가장 먼저 제시 된 지점에서부터 판단을 시작하게 되기에 해당 지점이 한계점이 되어 판단에 왜곡이나 편파적인 영향을 끼친다.

대형마트에서 할인 상품 옆에 원가를 적고 ~~줄을 그어~~ 두면 원가를 기준점으로 생각하게 되는 것이 그 예이다.

애플이 아이폰 판매할 때, 첫 출시에 599 $, 몇달 후 399 $ 로 가격 인하하여 폭팔적인 판매 증가를 일으켰다. 최초 가격에 대한 기준점이 생기게 한 넛지 효과이다.

최고가 옆에 standard 가격을 배치하여 가격을 낮게 보이게 하는 것도 그 한 예이다.

다크 넛지

위 예시를 보면서, 넛지가 선한의도를 위해서만 사용되는 것이 아니라는 것을 느꼈을 것이다. 즉, 적재적소에 넛지를 배치하여 매출 증가를 기대하는 것도 기업의 역할 중 하나이다. 하지만, 이 의도자체가 기존 넛지와 다르므로 다크 넛지라고 부르기도 하는 듯 하다. 하지만 실제 기업에서는 넛지를 "디자이너가 어떠한 의도를 가지고 행동을 유도하는 방식" 정도로 통일하여 해석하는 듯 하다. 음원 사이트에서 낮은 가격에 할인 프로모션을 구매하고, 정식 가격으로 넘어가게 한 디자인도 모바일로 가입했는데 탈퇴는 PC로만 가능 한 것도, 마지막으로 항공권 배너를 클릭 한 후 날짜 설정 시 가격 변동이 큰 것도 이에 해당한다. 에어비앤비 역시 보여지는 가격과 수수료, 청소비가 포함된 가격이 크게 달랐던 것도 그 예시이다.

넛지를 ing 를 붙여 넛징이라고 표현할 때도 있다. 이는 넛지가 본래 쓰이는 용어고, 넛징은 넛지를 시스템이나 ui에 넣는거라고 이해하면 된다.

본 글은 https://brunch.co.kr/@cliche-cliche/43 를 참고하여 작성했습니다.

03화 다크 넛지와 UX패턴

윤리적 UX 디자인은 가능할까? | 우선, 넛지 넛지(Nudge)란 '행동경제학' 분야에서 파생된 용어로 '어떤 행동을 하도록 부추기며 옆구리를 슬쩍 찌르는 것'을 의미하는 영어단어다. 넛지의 기본 토

brunch.co.kr

위 글에는 넛지의 다양한 패턴도 참고할 수 있습니다.

머신 러닝 정리 6 - Naive Bayes Classifier (conditional Independence 조건부 독립)

알 수 없는 사용자 — Mon, 17 Oct 2022 21:57:58 +0900

Optimal Classification Concept

Navie Bayes classifier

Supervised Learning

supervised learning: 데이터와 레이블이 주어진 상태에서 학습을 진행

많은 경우 데이터와 동시에 레이블이 주어진다. 이 경우 레이블이 존재하므로 마치 주입식 학습처럼 데이터에 따른 레이블의 대세를 학습한다고 이해하면 좋다.

보통 Classificaion 과 Regression 문제로 많이 나뉘는데, 현재 linear regression 을 한번 다루기도 했고 보통 classificaion 을 할줄 알면 regression은 따라오므로 본글은 classification을 위주로 내용이 전개된다.

Optimal Classification

Classificaion: X (데이터) 가 주어졌을 때 적절한 y 값을 예측 (아래의 예시를 살펴보자)

X라는 정보가 조건으로 주어졌을 때, 초록 y 일지, 빨간 y 일지 예측하는 것이 (class가 2개인) classificaion 이다.

X 의 관측 값에 따라 빨간 y 일지 초록 y 일지에 대한 확률을 얻게 되는데 이 때 더 확률이 높은 쪽으로 분류하여 y 값을 결정한다.

$\rightarrow$ pdf 가 주어진다면 확률을 얻기 쉬워져 분류가 간단해진다.

pdf 를 어떻게 정의할 수 있을까?

Optimal predictor of Bayes classifier

$f^* = argmin_f P(f(X) \neq Y)$

$\hat{Y}$ 과 $Y$ 를 최소로 하는 $f^*$ 를 찾아내는 것이 바로 최적화 과정이다. 즉 바로 머신러닝의 목적인 가장 현실과 유사한 함수를 근사하여 optimal predictor 를 생성한다.

$f^* = argmax_{Y-y} P(Y = y | X = x)$

다시 말하자면, 주어진 $x$에 대하여 y 값이 최대화 되도록 하는 함수이다.

※ recall

아래는 이항 분포에 대한 MLE, MAP 이다.

MLE

$\hat{\theta} = argmax_{\theta} P(D|\theta)$

위 식을 오해하면 안된다. 최고값 $\theta$ 가 주어졌을 때 D(관측값) 가 등장할 확률을 구하는 것이 아니라,

주어진 파라미터 (특정 분포)에서 관측값이 등장할 확률인 "likelihood 값"이 최대가 되는 즉, $\theta$값을 조정해가며 관측값이 주어졌을 때, 해당 관측이 등장할 확률이 최대가 되는 순간이 바로 MLE 이다.

즉 $P(D| \theta)$ 값을 최대로 하는 $\hat{\theta}$

$$P(D| \theta) = \theta^{a_H} (1 - \theta)^{a_{\tau}}$$

$$\hat{\theta} = \frac{a_H}{a_H + a_{\tau}}$$

위 공식이 이해가 안되면 아래 첨부된 MLE 정리 글을 읽고오자.

MAP

$$ \hat{\theta} = argmax_{\theta} P(\theta | D)$$

위 식의 의미는 Maximum a posteriori 즉, 사후 분포에서 최고점의 값이므로, 사후분포에 $argmax$ 가 붙어있다고 이해하면 된다.

$$ P(\theta | D)\propto \theta^{a_{H}} (1 - \theta)^{a_{\tau}} \theta^{\alpha - 1} (1-\theta)^{\beta -1}$$

$$\hat{\theta} = \frac{a_{H}+\alpha -1}{a_{H} + \alpha + a_{\tau} + \beta - 2}$$

위 공식이 이해가 안되면 아래 MAP 정리 글을 읽고오자.

https://itforfun.tistory.com/242

머신 러닝 정리 1 - MLE, MAP 정리

베이즈는 이미 2번 정리를 했지만, 여러번 볼 수록 좋기에 한번 더 정리를 한다. Supervised Learning Unsupervised Learning Label이 있는 learning (분류, regression) label 없이 주어진 데이터로 패턴 파악(cl..

itforfun.tistory.com

MLE, MAP 를 이용한 Optimal Classification and Bayes Risk

2가지 클래스로 분류하기 위해 다음과 같은 pdf 가 있다고 하자. pdf 는 점선으로도, 실선으로도 표현이 가능하다. (추가적인 설명은 추후 기술된다.)

pdf 위의 한점 $x_1$ 에 대한 $p1, p2$는 더하면 1이 된다. (y, y 중 하나로 분류되어야 하므로)

해당 그래프에서 특이한 점은 파란점 $x_m$ 이다. 정확하게 0.5 로 나누어 떨어져 어느 한쪽으로 분류할 수 없다.

해당 지점을 decision boundary라 한다.

아무래도 점선, 실선 중에서 '분류의 측면'에서 봤을 때 실선이 다음의 이유로 효용성이 높다.

점선에 비해 실선이 더욱 큰 확률 차이로 클래스를 구분한다.
decision boundary를 기준으로 더욱 급격한 경사로 두 클래스를 명확하게 구분한다.

분류 과업은 조금이라도 확률이 더 높은 것을 선택한다. 즉, decision boundary 를 기준으로 왼쪽인 y 로 분류했다고 할 때 왼쪽에 존재하는 빨간색 영역은 error 이다.

이러다보니 점선보다 실선의 경우 error 영역이 (아래 표시된 영역 만큼) 더 작으므로 실선을 선택하는 것이 더 유익하다.

error 영역을 bayes risk 라 한다.

위 내용으로 살펴봤을 때, optimal classifier 는 bayes risk 이라고 불리는 error 영역을 줄이는 것을 목표로 한다.

즉, error 영역을 줄이기 위해 linear 한 pdf를 어떻게든 S 커브 형태로 만들려고 한다.

가장 대표적인 것은 우리가 잘 아는 logistic function 이다.

logistic function을 직접적으로 다루기 전에 좀 더 개념 이해에 초점을 맞춰서 살펴보자.

먼저 주어진 데이터만을 가지고서 확률을 이용해서 위와 같은 S 커브 만들어보고, 커브가 classifier 의 성능을 어떻게 높히고 있는지 보자.

$f^* = argmax_{Y=y} P(Y = y | X = x)$

위 공식은 데이터에서 주어진 Y 와 예측한 y 가 최대한 같은 값이 되는 확률을 만드는 근사 함수를 뜻한다.

이 공식은 bayes theorem 을 이용하여 아래와 같이 정리할 수 있다.

$= argmax_{Y=y} P(X = x | Y = y) P(Y = y)$

$P(Y = y)$ : Class Prior = Prior

문제는 Likelihood 경우 $x$ 변수의 개수에 따라 계산이 복잡해진다.

예를 들어 키에 따른 여자 친구 유무의 경우 처리가 변수가 1개여서 간단하지만,

키, 나이, 재산, 지역, 종교 등 변수의 개수가 여러개일 때는 각 변수의 interaction이 복잡할 수 있어 이 때는 likelihood 계산이 어렵다.

이에 따라 Navie Bayes classifier 이 제안되었다.

Navie Bayes classifier

주어진 X(날씨정보)를 통해 Y(외출 여부)를 판별하는 과업이 있다고 가정하자.

$f^* = argmax_{Y=y} P(X=x|Y=y)P(Y=y)$

위 식은 $f^* = argmax_{Y=y} P(Y=y | X=x)$ 를 bayes therom 으로 정리한 것이다.

위 정리한 식이 실제 사례에 적용 가능한지 확인해보자.

$P(X=x | Y=y)$

$= P(x_1 = \textrm{sunny}, x_2 \textrm{warm}, x_3 = \textrm{normal}, x_4 = \textrm{strong}, x_5 = \textrm{warm}, x_6 = \textrm{same} | y=\textrm{Yes})$

$P(Y=y) = (y = \textrm{Yes})$

Prior 는 구하기 쉽다.

Yes: $\frac{3}{4}$

No : $\frac{1}{4}$

그러나 class conditional density 인 likelihood 의 계산은 좀 복잡하다.

위에서 잠시 언급했지만 class conditional density를 계산하기 위하여 몇개의 parameters 가 필요할까? 그리고 몇개의 관측치가 필요할까?

Prior 는 $P(Y=y) \,\, \textrm{for all y})$ 로 (클래스 개수 - 1) 즉 여기서는 1개의 parameter 만 필요하다.

하지만 $P(X=x | Y=y) \,\, \textrm{for all x,y}$ 는 각 $x_i$ 마다 2개의 선택지만 있다고 해도 $(2^4 - 1)$ * class 개수 (k개) 만큼이나 필요하다. 실제로 좀 더 복잡해지는 상황에서는 사용이 불가능하다.

$f^* = argmax_{Y=y} P(X=x|Y=y)P(Y=y)$

현실 세계를 근사한 다음의 함수는 parameter의 수가 많다보니 현실세계를 잘 반영하기 위해서는 아주 큰 데이터가 필요하다.

즉, 위 함수(joint probability distribution) 를 어떻게든 조정을 해야만 한다.

문제 구간은 다음과 같다.

$P(X=x | Y=y) \,\, \textrm{for all x,y} \rightarrow (2^d -1)k$

당연히 귀중한 data를 줄이는 것은 고려사항이 아니다. (데이터의 귀함)

파라미터 개수에 대한 보충 설명

https://itforfun.tistory.com/254

머신러닝 정리 7.5(2) - Naive Bayes는 Generative Model

itforfun.tistory.com

Conditional Independence

X 의 각 feature 들이 독립적이라고 가정 하여 연산 수를 줄이는 방법이다.

$P(X = < x_1, ... , x_i> | Y =y) \rightarrow \prod_i P(X_i = x_i | Y = y)$

예를 들어 여자친구가 입고오는 옷을 class variable 이라고 가정해보자. 이 때 X 는 키, 몸무게, 그날의 기분, 옷의 불편도라 하자.

여자친구는 기분이 별로면 편한 옷을 입고 오는 경향이 있다. 이 말인 즉슨, 기분과 옷의 불편도는 높은 상관관계가 있다는 뜻이다.

즉 독립이라 가정하는 것이 실제 상황에서는 어렵다. 그럼에도 불구하고 직접 계산하는 것은 $2^d - 1$ 만큼의 계산이 필요하기에 억지스럽고 naive 하게 가정하여 처리하는 것이 naive bayse classifier 이다.

conditional independence는 아래와 같이 표기한다.

$( \forall x_1, x_2, y) $. $P(x_1|x_2, y) = P(x_1|y)$

$x_2$ 가 주어져도 주어지지 않은 것과 확률이 같다.

$P(x_1, x_2|y) = P(x_1|y) P(x_2|y)$

위와 같이도 적을 수 있다. 우리에게 좀 더 익숙한 표기이다.

예를들면 아래와 같다.

$P(\textrm{Thunder|Rain, Lightning}) = P(Thunder|Lightening) $

Conditional 와 Marginal Independece 차이

각 independence 를 설명하기 전에 각 conditional, marginal probability 가 뭔지 간단하게 살펴보자.

Marginal Distribution 은 이전 글에서 언급한 주변 확률 분포이므로 사실 글을 읽고 아래부분을 스킵하고 넘어가도 된다.

다음 3개의 binary random 변수가 있다고 가정하자. P (H,S,F)

$H (심장병) \,\, \textrm{domain}(H) = {h, \neg h}$
$S (담배) \,\, \textrm{domain}(H) = {s, \neg s}$
$F (비만) \,\, \textrm{domain}(H) = {f, \neg f}$

각 조건에 따른 확률이 아래와 같을 때

Marginalization 은 아래와 같다.

$$P(H,S) = \sum_{x \in \textrm{domain}(F)} P(H,S,F = x)$$

$$P(H) = \sum_{x \in \textrm{domain}(S, F)} P(H,S = y, F = x) $$

$$P(S) = \sum_{x \in \textrm{domain}(H, F)} P(H = z,S, F = x) $$

반면에 conditional probability 는

$$P(S|H) = \frac{P(S,H)}{P(H)}$$

즉, H 가 일어났다고 가정하기에 그냥 $P(S,H)$ 와는 차이가 있다.

또한 H 가 일어났을 때, S 의 경우는 일어나거나 안 일어나거나이므로, 합쳐서 값이 1 이다.

아래 chain rule 을 살펴보면 흥미로운 사실을 알 수 있다.

$$P(H,S,F) = P(H) \times P(S|H) \times P(F| H,S) $$

$$= P(H) \times \frac{P(S,H)}{P(H)} \times \frac{P(S,H,F)}{ P(S,H)}$$

약분 되어 $P(S,H,F)$ 만 남는 것을 볼 수 있다.

베이즈 정리도 살펴보자.

$$P(S|H) = \frac{P(S,H)}{P(H)}, \,\, P(H|S) = \frac{P(S,H)}{P(S)} $$

위 식에서 두번째 식을 다시 쓰면

$$P(H|S) \times P(S) = P(S,H)$$

해당 식을 위의 첫번째 식에 대입하면 아래와 같이 정리된다.

$$P(S|H) = \frac{P(H|S) P(S)} {P(H)}$$

Marginal Independence

Y 값 에 대한 정보가 X 값에 대한 믿음에 영향을 전혀 끼치지 않는 경우에 우리는 랜덤 변수 X 가 랜덤 변수 Y에 대해 marignal independence 하다고 말한다.

간단하게 아래와 같이 적을 수 있다.

$$\textrm{if, for all } x_i \in dom(X), y_k \in dom(Y), P(X= x_i | Y = y_k) = P(X= x_i) $$

그리고 이건 아래와 같이 정리될 수 있다.

$$P(X) = P(X|Y) = \frac{P(X,Y)}{P(Y)}$$

이는 또 아래와 같이 정리될 수 있다.

$$P(X) \times P(Y) = \frac{P(X,Y)}{P(Y)} \times P(Y)$$

$$P(X)P(Y) = P(X,Y)$$

$$P(X) \times P(Y) \times \frac{1}{P(X)} = \frac{P(X,Y)}{P(Y)} \times \frac{1}{P(X)} \times P(Y)$$

$$P(Y|X) = P(Y)$$

2번식을 참고해서 실제 예시를 들어보자.

$$P(치통, 검진, 충치, 날씨) = P(치통, 검진, 충치) P(날씨)$$

아까 잠시 살펴보았던 심장병, 담배 예시를 살펴보자.

P(S) 와 P(S|H) 결과 값이 다르므로 서로 marginally independece 하지 않다.

한마디로 marginal independence는 우리가 평상시에 생각하는 독립이다.

Conditional Independence

그러나 위에서 살펴봤듯이 marginal independence는 $O(2^n)$ 의 복잡도를 가진다.

이에 따라 좀더 약한 독립 가정인 conditional independence 를 사용한다 .

아래의 예시를 살펴보자.

P(치통, 충치, 검진 성공)

충치와 검진 성공이 marginally independent 하지는 않다.

그러나 만약 내가 충치를 가지고 있다 할 때, 내가 치통의 유무에 따라 검진 성공 여부가 달라질까? 그렇지 않다.

1) $P(검진성공 | 치통, 충치) = P(검진성공 | 충치)$

만약 충치가 없다해도 마찬가지이다.

2) $P(검진성공 | 치통, \neg 충치) = P(검진성공 | \neg 충치)$

치통이나 검진성공여부는 충치가 있을 때 둘다 일어나는 일이지만, 치통과 검진성공 여부는 서로 직접적인 영향이 없다.

즉, 충치라는 상태가 주어졌을 때 검진의 성공 여부는 치통과 conditionally independent 하다.

$$P(\textrm{검진성공 | 치통, 충치}) = P(\textrm{검진성공 | 충치})$$

$$P(\textrm{치통 | 검진성공, 충치}) = P(\textrm{치통 | 충치})$$

$$P(\textrm{치통, 검진성공 | 충치}) = P(\textrm{치통 | 충치})P(\textrm{검진성공 | 충치}) \rightarrow P(X, Y |Z) = P(X|Z)P(Y|Z)$$

바로 세 번째 식은 조금 생소한데, 이에 대한 아래 증명을 참고하자.

즉, 두 변수가 marginally independent 하지 않더라도, 3번째 변수를 관측한 결과로써, 두 변수가 독립이 될 수 있다.

정의는 다음과 같다.

랜덤 변수 X 는 랜덤 변수 Z 가 주어졌을 때, Y에 대하여 conditionaly independent 하다.

$$\textrm{if, for all } x_i \in domain(X), y_k \in domain(Y), z_m \in domain(Z) \,\, P(X = x_i, Y = y_k, Z = z_m) = P(X=x_i, Z = z_m)$$

즉, Z 에 대한 정보가 주어졌을 때, Y의 값은 X 에 대한 믿음에 영향을 주지 못한다.

conditional independence 를 사용하면 joint distribution 의 표현 크기를 획기적으로 줄여준다. (exponential n $\rightarrow$ linear n )

$P(치통 | 검진성공, 충치) P(검진성공 | 충치) P(충치)$

marginally indepedent 하면 모두 독립이므로

$P(치통) \times P(검진성공) \times P(충치)$

conditionally independent 하면

$P(치통| 충치) \times P(검진성공 | 충치) \times P(충치)$

참고글

https://www.cs.ubc.ca/~carenini/TEACHING/CPSC322-10/SLIDES/lecture26-2010.pdf

Navie Bayes classifier

$f^* = argmax_{Y=y} P(X=x|Y=y)P(Y=y)$

기존 joint 과정에서 필요하던 parameter의 개수가 $2^d -1$ 였다.

여기에 모든 $x_1 ... x_6$ 에 conditional indepdent assumption 을 적용해보자.

$P(Y=y)$ prior 파트는 변함이 없다.

하지만 $P(X=x|Y=y)$ 해당 파트는 아래와 같이 곱샘으로 변하게 된다.

$\prod_{1 \leq i \leq d} P(X_i = x_i | Y = y)$

$$f^* \approx argmax_{Y=y}P(Y=y)\, \prod_{1 \leq i \leq d} P(X_i = x_i | Y = y)$$

개수는 $(2-1)dk = dk$ 개로 줄어들게 된다. (d: feature 개수 k: prior 개수(answer))

conditional independent assumption 은 당연히 틀리다. 그럼에도 너무 많은 파라미터 학습을 피하기 위한 어쩔 수 없는 선택이다.

가정 자체가 너무 약하다보니 Naive Bayes Classifier 라 명칭하였다.

Given:

Class Prior P(Y)

d conditionally independent features X given the class Y

For each $X_p$ we have the likelihood of $P(X_i | Y)$

Naive Bayes Classifier Function

$f_{NB}(x) = argmax_{Y=y} P(Y=y) \, \prod_{1 \leq i \leq d} P(X_i = x_i | Y = y)$

Naive Bayes Classifier 도 output의 bayes risk를 줄이려고 한다는점에서 optimal classifier 긴 하다.

Navie Bayes Problems

1. Naive 가정

현실에서 통용되지 않는 가정이다.

2. 부정확한 확률 측정

관측못한 sparse 한 Input 케이스가 있는 경우에 관측을 못한다. navie bayes classifier 가 이때는 동작하지 못한다. 이로 인해 MLE 보다는 MAP 를 사용해서 개별 확률 값을 만들어줘야 한다.

MLE 는 관측되지 않은 내용에 대해 estimation이 제대로 안된다. 이로 인해 MAP 를 통해 사전 정보라도 줘서 계산을 해야한다.

한번도 관측되지 않은 상태에 대하여 MLE 로 예측하면 확률값이 0 이 된다.

Application

Naive Bayes Classifier 의 실제 적용 사례를 살펴보며 익숙해지자.

예시는 아래에서 참고하였다.

https://www.datacamp.com/tutorial/naive-bayes-scikit-learn

Naive Bayes Classifier Tutorial: with Python Scikit-learn

Sklearn Naive Bayes Classifier Python. Learn how to build & evaluate a Gaussian Naive Bayes Classifier using Python's Scikit-learn package.

www.datacamp.com

1. feature가 한개인 경우

날씨에 따라 나가 놀지 여부를 결정하는 데이터이다.

날씨가 Overcast 인 날, 나가노는지 여부를 알고싶다.

이에 따른 공식은 아래와 같다.

사전 정보를 활용한 MAP 기법으로 계산을 해보자.

여기서 사용된 사전 정보란, 평상시에 얼마나 자주 나가 노는지에 대한 여부 정도가 될 수 있다.

날씨가 Overcast 인 날, 나가 놀 확률

P(Yes | Overcast) = P(Overcast | Yes) P(Yes) / P (Overcast)

1. Prior 확률 구하기:

P(Overcast) = 4/14 = 0.29

P(Yes)= 9/14 = 0.64

2. Posterior 확률 구하기:

P(Overcast |Yes) = 4/9 = 0.44

나가 논 날 줄, 날씨가 overcast 일 확률

3. 계산하기:

P (Yes | Overcast) = 0.44 * 0.64 / 0.29 = 0.98(Higher)

즉, 날씨가 overcast 한 경우, 나가 놀 확률은 0.98 로 예측된다.

날씨가 Overcast 인 날, 나가 놀지 않을 확률

P(No | Overcast) = P(Overcast | No) P(No) / P (Overcast)

1. Prior 확률 구하기:

P(Overcast) = 4/14 = 0.29

P(No)= 5/14 = 0.36

2. Posterior 확률 구하기:

P(Overcast |No) = 0/9 = 0

나가 놀지 않은 날 중, 날씨가 Overcast 일 확률

3. 계산하기

P (No | Overcast) = 0 * 0.36 / 0.29 = 0

즉, 날씨가 overcadt 하지 않은 경우, 나가 놀 확률은 0 으로 예측된다.

이에 따라 나가 놀 확률이 훨씬 높다고 결정할 수 있다.

2. feature가 여러개인 경우

feature가 여러개인 경우 진가를 발휘한다.

날씨가 Overcast 하고, 온도가 Mild 한 날 나가놀지 아닐지를 분류해보자.

베이즈 공식에 따라 작성해보면 아래와 같다.

날씨가 Overcast 하고 온도가 Mild 할 때 나가 놀 확률

P(Play= Yes | Weather=Overcast, Temp=Mild) = P(Weather=Overcast, Temp=Mild | Play= Yes)P(Play=Yes)

1. Prior 확률 구하기:

P(Yes)= 9/14 = 0.64

2. Posterior 확률 요소 구하기:

P(Overcast |Yes) = 4/9 = 0.44 P(Mild |Yes) = 4/9 = 0.44

3. Posterior 확률을 계산하기:

P(Weather=Overcast, Temp=Mild | Play= Yes) = 0.44 * 0.44 = 0.1936(Higher)

4. 계산하기:

P(Play= Yes | Weather=Overcast, Temp=Mild) = 0.1936*0.64 = 0.124

날씨가 Overcast 하고 온도가 Mild 할 때 나가 놀지 않을 확률

P(Play= No | Weather=Overcast, Temp=Mild) = P(Weather=Overcast, Temp=Mild | Play= No)P(Play=No)

1. Prior 확률 구하기:

P(No)= 5/14 = 0.36

2. Posterior 확률 요소 구하기:

P(Weather=Overcast |Play=No) = 0/9 = 0 P(Temp=Mild | Play=No)=2/5=0.4

3. Posterior 확률을 계산하기:

P(Weather=Overcast, Temp=Mild | Play= No) = 0 * 0.4= 0

4. 계산하기:

P(Play= No | Weather=Overcast, Temp=Mild) = 0*0.36=0

확률 비교를 통해 Overcast 날씨와 Mild 온도에 나가노는 것으로 확인되었다.

feature가 1 개일 때는 분모가 존재했는데 feature가 여러개가 되고, conditional independence를 가정하자 갑자기 분모가 사라졌다.

위 내용을 recall 해 보면,

$f^* = argmin_f P(f(X) \neq Y)$

$f^* = argmax_{Y-y} P(Y = y | X = x)$

Bayes Theorem 에 의해 아래와 같이 정리했다.

$= argmax_{Y=y} P(X = x | Y = y) P(Y = y)$

사실 조건부 확률에 따르면 아래 인것이 자명하다.

$P(Y | X) = \frac{P(X|Y) P(Y)} {P(X)}$

그럼 왜 분모를 생략하게 되었을까?

오랜 고민끝 아래의 결과에 이르렀다.

argmax_{Y=y} 에서 분모는 상수이다.

상수를 생략해도 Y가 나올 확률을 최대화 하는 상황은 같으므로 생략한 것으로 보인다.

아래는 위키백과를 참고하였다.

베이즈 정리의 분모에 해당하는 부분은 가능도를 구할 때 조건으로 걸린 사건(위의 예의 경우, (실제 병의 유무와는 상관 없이) '양성 판정이 나올 확률')의 확률이다. 기능적으로는 사후 확률이 확률의 정의(0 이상 1 이하여야 한다)를 충족시키도록 사전확률과 가능도의 곱을 보정해주는 역할을 한다. 위와 같은 예에서는 쉽게 계산할 수 있고 엄밀하게 사후확률을 구하려면 반드시 필요한 부분이지만, 실제로 생각보다 계산이 까다로울 경우 등식을 비례 관계로 바꾸고 생략할 수도 있다.

즉, 분류에 있어서 분모는 중요하지 않다. 그리고 애초에 conditional indenpendence 가정 자체가 확률을 구할 때 정확하지 않지 않은가?

[프로그래머스] 구현 - 거리두기 확인하기

알 수 없는 사용자 — Thu, 6 Oct 2022 17:22:28 +0900

문제 설명

개발자를 희망하는 죠르디가 카카오에 면접을 보러 왔습니다.

코로나 바이러스 감염 예방을 위해 응시자들은 거리를 둬서 대기를 해야하는데 개발 직군 면접인 만큼
아래와 같은 규칙으로 대기실에 거리를 두고 앉도록 안내하고 있습니다.

대기실은 5개이며, 각 대기실은 5x5 크기입니다.

거리두기를 위하여 응시자들 끼리는 맨해튼 거리1가 2 이하로 앉지 말아 주세요.

단 응시자가 앉아있는 자리 사이가 파티션으로 막혀 있을 경우에는 허용합니다.

예를 들어,

위 그림처럼 자리 사이에 파티션이 존재한다면 맨해튼 거리가 2여도 거리두기를 지킨 것입니다.	위 그림처럼 파티션을 사이에 두고 앉은 경우도 거리두기를 지킨 것입니다.	위 그림처럼 자리 사이가 맨해튼 거리 2이고 사이에 빈 테이블이 있는 경우는 거리두기를 지키지 않은 것입니다.

응시자가 앉아있는 자리(P)를 의미합니다.	빈 테이블(O)을 의미합니다.	파티션(X)을 의미합니다.

5개의 대기실을 본 죠르디는 각 대기실에서 응시자들이 거리두기를 잘 기키고 있는지 알고 싶어졌습니다. 자리에 앉아있는 응시자들의 정보와 대기실 구조를 대기실별로 담은 2차원 문자열 배열 places가 매개변수로 주어집니다. 각 대기실별로 거리두기를 지키고 있으면 1을, 한 명이라도 지키지 않고 있으면 0을 배열에 담아 return 하도록 solution 함수를 완성해 주세요.

제한사항

places의 행 길이(대기실 개수) = 5
- places의 각 행은 하나의 대기실 구조를 나타냅니다.
places의 열 길이(대기실 세로 길이) = 5
places의 원소는 P,O,X로 이루어진 문자열입니다.
- places 원소의 길이(대기실 가로 길이) = 5
- P는 응시자가 앉아있는 자리를 의미합니다.
- O는 빈 테이블을 의미합니다.
- X는 파티션을 의미합니다.
입력으로 주어지는 5개 대기실의 크기는 모두 5x5 입니다.
return 값 형식
- 1차원 정수 배열에 5개의 원소를 담아서 return 합니다.
- places에 담겨 있는 5개 대기실의 순서대로, 거리두기 준수 여부를 차례대로 배열에 담습니다.
- 각 대기실 별로 모든 응시자가 거리두기를 지키고 있으면 1을, 한 명이라도 지키지 않고 있으면 0을 담습니다.

문제 자체는 이해가 빨리 되었으나 구현에서 좀 더 효율적으로 짜기위해 고민하다가 시간을 많이 썼다.

나와 동일한 알고리즘 이나 더 보기 좋게 짠 코드

def solution(places):
    answer = [];
    
    #place를 하나씩 확인
    for p in places:
        
        #거리두기가 지켜지지 않음을 확인하면 바로 반복을 멈추기 위한 key
        key = False;
        nowArr = [];
        
        #이번 place를 nowArr에 담아줍니다.
        for n in p:
            nowArr.append(list(n));
        
        #이중 for문을 이용해 하나씩 확인합니다.
        for i in range(5):
            if key:
                break;
                
            for j in range(5):
                if key:
                    break;
                
                #사람을 찾아내면 판단을 시작합니다.
                if nowArr[i][j] == "P":
                    
                    if i+1<5:
                    	#만약 바로 아랫부분에 사람이 존재하면 break
                        if nowArr[i+1][j] == "P":
                            key = True;
                            break;
                        #만약 아랫부분이 빈테이블이고 그 다음에 바로 사람이 있다면 한칸 떨어져 있더라도 맨허튼 거리는 2이므로 break
                        if nowArr[i+1][j] == "O":
                            if i+2<5:
                                if nowArr[i+2][j] == "P":
                                    key = True;
                                    break;
                    #바로 오른쪽 부분에 사람이 존재하면 break    
                    if j+1<5:
                        if nowArr[i][j+1] == "P":
                            key = True;
                            break;
                         #만약 오른쪽 부분이 빈테이블이고 그 다음에 바로 사람이 있다면 한칸 떨어져 있더라도 맨허튼 거리는 2이므로 break   
                        if nowArr[i][j+1] == "O":
                            if j+2<5:
                                if nowArr[i][j+2] == "P":
                                    key = True;
                                    break;
                    #우측 아래 부분입니다.
                    if i+1<5 and j+1<5:
                    	#만약 우측 아래가 사람이고, 오른 쪽 또는 아랫부분중 하나라도 빈테이블이면 break
                        if nowArr[i+1][j+1] == "P" and (nowArr[i+1][j] == "O" or nowArr[i][j+1] == "O"):
                            key = True;
                            break;
                    
                    #좌측 아래부분입니다.
                    if i+1<5 and j-1>=0:
                    	#만약 좌측 아래가 사람이고, 왼쪽 또는 아랫부분중 하나라도 빈테이블이면 break
                        if nowArr[i+1][j-1] == "P" and (nowArr[i+1][j] == "O" or nowArr[i][j-1] == "O"):
                            key = True;
                            break;
        
        #위의 for문동안 key가 True로 변경되었다면 거리두가기 지켜지지 않은것 이므로 0을 answer에 추가
        if key:
            answer.append(0);
        else:
        #key가 false로 끝났다면 거리두기가 지켜졌으므로 1 추가
            answer.append(1);

    #끝!
    return answer;

def check(data, y, x):
    dx = [1,0,-1]
    dy = [0,1,0]
    mark = [0,0,0,0] 
    tmp = False 
    
    for i in range(3):
        nx = x + dx[i]
        ny = y + dy[i]
        if 0 <= ny < len(data) and 0 <= nx < len(data[0]):
            if data[ny][nx] == 'P':
                return False 
            elif data[ny][nx] == 'X':
                mark[i] = 1 
            elif data[ny][nx] == 'O' and dx[i] | dy[i] > 0:
                if ny + dy[i] < len(data) and nx + dx[i] < len(data[0]):
                    if data[ny + dy[i]][nx + dx[i]] == 'P':
                        return False 
    
        if i == 1:
            if mark[i] & mark[i-1] != 1:
                if 0 <= y + 1 < len(data) and 0 <= x + 1 < len(data[0]):
                    if data[y+1][x+1] == 'P':
                        return False       
        elif i == 2:
            if mark[i] & mark[i-1] != 1:
                if 0 <= y + 1 < len(data) and 0 <= x - 1 < len(data[0]):
                    if data[y+1][x-1] == 'P':
                        return False 
        
    return True
                

def solution(places):
    ans = []
    for place in places:
        tmp = 1 
        for i, row in enumerate(place):
            for j, element in enumerate(row): 
                if element == 'P':
                    tmp = tmp & check(place, i, j)
        if tmp == 1:
            ans.append(1)
        else:
            ans.append(0)

        
    return ans

잘 살펴보면 똑같은 과정이나 내 구현은 이래저래 실수할 여지가 좀 더 많이 보인다.

추가적으로 dx, dy 를 따로 선언하지 않고 필요한 부분들을 직접 더하고 빼서 접근하니 보기 좋다.

계속 몇 개의 특별 케이스를 통과하지 못했는데 그 케이스는 다음과 같았다.

처음에 확인해야 할 영역을 오른쪽, 아래, 2칸 오른쪽, 2칸 아래, 대각 (오른쪽) 이라고 생각했는데,

알고보니 대각 (왼쪽) 도 고려 대상이다. 앞으로는 이런 케이스들을 놓치지 않기 위해서 좀 더 hard 한 case 를 상상해보며 구현 계획을 먼저 짜야겠다.

머신 러닝 정리 5 - Linear Regression

알 수 없는 사용자 — Thu, 6 Oct 2022 02:32:08 +0900

머신러닝은 궁극적으로 우리가 찾고자 하는 함수를 근사하는 것이다.

Linear Regression 은 그 중 아주 간단하고, 강력한 방법론 중 하나이다.

이름 그대로 linear 한 형태로 함수를 근사한다.

우리의 가설은 아래와 같다.

$h : \hat{f}(x ; \theta) = \theta_0 + \sum^{n}_{i=1} \theta_i x_i = \sum^{n}_{i=0} \theta_i x_i$

n 은 feature value 의 개수이다.

linear를 유지해야 하기 때문에 $x$ 는 건들지 않고 $\theta$ 값을 잘 조정하여 함수를 근사한다.

($x$를 건들지 않고에 대해 이해가 잘 안간다면 일단 $x$ 는 관측 데이터라 생각만 하고 넘어가자.)

그 전에 공식을 정리해보자.

$ \theta_0 + \sum^{n}_{i=1} \theta_i x_i = \sum^{n}_{i=0} \theta_i x_i$

위에서 $\theta_0$ 를 정리하고, 식을 $\hat{f} = X\theta$ 로 간소화하기 위하여 아래와 같이 정리한다.

$X = \begin{pmatrix} 1 & \cdots & x^1_{n} \\ \vdots & \ddots & \vdots \\ 1 & \cdots & x^D_{n} \end{pmatrix} , \theta = \begin{pmatrix} \theta_0 \\ \theta_1 \\ \cdots \\ \theta_n \end{pmatrix}$

현실은 noisy 하다. 이에 따라 true 값은 예상치 못한 error 을 포함해야한다.

$f(x;\theta) = \sum^{n}_{i=0} \theta_i x_i + e = y \rightarrow f = X\theta + e = Y$

하지만 우리가 근사하는 함수는 error를 반영할 수 없으므로 $\hat{f}$ 로 표기한다.

$\hat{\theta} = argmin_\theta (f - \hat{f})^2 = argmin_\theta (Y - X\theta)^2$

이미 데이터 X 와 결과값 Y 는 제공되어 있다. 우리가 모르는 값은 $\theta$ 이기에 해당 값만 구해주면 된다.

$ = argmin_\theta (Y - X\theta)^T(Y - X\theta) = argmin_\theta(\theta^T X^T X\theta - 2 \theta^T X^T Y + Y^T Y)$

$Y^T Y$ 는 상수이므로, 빼고 고려할 수 있다.

$ argmin_\theta(\theta^T X^T X\theta - 2 \theta^T X^T Y)$

위 식을 최적화 하기 위해서는 극점을 찾도록 $\theta$에 대해 미분을 수행하면 된다.

$\nabla _\theta (\theta^T X^T X\theta - 2 \theta^T X^T Y) = 0$

$2X^T X\theta - 2X^T Y = 0$

위 미분 과정을 아래 짧게 서술한다.

※ 스칼라함수를 벡터로 미분한 경우

$\frac{\partial}{\partial x}(x^T A x) = x^T(A^T + A)$

$A = X^T X$ 로 치환하여 적용하면

$\theta^T X^T X\theta = \theta^T A \theta$

$ \theta^T (X^T X + X^T X) = 2 \theta^T(X^T X)$

$\frac{\partial}{\partial x}(a^T x) = \frac{\partial}{\partial x}(x^T a) = a^T$

$-2\theta^T X^T Y = -2 X^T Y$

따라서, $\theta = (X^T X)^{-1} X^T Y$

X,Y 를 앎므로 $\theta $ 를 구할 수 있다.

Housing dataset

https://archive.ics.uci.edu/ml/machine-learning-databases/housing/

Index of /ml/machine-learning-databases/housing

archive.ics.uci.edu

13 numerical independent values
1 numerical dependent value

위와 같은 데이터 셋이 있다고 하자.

13개의 Housing feature 중 한가지만을 사용하여 나타낸 plot 이다.

$\theta = (X^T X)^{-1} X^T Y$

X 값과 Y 값 (빨간 점)을 통해 위 공식에서 $\theta$를 구한 후, X 값에 대한 $\hat{Y}$ 를 구한 결과(파란점) 이다.

feature 의 개수를 단지 dimension 을 올리는 것과 같은 방식으로 증가시켜볼 수 있다. (linear regression 에서는 x 를 건들지 않는다고 사전에 언급했었는데, dimension을 올리는 것이 x를 건든다는 것의 한 예이다.)

예를 들어 $x^2, x^3, x^4 ... $ 와 같이 x의 차원을 뻥튀기를 해보는 방법이다.

$h: \hat{f} (x; \theta) = \sum^{n}_{i=0} \sum^m_{j=1} \theta_{i,j} \phi_j (x_i)$

이 경우 위와 같이 현재 데이터에 대해서는 마치 관측이 잘 된 것 처럼 보이지만, overfitting 의 가능성이 높다는 것을 알 수 있다.

linear regression 은 아주 간단한 모델이지만, 실제 세상에서 데이터를 예측하는데 여전히 많이 사용되는 좋은 모델이다.

하지만, 당연히 linear 한 특성이 강점이 되기도 하지만, 많은 경우 제약이 되기도 한다.

머신 러닝 정리 4- Decision Tree

알 수 없는 사용자 — Wed, 5 Oct 2022 17:45:51 +0900

현실 세계에서는 rule base 가 완벽하게 동작하기 어렵다.

모든 결정이 consistent 한 것이 아니다. (오늘은 비가 오지만 나가고 싶을 수 있다.)
error 가 관측치에 있기도 하다.
모든 정보를 다 보기도 어렵다. (놓친 feature)

그렇다면 우선, error 가 있는 경우에 통계적 기법을 가미해서 learning 을 할 수 있는 방법은 무엇이 있을까?

Decision Tree 를 통해 가능하다.

사전 version space를 통해 만들어진 결과물로 decision tree 를 만들 수 있다.

http://archive.ics.uci.edu/ml/datasets/Credit+Approval

UCI Machine Learning Repository: Credit Approval Data Set

archive.ics.uci.edu

에서 credit card approval 데이터 셋을 얻을 수 있다.

690 Instances total
307 positive instance

credit card 신청인 총 690 인 중, 307 명만 허가된 데이터 셋이다.

A1 ~ A15 features

A1: b, a.
A2: continuous.
A3: continuous.
A4: u, y, l, t.
A5: g, p, gg.
A6: c, d, cc, i, j, k, m, r, q, w, x, e, aa, ff.
A7: v, h, bb, j, n, z, dd, ff, o.
A8: continuous.
A9: t, f.
A10: t, f.
A11: continuous.
A12: t, f.
A13: g, p, s.
A14: continuous.
A15: continuous.
A16: +,- (class attribute)

A1 feature

98 positive when a
112 negative when a
206 positive when b
262 negative when b
3 positive when ?
9 negative when ?

...

A9 feature

284 positive when t
77 negative when t
23 positive when f
306 negative when f

...

A1 으로만 판결을 내리면 아래와 같다.

A1 의 특성만으로 판결을 내리는 것은 무리가 있다.

A9 특성을 사용하면 A1 보다는 더 좋은 결과를 내나, 여전히 많이 틀리긴 한다.

이제 본격적으로 Decision Tree 를 살펴보자.

드디어 Entropy에 대해 정리할 기회가 왔다.

Entropy

어떤 특성을 더 잘 확인할 수 있을지 알려주는 지표

머신 러닝에서 중요한 목표중 하나는 바로 uncertainty 를 줄이는 것이다.

(A1 보다 A9 의 uncertainty 가 적은건 자명해보인다.)

이러한 uncertainty 는 어떻게 정량화 할 수 있을까?

entropy 가 높을 수록 uncertainty도 높다.

엔트로피에 대한 정리

https://bskyvision.com/389

[정보이론] 정보량과 엔트로피의 의미

정보이론은 신호에 존재하는 정보의 양을 측정하는 이론이다. 정보이론의 핵심은 잘 발생하지 않는 사건은 자주 발생하는 사건보다 정보량이 많다는 것이다. 정보량이란 우선 정보이론에서 '정

bskyvision.com

https://memesoo99.tistory.com/38

Information Theory 이해하기 - 정보량과 Entropy

딥러닝을 공부하다보면 KL-divergence, JSD-divergence같이 확률분포를 판단하는 척도들을 종종 접하게 된다. 그리고 그런 척도들의 기본이론이 바로 Information Theory, 정보이론이다. 정보량 정보이론의

memesoo99.tistory.com

3줄 정리

1. 정보량: 놀람의 정도 수치화, 단일 사건에 대한 정보량

$$I(x_j) = -\log_a p(x_j)$$

확률이 1에 가까워 질 수록 정보량은 0, 0에 가까워 질 수록 무한대로 수렴 즉 확률이 낮을 수록 놀랍다. (놀랍다 = 정보량이 많다.)

2. 엔트로피는 어떤 사건에 대한 확률 분포의 정보량

$$\sum^N_{i=1} -P(x_i)\log P(x_i)$$

각 사건의 정보량 $I(a)$ 에해당 정보가 등장할 확률$P(a)$를 곱해준다(사건을 표현하기 위해 요구되는 평균 자원)

Entropy H

Features 은 random variables 이다.

$H(X) = - \sum_x P(X=x) \log_a P(X=x)$

Joint Entropy

결합 entropy 는 의미도 이름 그 자체라 어렵지 않다. 아래 링크 참고

https://bskyvision.com/604

[정보이론] 결합(joint) 엔트로피와 조건부(conditional) 엔트로피

결합(joint), 조건부(conditional)라는 단어는 확률에서 많이 쓰이는 용어다. 엔트로피 역시 확률을 이용한 것이므로 결합 엔트로피와 조건부 엔트로피가 존재한다. 엔트로피에 대해 잠시 복습하자.

bskyvision.com

Conditional Entropy

사전 지식

확률 질량 함수

이산 확률 변수의 확률 분포를 나타내는 함수

확률 밀도 함수

연속 확률 변수의 확률 분포를 나타내는 함수

결합 확률 질량 함수

두 이산 확률 변수 X, Y 가 각각 아래와 같이 존재할 때, X 가 $x_i$ 의 값을 갖고 Y 가 $y_j$의 값을 가질 확률은 다음과 같이 나타낼 수 있다.

$P( X = x_i, Y = y_j) = p_{i,j} (i = 1,2,3,4 ...,m, j = 1,2,3,4 ..., n)$

$p_{i,j}$ 를 이산확률변수 X,Y 의 결합 확률 질량 함수라 한다. X, Y 각각 특정한 값을 가질 때 확률을 뜻한다.

아래의 예시를 살펴보자

조건: 3개의 빨간 공, 2개의 노란 공, 4개의 초록 공이 들어있는 주머니
행위: 임의로 2개의 공을 꺼낸다.
뽑은 빨간 공의 개수: 확률변수 X, 뽑은 노란 공의 개수: 확률변수 Y
X,Y 로 이루어진 순서쌍: (0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (2, 0) 총 6개
분모는 9개중 2개를 뽑는 경우 즉, 9개 중 2개를 뽑는 가능성이 전체의 경우

1) 빨간 공 0개, 노란 공 0개, (초록 공 2개)를 뽑는 경우의 확률:

2) 빨간 공 0개, 노란 공 1개, (초록 공 1개)를 뽑는 경우의 확률:

3) 빨간 공 0개, 노란 공 2개, (초록 공 0개)를 뽑는 경우의 확률:

4) 빨간 공 1개, 노란 공 0개, (초록 공 1개)를 뽑는 경우의 확률:

5) 빨간 공 1개, 노란 공 1개, (초록 공 0개)를 뽑는 경우의 확률:

6) 빨간 공 2개, 노란 공 0개, (초록 공 0개)를 뽑는 경우의 확률:

결합확률분포표

모든 확률을 더하면 당연히 1이다.

결합 확률 밀도 함수

두 개의 연속확률변수 X와 Y가 존재할 때, X가 a이상 b이하이면서 Y가 c이상 d이하일 확률은 다음과 같이 나타낸다.

여기서 $f(x, y)$를 연속확률변수 X, Y의 결합확률밀도함수라고 부른다.

임의로 선택한 30세 성인의 키를 연속확률변수 X라고 하면 키가 170-175cm일 확률

$f(x)$는 연속확률변수 X의 확률밀도함수

30세 성인의 키가 170cm이상 175cm이하이면서 동시에 몸무게가 80kg 이상 85kg이하일 확률은 결합확률밀도함수를 사용

키와 몸무게는 완전히 독립적이라고 볼 수 없기 때문이다. 두 확률변수가 만약에 서로 통계적으로 독립이라면 아래와 같이 단순히 두 확률을 곱하는 것으로 확률을 구할 수 있다.

주변확률질량함수

질량이라는 단어로 이산확률변수와 관련된 것임을 알 수 있다.

두 개 확률변수의 결합확률질량함수가 주어진 상황에서 오직 한가지 확률변수의 확률함수만을 알고 싶은 경우가 있다. 이산확률변수 X, Y의 결합확률질량함수가 $p(x, y)$라고 하자. 이 결합확률질량함수로부터 알고 싶은 것이 오직 확률변수 X의 확률함수라면 Y에 대한 정보는 필요없다.

이산확률변수 X, Y의 결합확률질량함수가 주어진 상황에서 X와 Y의 주변확률질량함수는 각각 다음과 같이 구한다.

$p_X(x) = \sum_{all y} p(x, y)$

$p_Y(y) = \sum_{all x}p(x,y)$

즉 각 확률 변수가 특정한 값을 가질 때 다른 확률 변수가 가질 수 있는 모든 값들의 확률을 더한 것이다.

주변확률밀도함수

밀도라는 단어로 연속확률변수와 관련된 것임을 알 수 있다.

결합확률밀도함수도 마찬가지로 주어진 상황에서 오직 한가지 확률변수의 확률함수만을 알고 싶은 경우에 사용한다.

$f_X(x) = \int^{\infty}_{- \infty} f(x,y) dy$

$f_Y(y) = \int^{\infty}_{- \infty} f(x,y) dx$

예제를 통해 살펴보자. 아래와 같이 이산 확률 변수를 갖는 결합 확률 분포표가 있다고 하자.

주변확률 질량함수는 어떻게 구할까? 간단하게 X = 0 일 때, 가능한 모든 Y 의 값을 더해주면 X = 0 일때의 주변질량함수의 값이다.

정리하면 아래와 같다.

길고 긴 사전 배경을 살펴보았다. 이제 조건부 엔트로피에 대해 살펴보자.

표현식은 아래와 같다.

$H(Y | X) = \sum_{x} p_{X}(x)H(Y|X = x) = \sum_{x}p_{X}(x)\sum_{y}p_{Y|X}(y|x)\log_2 \frac{1}{p_{Y|X}(y|x)}$

X가 주어졌을 때 Y의 엔트로피 $H(Y|X)$

식만 주어졌을 때는 도통 감이 안온다. 아래를 통해 살펴보자.

특정 상황에 대한 결합 분포표를 통해 주변 확률질량함수를 구했다.

$H(Y|X)$

$H(X|Y)$

H(Y|X)와 H(X|Y)는 일반적으로 다른 값을 갖는다.

위와 같이 수식으로 보면 이해가 좀 어렵다. 아래의 예시를 살펴보자.

(아래 예시는 https://wooono.tistory.com/104 블로그의 내용을 발췌했음을 밝힘)

Decision Tree 를 구성 단계

decision tree 를 구성하는 방식은 다양하다. 그러하니 여기서는 가장 간단한 ID3 algorithm 을 다룬다.

Root 노드의 불순도 계산
나머지 속성에 대해 분할 후 자식노드의 불순도 계산
각 속성에 대한 Information Gain 계산 후 Information Gain(Root노드와 자식노드의 불순도 차이)이 최대가 되는 분기조건을 찾아 분기
모든 leaf 노드의 불순도가 0이 될때까지 2,3을 반복 수행한다.

※ Information Gain 이란?

분기 이전의 불순도와 분기 이후의 불순도의 차이를 정보 획득이라 한다.

불순도가 1인 상태에서 0.7인 상태로 바뀌었다면 정보 획득(information gain)은 0.3이다. 아래의 예시를 통해 경험적으로 개념을 습득해보자.

※ 불순도란?

분기기준을 선택하기 위해서는 불순도(impurity)라는 개념을 사용. 복잡성을 의미하며, 해당 범주 안에 서로 다른 데이터가 얼마나 섞여 있는지를 뜻한다.

Entropy, Gini 등 여러 함수가 해당 될 수 있다. (Entropy Gini 차이: Gini 가 속도가 더 빠르나, Entropy 가 비교적 정확하게 분류한다고 알려져있다.)

1. Root 노드의 불순도 계산

경기의 참가 여부로 먼저 Root 노드를 설정한다.

2. 나머지 속성에 대해 분할 후 자식노드의 불순도 계산

날씨
온도
습도
바람

3. 각 속성에 대한 Information Gain 계산 후 Information Gain(Root노드와 자식노드의 불순도 차이)이 최대가 되는 분기조건을 찾아 분기

4. 모든 leaf 노드의 불순도가 0이 될때까지 2,3을 반복 수행한다.

예를 들어, "맑음"으로 분류된 노드는 "날씨 = 맑음" 인 데이터만 가지고 와서 다시 분할 전 엔트로피를 계산한다.

최종결과

일반화

깊어질 수록 train,test 셋에 대한 accuracy

위 구성방법을 사용하여 트리를 형성하게 되면, leaf 노드가 순도 100%의 한가지 범주만을 가지게 되는 Full tree(최대 트리)를 형성하게 된다.

하지만 이러한 최대 트리는 새로운 데이터에 적용할 때 과적합 문제(Overfitting)가 발생하여 일반화 성능이 떨어지게 된다.

따라서 형성된 결정트리에 대해 가지치기(Pruning)를 수행하여 일반화 성능을 높힌다.

가지치기 (pruning)

가지치기란 최대트리로 형성된 결정트리의 특정 노드 밑의 하부 트리를 제거하여 일반화 성능을 높히는 것을 의미한다. (오버피팅을 막기위해 사용된다.)
더 많은 가지가 생기지 않도록 최대 깊이, leaf 노드의 최대 개수, 한 노드가 분할하기 위한 최소 데이터 수 등의 제한이 가능하다.

가지치기의 비용함수

의사결정나무는 아래 비용함수를 최소로 하는 분기를 찾아내도록 학습된다.
$CC(T) = Err(T) + \alpha × L(T)$

$CC(T)$
- 의사결정나무의 비용 복잡도
- 오류가 적으면서 terminal node 수가 적은 단순한 모델일 수록 작은 값
$ERR(T)$
- 검증데이터에 대한 오분류율
$L(T)$
- terminal node의 수
- 구조의 복잡도
$\alpha$
- ERR(T)와 L(T)를 결합하는 가중치
- 사용자에 의해 부여됨, 보통 0.01~0.1의 값을 씀

간단한 수식이다.

Decision Tree의 장단점

장점

데이터의 전처리 (정규화, 결측치, 이상치 등) 를 하지 않아도 된다.
수치형과 범주형 변수를 한꺼번에 다룰 수 있다.

한계

만약 샘플의 사이즈가 크면 효율성 및 가독성이 떨어진다.
과적합으로 알고리즘 성능이 떨어질 수 있다.
- 이를 극복하기 위해서 트리의 크기를 사전에 제한하는 튜닝이 필요하다.
한 번에 하나의 변수만을 고려하므로 변수간 상호작용을 파악하기가 어렵다.
결정트리는 Hill Climbing 방식 및 Greedy 방식을 사용하고 있다.
- 일반적인 Greedy 방식의 알고리즘이 그렇듯이 이 방식은 최적의 해를 보장하지는 못한다.
약간의 차이에 따라 (레코드의 개수의 약간의 차이) 트리의 모양이 많이 달라질 수 있다.
- 두 변수가 비슷한 수준의 정보력을 갖는다고 했을 때, 약간의 차이에 의해 다른 변수가 선택되면 이 후의 트리 구성이 크게 달라질 수 있다.
이같은 문제를 극복하기 위해 등장한 모델이 바로 랜덤포레스트이다.
- 같은 데이터에 대해 의사결정나무를 여러 개 만들어 그 결과를 종합해 예측 성능을 높이는 기법이다.

단순하게 살펴보아도 변수간의 상관관계는 전혀 반영되지 않으며, Greedy 알고리즘 특성상 최적의 해가 아니라는 것을 알 수 있다. 또한 과적합이 일어나기도 쉽다. 그러나 랜덤포레스트의 기반이 됨과 동시에 수학적으로 살펴볼 구석들이 있었다는 점에서 꼭 살펴보고 넘어가야 한다.

머신 러닝 정리 3 - 룰 베이스 알고리즘이란?

알 수 없는 사용자 — Thu, 29 Sep 2022 17:22:29 +0900

머신러닝이란?

경험에 의해 배우는 프로그램

경험에 의해 특정 테스크의 수행능력이 점차 향상 된다.

즉, 더 많은 경험이 쌓이면 (혹은 더 많은 사전 지식) 머신러닝의 성능이 점차 좋아질 것이라 기대된다.

Rule Based Learning

이상적인 세상 가정

관측 에러 X

모든 것은 일관적 관측

아래의 종류만으로 결과를 완벽하게 설명 가능

Sky	Temp	Humid	Wind	Water	Forecast	EnjoySpt
Sunny	Warm	Normal	Strong	Warm	Same	Yes
Sunny	Warm	High	Strong	Warm	Same	Yes
Rainy	Cold	High	Strong	Warm	Change	No
Sunny	Warm	High	Strong	Cool	Change	Yes

Function Approximation

머신러닝의 목표라고도 할 수 있다.

현실을 잘 반영하는 함수

Instance X

Features: O : <Sunny, Warm, Normal, Strong, Warm, Same>

Label: Y: <Yes>

Training Dataset D

Instance 관측치 모음

Hypothesis H

X 를 Y 로 변환하는 잠재적으로 가능한 함수

$h_i$: <Sunny, Warm, ?, ?, ?, Same> $\rightarrow$ Yes

다양한 가설이 가능하다.

Target Function c

알지 못하나, 데이터를 통해 추론해서 목표로하는 함수 즉 h 를 c 로 만드는 것이 목표

위 그림을 살펴보자. 위 그림의 오른 쪽 Hypothesis H $h_i$ 에 해당하는 Instance X $x_i$ 를 확인해보자.

각 가설에 따라 해당하는 instance를 확인할 수 있다.

이 그림이 룰 베이스를 설명한다. 즉, 룰베이스는 필터링 마냥 각각의 룰에 해당하는 것을 거르고 걸러 우리가 원하는 값을 찾을 수 있는 함수를 근사하는 것이다.

Find-S Algorithm

가설 h 에 대하여,

D 의 instance x 가 만약 positive 이면,
instance x 의 feature f 가 가설 h 에 해당되는지 확인
만약, 포함되지 않으면 $h \cup f_i \in x$

한마디로 정리하자면, instance x 가 positive 임에도 가설에서 해당되지 않던 내역을 가지고 있으면 가설에 추가하게 되는 것이다.

아래 예시를 살펴보자.

Instances

$x_1$ : <Sunny, Warm, Normal, Strong, Warm, Same>

$x_2$ : <Sunny, Warm, Normal, Light, Warm, Same>

$x_4$: <Sunny, Warm, Normal, Strong, Warm, Change>

Hypotheses

$h_0$ = <$\emptyset, \emptyset, \emptyset, \emptyset, \emptyset, \emptyset$>

$h_1$ = <Sunny, Warm, Normal, Strong, Warm, Same>

초기 instance $x_1$ 에 대하여 update

$h_{0,1,2}$ = <Sunny, Warm, Normal, ?, Warm, Same>

instance $x_2$ 로 인해 Strong 이 아닌 Light 여도 postivie 임을 확인 (합집합)

$h_{0,1,2,4}$ = <Sunny, Warm, Normal, ?, Warm, ?>

instance $x_4$ 로 인해 Same 이 아닌 Change 여도 postivie 임을 확인 (합집합)

$h_{0, 1,2, 4}$ 가 실제 함수를 올바르게 근사할까? 사실 알 수 없다. 다른 feature들도 여러 요소를 허용할 수도 있기에, 가능한 가설이 다양하다.

Version Space

가능한 여러 가설을 하나로 정리하기 어렵다.

이에 따라 범위를 찾아내는 방법이 제시되었다. 이를 version space라 한다.

범위를 제안하기 위하여 boundary 설정이 필요하다.

General Boundary G

set of the maximally general hypotheses of the version space

Specific Boundary S

set of the maximally specific hypotheses of the version space

Every Hypothesis h, satisfies

$\textrm{VS}_{H,D} = \{ h \in H | \exists s \in S, \exists g \in G, g \leq h \leq s \}$

정의만 봤을 때는 G 와 h 의 차이가 직관적으로 다가오지 않는다.

아래 도표를 살펴보자.

직관적으로 넓게 잡은 범위는 가능한 상황을 모두 가능하다고 가설을 세우는 것이다.

그러나 좀 좁게 잡은 범위는 가능한 상황이 더 있더라도 specific 하게 예측할 수 있는 경우는 specific 하게 가설을 세우는 것이다.

Candidate Elimination Algorithm

Version space를 만들기 위해서 가장 General, Specific 한 가설을 생성한 후, 점점 좁혀나가서 특정 version space 만을 찾아내는 알고리즘이다.

S 를 가능한 specific 하게 초기화 한다.

$\textrm{S0}$ : {< $\emptyset, \emptyset, \emptyset, \emptyset, \emptyset, \emptyset $ >}

G 를 가능한 general 하게 초기화 한다.

$\textrm{G0}$ : {< $?, ?, ?, ?, ?, ?$ >}

D 에 있는 각각의 instance x 를 통하여 타겟 값을 좁혀나간다.

만약 x 의 label y 가 postive 라면,

S 를 최대한 x 를 포함하는 general 한 범위로 일반화한다.
label 을 추론하는데 해당되지 않는 즉, $h(o) != y$인 h를 G 에서 제거한다.

만약 x 의 label y 가 negative 라면,

x의 o(feature) G에서 제거할 수 있는 만큼 제거한다.
S 에 속한 $h(0) = y$ 의 h 를 제거한다.

$\exists s \in S, \exists g \in G, g \leq h \leq s$ 를 만족하는 h 를 생성한다.

아래를 살펴보자.

Candidate Elimination Algorithm 의 과정

Specific, Generalize 하게 업데이트 되는 것을 확인할 수 있다.

Negative 한 케이스가 업데이트 되는 것도 확인할 수 있다.

다만, 어떠한 요소때문에 Negative 가 된지 알 수 없으므로 위와 같이 G 가 결정된다.

마지막 케이스를 통해 업데이트를 마쳤다. 그러나 여전히 G 과 S 사이에 여러 가설이 존재할 수 있다. 이 중 하나가 True 값일것이라 기대하며 learning 하는 것이 rule based 방법이다.

추가적으로 새로운 instance 가 들어오면 version space 를 점점 더 narrow down 할 수 있다.

해당 version space를 기반으로 classification 이 가능해진다.

Specific Boundary S

{<Sunny, Warm, ?, Strong, ?, ?>}

General Boundary G

{ <Sunny, ?, ?, ?, ?, ? >, <?, Warm, ?, ?, ?, ?> }

new instance

<Sunny, Warm, Normal, Strong, Cool, Change>

S 도 통과했으므로 OK

<Rainy, Cold, Normal, Light, Warm, Same>

G 도 통과하지 못하므로 NO

<Sunny, Warm, Normal, Light, Warm, Same>

S 는 통과하지 못하나 G 는 통과한다. 즉 해당 instance 는 결정을 못내리는 상황이다. Rule based learning 은 이러한 문제점을 가지고 있다.

위에서 살펴본 Candidate - elimination algorithm 은 아주 이상적인 세상에서만 사용가능하다.

데이터가 계속 들어오면 이상적인 세상에서는 True function 으로 converge 하게 될 것이다.

이상적인 세상의 조건은 상단에서 언급했다.

즉, 현실에서는 노이즈가 낀다는 것을 감안해야하고, Decision factor(feature) 또한 관측하지 못한 것이 있을 수 있다.

머신 러닝 정리 2 - 확률 분포

알 수 없는 사용자 — Thu, 29 Sep 2022 00:45:10 +0900

확률이란?

$P(E) \in R$ : 확률이란 함수 형태를 가지고 있다.
$P(E) \geq 0$ : 모든 각 사건은 확률이 0 이상이다. (음수는 없다.)
$P(\omega) = 1$ : 모든 경우를 합치면 1이다.

오메가에 대한 정의

$$ P(E_1 \cup E_2 \cup ...) = \sum^{\infty}_{i=1} P(E_i) $$

if $A \subseteq B$ then $P(A) \leq P(B)$
$P(\emptyset) = 0$
$0 \leq P(E) \leq 1$
$P(A \cup B) = P(A) + P(B) - P(A \cup B)$
$P(E^C) = 1- P(E)$

위 정도로 정리 가능하다.

조건부 확률

$$P(A | B) = \frac{P(A \cap B)}{P(B)}$$

B 가 주어졌을 때 A 가 성립할 확률, 즉 A와 B 가 동시에 성립해야 하며 이를 B 전체로 나눠줘야 한다.

$P(A \cap B) = P(B \cap A)$ 이므로 아래도 성립한다.

$P(B | A) = \frac{P(A | B) P(B)}{P(A)}$

확률 분포

사건(event)이 확률에 맵핑되는 함수를 확률 분포라고 한다.

예시)

확률 함수

$$f(x) = \frac{1}{\sqrt{2\pi}} \exp\left( -\frac{1}{2}\left(x\right)^{\!2}\,\right)$$

x 가 사건(event)

확률 밀도 함수

누적 분포 함수

분포의 모양을 조정할 수 있다.

1. 공식자체를 수정하여 분포를 바꿀 수 있다.

각 공식마다 이름이 있다. (normal, poisson, beta .. )

2.parameter 값을 조정하여 바꿀 수 있다.

normal distribuion

$f(x;mu, \sigma) = \frac{1}{\sigma\sqrt{2\pi}} \exp\left( -\frac{1}{2}\left(\frac{x-\mu} {\sigma}\right)^{\!2}\,\right)$

Notaion : $N(\mu, \sigma^2)$

Mean: $\mu$

Variance: $\sigma^2$

Beta distribution

normal distribution 은 양쪽에 long-tail이 끝없이 존재한다.

반면, beta distribution은 tail 없이 연속적인 값 [0,1] 내에 존재한다. (범위가 딱 정해진 경우 유용하다)

확률또한 범위가 정해져 있으므로 확률을 모델링 할 때 beta distribution 이 많이 사용된다.

$$P(\theta) = \frac{\theta^{\alpha - 1} (1-\theta)^{\beta -1}}{B(\alpha, \beta)}$$

$$B(\alpha, \beta) = \frac{\Gamma(\alpha) \Gamma(\beta)}{\Gamma{\alpha+\beta}}$$

$$\Gamma(\alpha) = (\alpha-1)!$$

$$\alpha \in N^{+}$$

Notation: $\textrm{Beta}(\alpha, \beta)$

Mean: $\frac{\alpha}{\alpha+\beta}$

Variance: $\frac{\alpha \beta}{(\alpha+\beta)^2 (\alpha + \beta + 1)}$

Binomial Distribution

$f(\theta; n, p) = {N\choose k} p^k(1-p)^{n-k}, {N\choose k} = \frac{n!}{k!(n-k)!}$

Notation: $B(n, p)$

mean: $np$

Variance: $np(1-p)$

분포가 연속적이지 않고 끊겨있는 것을 볼 수 있다. 즉, 이산적인 사건에 대해 확률을 정의할 때 사용한다.

Multinomial Distribution

앞과 뒤 처럼 2가지가 아닌 그 이상의 선택지가 있는 경우에는 다른 분포가 필요하다. 그 때 사용할 수 있는 분포이다.

binomial distribution의 일반화

Word Selection (말을 하고나서 다음 단어를 선택하는 경우), Cluster Selection

$f(x_1, ..., x_k; n, p_1, ..., p_k) = \frac{n!}{x_1! ... x_k!} p_1^{x_1} ... p_k^{x_k}$

Notation: $\textrm{Mult}(P), P = < p_1, ..., p_k >$

Mean: $\textrm{E}(x_i) = np_i $

Variance: $\textrm{Var}(x_i) = np_i(1-p_i)$

머신 러닝 정리 1 - MLE, MAP 정리

알 수 없는 사용자 — Wed, 28 Sep 2022 17:12:04 +0900

베이즈는 이미 2번 정리를 했지만, 여러번 볼 수록 좋기에 한번 더 정리를 한다.

Supervised Learning	Unsupervised Learning
Label이 있는 learning (분류, regression)	label 없이 주어진 데이터로 패턴 파악(clustering, Filtering)

Unsupervised Learning 예시: 주어진 신문기사 4만개에서 10개로 분류해보아라.

labeling 과정을 거칠 필요가 없이 clsutering 하면 된다.

이항 분포

이산 확률 분포

$$\textrm{n번중 k번 성공}$$

$$f(k;n,p) = P( K = k ) = \binom{n}{k} \, p^k (1-p)^{n-k}$$

$$\binom{n}{k} = \frac{n!}{k! (n-k)!} = \, ^n C_{k} $$

$$\rightarrow \textrm{독립시행}$$

독립시행

독립시행에 대한 이해가 필요

주사위 던지기

A: 6의 양의 약수가 나오는 사건 {1, 2, 3, 6}

$$P(A) = \frac{n(A)}{n(S)} = \frac{4}{6} = \frac{2}{3}$$

5번의 시행에서 사건 A가 3번 일어날 확률

단순하게 생각하면 아래와 같다.

$$\frac{2}{3}^3 \times \frac{1}{3}^2$$

하지만 5번의 시행에서 사건 A가 3번 일어날 경우가 한가지만 있는 것이 아니다.

실제는 아래와 같다.

$ ^n C_{r} $

순서를 고려하지 않는 조합이다. (매 시행시 일어날 확률이 P인 사건. n회의 시행 중 r번 일어날 확률)

$\rightarrow$ $^n C_{r}$ $p^r$ $(1-p)^{n-r}$

조합 (Combination): 순서를 고려하지 않음

순열 (Permutation): 순서를 고려

MLE

$$\hat{\theta} = argmax_{\theta} P(D \, |\, \theta \,) = argmax_{\theta} \, \theta^{a_H} (1 - \theta) ^{a_{\tau}}$$

$$= argmax_{\theta} \ln \{ \theta^{a_H} (1 - \theta) ^{a_{\tau}} \}$$

$$= argmax_{\theta} \{ \, a_{H} \ln{\theta} + a_{\tau} \ln{(1 - \theta)} \}$$

log function 은 monotonous 하게 증가하기 때문에 log를 mapping 한 후 구한 최댓값이 기존 최댓값(최대화 되는 점)과 동일하다.

$$\frac{\partial}{\partial \theta} (a_{H} \ln{\theta} + a_{\tau} \ln{(1 - \theta)})$$

미분을 하는 이유는 그냥 극점을 찾기 위함이다. 변화율이 0으로 떨어질때가 극점이기 때문

$$\ln{x}$$

$$\lim_{x \to \infty} (1 + \frac{1}{x})^x$$

각각의 미분법 혹은 극한 잊고 있으면 한번에 과정이 보이지 않는다.

$$\frac{\partial }{\partial x} \ln{x} = \frac{1}{x}$$

$$(1+0)^{\infty} = e \,\,\, \textrm{0과} \, \infty \textrm{처럼 역수를 이루고 있어야 한다.}$$

https://itforfun.tistory.com/220

ln (x-1) 의 미분

필자에게 자신을 돌아볼 충격적인 일이 있었다. ln(x - 1)을 미분하는데, 두가지 방법에 따라 결과값이 다르게 나온 것이다. 1) 합성 함수의 미분 $$\ln(x-1)' = g'(f(x))f'(x) $$ $$\ln(x-1)' = \ln'(x-1)(x-1)'..

itforfun.tistory.com

$$\frac{\partial}{\partial \theta} (a_{H} \ln{\theta} + a_{\tau} \ln{(1 - \theta)}) = 0$$

$$\frac{a_H}{\theta} - \frac{a_{\tau}}{1-\theta} = 0$$

$$\theta = \frac{a_{H}}{a_{\tau}+a_{H}}$$

MLE 측면에서 추정된 값은 $\hat{\theta} = \frac{a_{H}}{a_{\tau}+a_{H}}$ 이다.

$\hat{\theta}$ 는 파라미터의 추정값이지 파라미터가 아니다. 이에 따라 시행의 숫자가 많아질 수록 error 확률이 떨어진다.

에러 Bound

$$P(| \hat{\theta} - \theta^{*}| \geq \epsilon) \leq 2 e^{-2N\epsilon^2}$$

N 이 커지면 커질 수록 Error bound 는 작아진다.

이를 역산하여 error term 인 $\epsilon$ 과 그때의 확률을 구해볼 수 있다.

예를 들어 시행을 100번하여 $\epsilon$ 이 0.1 일 때의 실제 에러가 0.1 보다 클 확률은 0.0338338208 보다 낮다.

이를 PAC (Probably Approximate Correct learning) 이라 한다.

MLE 깔끔한 정리 블로그

https://techblog-history-younghunjo1.tistory.com/70

[ML] 데이터 학습방법으로서 MLE, MAP

※해당 게시물에 사용된 일부 자료는 순천향대학교 빅데이터공학과 정영섭 교수님의 머신러닝 전공수업 자료에 기반하였음을 알려드립니다. 이번 포스팅에서는 간단한 주제를 다룰텐데, 바로

techblog-history-younghunjo1.tistory.com

한마디로 정리하자면:

likelihood 는 주어진 파라미터 (특정 분포)에서 관측값이 등장할 확률이다.

MLE 는 "어떤 파라미터" 가 가장 많은 관측값을 포함하는가.

즉, likelihood 는 아래 이미지 같이 파라미터 마다 관측 값이 등장할 확률이 다르다.

그러므로, likelihood 를 미분하여 극점을 찾으면 그때의 파라미터가 MLE 이다.

MAP

Bayes 가 말하길,

사전에 가지고 있던 "사전 정보"를 파라미터 추정 과정에 가미할 수 있다.

$$P(\theta | D) = \frac{P(D|\theta) P(\theta)}{ P(D)}$$

$$\textrm{Posterior} = \frac{ \textrm{Likelihood} \times \textrm{Prior Knowledge} }{ \textrm{Normalizing Constant} }$$

$$ \frac{ \theta에 대한 사전정보 \times \theta 가 주어졌을 때 데이터를 관측할 \, \textrm{likelihood}}{데이터가 존재할 확률} $$

※Likelihood: 어떤 값이 관측되었을 때 이것이 특정 분포에서 왔을지에 대한 확률 고정 값이 관측 값이다.

MLE, Likelihood 에 대한 정리

https://jjangjjong.tistory.com/41

확률(probability)과 가능도(likelihood) 그리고 최대우도추정(likelihood maximization)

* 우선 본 글은 유투브 채널StatQuest with Josh Starmer 님의 자료를 한글로 정리한 것 입니다. 만약 영어듣기가 되신다면 아래 링크에서 직접 보시는 것을 추천드립니다. 이렇게 깔끔하게 설명한 자료

jjangjjong.tistory.com

$P(\theta | D) \propto P(D | \theta) P(\theta)$

$P(D | \theta) = \theta^{a_{H}} (1 - \theta)^{a_{\tau}}$

$P(\theta) = ?$

Beta distribution

$$P(\theta) = \frac{\theta^{\alpha - 1} (1-\theta)^{\beta -1}}{B(\alpha, \beta)}$$

$$B(\alpha, \beta) = \frac{\Gamma(\alpha) \Gamma(\beta)}{\Gamma{\alpha+\beta}}$$

$$\Gamma(\alpha) = (\alpha-1)!$$

$$ P(\theta | D) \propto P(D | \theta) P(\theta) $$

$$ \propto \theta^{a_{H}} (1 - \theta)^{a_{\tau}} \theta^{\alpha - 1} (1-\theta)^{\beta -1}$$

어차피 betsa distribution 의 $B(\alpha, \beta)$ 는 $\alpha, \beta$ 값에 의해 정해지는 상수이다. 이에 따라 생략한다.

MLE 과정에서 극점을 통해 미분한 결과 다음과 같은 결과를 얻었다.

$$P(D | \theta) = \theta^{a_{H}}(1-\theta)^{a_{\tau}}$$

$$\hat{\theta} = \frac{a_{H}}{a_{\tau}+a_{H}}$$

MAP 에서 구하고자 하는 $\theta$ 는 $\hat{\theta} = argmax_{\theta} P(\theta | D)$ 이므로

$$ P(\theta | D)\propto \theta^{a_{H}} (1 - \theta)^{a_{\tau}} \theta^{\alpha - 1} (1-\theta)^{\beta -1}$$

$$\hat{\theta} = \frac{a_{H}+\alpha -1}{a_{H} + \alpha + a_{\tau} + \beta - 2}$$

로 MAP 를 정리할 수 있다. 즉 $\alpha, \beta$ 값을 조정해보며 (prior knowledge) MLE 와 다른 결과값을 만들어 볼 수 있다.

물론 시행이 무수히 많아지게 되면 MLE 와 동일한 값이 된다.

베이지안 PYMC3

알 수 없는 사용자 — Tue, 27 Sep 2022 20:59:44 +0900

베이지안 라이브러리가 필요한 이유

베이지안이 어려운 이유는 실제로 conjugate distribution 을 찾기 어렵기 때문이다.

이로 인해 MCMC 샘플링을 사용하는 방식을 많이 사용하고 대표적인 library 로 PYMC3 가 있다. 복잡한 과정을 모두 대신해준다.

생각보다 듀토리얼이 없어서 아주 간단한 이론적 배경과 사용법을 정리해본다.

해당 글을 읽었을 때의 유익

저자는 본 글을 읽고나서 베이지안 사고방식이 어떤 의미인지, 그리고 해당 사고방식을 어떻게 접목해야하는지 깨달을 수 있는 기회가 되었다.

해당 내용은 https://nbviewer.org/github/markdregan/Bayesian-Modelling-in-Python/blob/master/Section%201.%20Estimating%20model%20parameters.ipynb

Jupyter Notebook Viewer

The above code has just gathered 200,000 credible samples of $\mu$ by traversing over the areas of high likelihood of the posterior distribution of $\mu$. The below plot (left) shows the distribution of values collected for $\mu$. The mean of this distribu

nbviewer.org

을 대부분 참고하였다. 본 글이 이해가 잘 가지 않는다면 위 글을 읽는 것을 추천한다.

베이지안 통계학자들은 어떤 사고방식을 가지고 있을까?

아래의 시나리오가 있다고 생각해보자.

한 소년이 집 앞을 지나가는 자동차를 매일 관찰하였다. 그는 매일 스쳐간 자동차의 수를 노트에 기록하였고 한주가 지나자 소년의 노트에는 2, 33, 20, 29, 20, 30, 18 의 수가 기록되었다.

데이터가 관측이 완료되었다. 즉, 이로 인해 생성되는 parameter는 고정되었고 그 값이 바뀌지 않는다.

하지만, 베이지안 통계학자들은 확률 분포를 사용하여 데이터를 통해 고정된 파라미터의 uncertainty 를 나타내고자 한다.

소년의 행위는 포아산 분포를 통해 데이터를 모델링 할 수 있는 흔한 상황이다. (포아산 분포에 대해서는 따로 언급하지 않는다.)

포아산 분포는 $\mu$ 라는 parameter 하나로 데이터의 평균과 분산 모두를 설명한다.

$$p(x \ | \ \mu) = \frac{e^{-\mu}\mu^{x}} {x!} \mbox{ for } x = 0, 1, 2, \cdots$$

아래는 각각 다른 $\mu$ 를 가진 세 가지의 포아산 분포 예시이다.

fig = plt.figure(figsize=(11,3))
ax = fig.add_subplot(111)
x_lim = 60
mu = [5, 20, 40]
for i in np.arange(x_lim):
    plt.bar(i, stats.poisson.pmf(mu[0], i), color=colors[3])
    plt.bar(i, stats.poisson.pmf(mu[1], i), color=colors[4])
    plt.bar(i, stats.poisson.pmf(mu[2], i), color=colors[5])
    
_ = ax.set_xlim(0, x_lim)
_ = ax.set_ylim(0, 0.2)
_ = ax.set_ylabel('Probability mass')
_ = ax.set_title('Poisson distribution')
_ = plt.legend(['$\mu$ = %s' % mu[0], '$\mu$ = %s' % mu[1], '$\mu$ = %s' % mu[2]])

각 $\mu$ 값에 의해 결정된 평균과 분산을 확인할 수 있다.

이제 실전으로 들어가보자.

주어진 데이터: 메세지를 응답하는데 걸리는 시간과 걸린 시간에 따른 답장 메세지 개수

우리는 이 데이터로 포아산 분포를 모델링 하고, parameter $\mu$를 찾을 수 있다. 해당 parameter를 추정할 수 있는 두가지 방식이 있다: 빈도주의 방식, 베이지안 방식. 두 방식으로 parameter를 추정해보자.

fig = plt.figure(figsize=(11,3))
_ = plt.title('Frequency of messages by response time')
_ = plt.xlabel('Response time (seconds)')
_ = plt.ylabel('Number of messages')
_ = plt.hist(messages['time_delay_seconds'].values, 
             range=[0, 60], bins=60, histtype='stepfilled')

$\mu$ 를 추정하는 빈도주의적 방법

빈도주의자는 포아산 분포의 $\mu$ 를 어떻게 추정할까?

여기서는 함수의 likelihood를 최대로 하기 위하여 최적화 테크닉을 사용한다.

아래의 poisson_logprob() 함수는 포아산 모델과 parameter 값이 주어질 때 관측된 데이터의 총 likelihood를 return 한다.

opt.minimize_scalar 함수는 주어진 관측 데이터로부터 가장 신뢰할 만한 $\mu$ (log likelihood 를 최대화하는) 를 찾는다.

해당 최적화 테크닉은 가능한 $\mu$를 interate하며 가장 높은 likelihood를 갖는 최적의 $\mu$ 를 찾아낸다.

y_obs = messages['time_delay_seconds'].values

def poisson_logprob(mu, sign=-1):
    return np.sum(sign*stats.poisson.logpmf(y_obs, mu=mu))

freq_results = opt.minimize_scalar(poisson_logprob)
%time print("The estimated value of mu is: %s" % freq_results['x'])

출력

The estimated value of mu is: 18.2307692324
CPU times: user 90 µs, sys: 45 µs, total: 135 µs
Wall time: 101 µs

측정된 $\mu$ 는 18.0413533867 이다. 이 최적화 테크닉은 매우 효율적으로 특정 값을 찾아 제공한다. 다만 uncertainty 에 대한 지표는 제공하지 못한다.

(stats.poisson.logpmf 는 포아산 질량 함수에 log 를 취한 값을 return 한다. 각 값을 joint probability 한 결과를 얻는 것과 동일한데, log 를 취했다보니 곱대신 합이다. 바로 아래의 포아산 질량 함수를 참고해보자.)

$$p(x \ | \ \mu) = \frac{e^{-\mu}\mu^{x}} {x!} \mbox{ for } x = 0, 1, 2, \cdots$$

아래 차트는 우리가 최적화 하는 함수를 시각화한 결과이다. 주어진 데이터와 모델에서 $\mu$ 의 값의 변화에 따른 log probability 를 확인할 수 있다.

optimizer 는 마치 언덕을 올라가듯 작동한다 - 커브의 랜덤한 점에서 시작하여 더 올라갈 수 없는 지점까지 점진적으로 등산한다.

x = np.linspace(1, 60)
y_min = np.min([poisson_logprob(i, sign=1) for i in x])
y_max = np.max([poisson_logprob(i, sign=1) for i in x])
fig = plt.figure(figsize=(6,4))
_ = plt.plot(x, [poisson_logprob(i, sign=1) for i in x])
_ = plt.fill_between(x, [poisson_logprob(i, sign=1) for i in x], 
                     y_min, color=colors[0], alpha=0.3)
_ = plt.title('Optimization of $\mu$')
_ = plt.xlabel('$\mu$')
_ = plt.ylabel('Log probability of $\mu$ given data')
_ = plt.vlines(freq_results['x'], y_max, y_min, colors='red', linestyles='dashed')
_ = plt.scatter(freq_results['x'], y_max, s=110, c='red', zorder=3)
_ = plt.ylim(ymin=y_min, ymax=0)
_ = plt.xlim(xmin=1, xmax=60)

위 과정은 parameter $\mu$ 를 18로 추정하였다. 포아산 분포의 parameter $\mu$ 는 평균과 분산을 동시에 나타낸다. 아래 차트는 해당 분포를 시각화한 결과이다.

fig = plt.figure(figsize=(11,3))
ax = fig.add_subplot(111)
x_lim = 60
mu = np.int(freq_results['x'])
for i in np.arange(x_lim):
    plt.bar(i, stats.poisson.pmf(mu, i), color=colors[3])
    
_ = ax.set_xlim(0, x_lim)
_ = ax.set_ylim(0, 0.1)
_ = ax.set_xlabel('Response time in seconds')
_ = ax.set_ylabel('Probability mass')
_ = ax.set_title('Estimated Poisson distribution for Hangout chat response time')
_ = plt.legend(['$\lambda$ = %s' % mu])

포아산 모델과 측정된 $\mu$ 는 10보다 작거나 30보다 큰 관측치가 낮은 확률로 존재할 수도 있다는 것을 보여준다. 대부분의 확률 밀도는 10과 30 사이에 위치한다. 하지만, 우리는 이 결과가 우리가 관측한 결과와 다르다는 것을 알 수 있다.

$\mu$ 를 추정하는 베이지안 방법

$$\overbrace{p(\mu \ |\ Data)}^{\text{posterior}} = \dfrac{\overbrace{p(Data \ | \ \mu)}^{\text{likelihood}} \cdot \overbrace{p(\mu)}^{\text{prior}}}{\underbrace{p(Data)}_{\text{marginal likelihood}}}$$a

간단하게 위 식에 대해 이해해보자.

(marginal likelihood 는 발생할 수 있는 모든 경우의 확률을 의미한다. 즉 발생할 수 있는 모든 경우를 분포로 그려본다면 이 때 해당하는 너비이다. )

위 그림은 다음과 같이 해석될 수 있다. (위 그림의 아래부터 대응된다.)

관측을 통해 데이터를 얻는다. ($y_{i}$)
관측된 데이터는 알 수 없는 어떠한 과정을 통해 생성 되었다. 하지만 우리는 이 과정이 포아산 분포를 통해 나타낼 수 있다고 믿는다. (Likelihood)
포아산 분포는 parameter를 한개 갖는다. ($\mu$ ) $\mu$는 0 ~ 60 사이 값이다. (Prior)
우리는 Prior $\mu$ 를 uniform 분포로 모델링한다. 이는 $\mu$ 가 해당 범위내 어디쯤에 어느정도 위치할지 예상할 수 없기 때문이다.

놀라운 MCMC 의 메커니즘

The process of Markov Chain Monte Carlo (MCMC) is nicely illustrated in the below animation. The MCMC sampler draws parameter values from the prior distribution and computes the likelihood that the observed data came from a distribution with these parameter values.

Markov Chain Monte Carlo (MCMC)의 과정은 아래 에니메이션 시각화를 통해 살펴볼 수 있다. MCMC sampler는 prior 분포로부터 parameter 값들을 뽑고 이 파라미터 값들을 갖는 분포로부터 관측한 데이터가 나올 수 있는 likelihood를 계산한다.

$$\overbrace{p(\mu \ |\ Data)}^{posterior} \varpropto \overbrace{p(Data \ | \ \mu)}^{likelihood} \cdot \overbrace{p(\mu)}^{prior}$$

위 공식은 MCMC sampler 을 이끄는 한줄기 빛 역할을 한다. MCMC sampler 가 prior 에서 parameters 를 뽑아낸 이후, 주어진 데이터에 대하여 prior에서 뽑아낸 parameters의 likelihood를 계산한다. (그리고 sampler를 더 높은 확률의 영역으로 향하도록 이끈다.)

사전에 언급했던 빈도주의적 최적화 테크닉과 개념적으로 유사한 면이 있다. MCMC sampler 도 더 높은 확률의 likelihood 영역을 향해 해맨다. 그러나 베이지안 방법은 절대적 최대치 값을 찾는 것보다 확률이 가장 높은 영역의 sample들을 탐색하고 모으는 것에 관심이 있다. 이렇게 하여 얻은 모든 sample들은 믿을 만한 parameter로 고려된다.

with pm.Model() as model:
    mu = pm.Uniform('mu', lower=0, upper=60)
    likelihood = pm.Poisson('likelihood', mu=mu, observed=messages['time_delay_seconds'].values)
    
    start = pm.find_MAP()
    step = pm.Metropolis()
    trace = pm.sample(200000, step, start=start, progressbar=True)

Applied interval-transform to mu and added transformed mu_interval_ to model.
  2%|▏         | 3769/200000 [01:13<1:05:21, 50.04it/s]

( 정리하자면, 만약 사전분포의 분산이 커서 precision 이 낮아지게 되면 prior 에서 뽑는 parameter 의 value 의 범위도 넓어지게 되고, 이러면 관측 데이터의 likelihood를 찾을 수 있는 범위가 넓어져 관측 데이터에 영향을 더욱 많이 받게 되는 것으로 보인다. 반면 분산이 작아 precision 이 크게되면 prior 에서 뽑는 parameter 의 value 의 범위도 좁아지고 관측 데이터의 likelihood를 찾을 수 있는 범위도 좁아져 관측 데이터에 영향을 거의 받지 않고 사전 정보에 남아있게 되는 것으로 보인다. )

상단의 코드는 높은 likelihood의 $\mu$ 사후 분포를 탐색하여 200,000개의 믿을만한 $\mu$ sample 을 수집했다. 하단의 왼쪽 차트는 $\mu$ 를 위해 수집된 분포를 보여준다. 해당 분포의 평균은 빈도주의 방식의 예측값과 거의 동일하다. 그러나, 이 뿐 만이 아니라 uncertainty 측정값 또한 얻을 수 있고, 이를 통해 $\mu$는 17 ~ 19 사이에 충분히 믿을 만한 값들이 존재함을 알 수 있다. 추후 다루겠지만 uncertainty 값은 정말 중요하다.

초기 sample 버리기

상단 MCMC code 의 pm.find_MAP() 에 대하여 간략하게 설명해본다. MAP 은 Maximum a posteriori estimation 을 뜻한다. MCMC sampler 가 sampling을 시작하기 좋은 위치를 찾을 수 있도록 돕는다. 이상적으로는 likelihood 가 높은 영역에서 모델을 시작하지만, 때때로는 이런 일은 일어나지 않는다. 이에 따라, 초기에 수집된 samples 은 종종 버려진다. (이를 burnin samples 라 한다.)

_ = pm.traceplot(trace, varnames=['mu'], lines={'mu': freq_results['x']})

fig = plt.figure(figsize=(11,3))
plt.subplot(121)
_ = plt.title('Burnin trace')
_ = plt.ylim(ymin=16.5, ymax=19.5)
_ = plt.plot(trace.get_values('mu')[:1000])
fig = plt.subplot(122)
_ = plt.title('Full trace')
_ = plt.ylim(ymin=16.5, ymax=19.5)
_ = plt.plot(trace.get_values('mu'))

Model convergence

상단 모델이 $\mu$의 값을 추정했다고 해서 모델이 꼭 주어진 데이터에 대해서 좋은 결과를 찾았다는 뜻은 아니다. 몇가지 추천할만한 확인 과정이 있다. 첫번째로, output 의 trace 를 확인해본다. trace가 확확 뛰어야 하며 마치 송충이 같아 보여야한다. 만약 trace 가 위아래로 움직이는 뱀 흔적처럼 보이거나 한 곳에 갇힌것처럼 보이면 수렴 문제가 있거나, MCMC sampler 의 결과물이 믿을 만 하지 않은 것일 수 있다.

Autocorrelation plot

두번째 확인 해볼 수 있는 방법은 autocorrelation test 이다. 이는 연속적인 MCMC sampling chain 의 sample들 간의 correlation을 측정하는 방법이다. sample들이 서로 낮은 correlation을 가지고 있으면 높은 correlation을 일 때보다 parameter 측정 값에 새로운 정보를 더하는 모양이다.

시각적으로 보면 상대적으로 빠르게 0으로 감소한 다음 0 상관관계 위아래로 진동하는 autocorrelation 차트가 우리가 원하는 결과이다. 만약 autocorrelation 차트가 떨어지지 않으면 주로 혼합 불량 신호이므로 모델을 다시 선정하고 (ex. likelihood) 샘플링 방식 (ex. matropolis)도 다시 고려해야 한다.

_ = pm.autocorrplot(trace[:2000], varnames=['mu'])

베이즈 아주 얕은 정리

알 수 없는 사용자 — Mon, 19 Sep 2022 22:04:04 +0900

베이즈를 활용해서 연구도 해봤고, 어느정도 이해했다고는 생각하지만 항상 약간만 깊이 들어가면 내가 아무것도 모르는 구나를 깨닫게 된다.

이론적으로 완벽할 필요는 없지만 어느정도 구조에 대한 파악이 필요하다고 생각한다.

아래 블로그는 웹서핑 과정 중에서 만난 여지껏 어떤 블로그보다 베이즈에 대한 개괄을 잘 작성해놓은 블로그이다.

본 글은 내 사전지식에 맞춰 좀 덜거나 더해 작성되었기에 해당 글을 읽는 것보다 아래의 블로그 글을 읽는 것이 더 좋을 것 같다. 물론 나랑 사전 지식이 비슷하다면 이 글이 오히려 좋을 수도 있다.

http://posterior.egloos.com/9606941

베이즈 정리 (일반적 형태)

앞의 글들에서 베이즈 정리의 의미와 그 사용 예시를 살펴보았다. 이제 본격적인 베이지안 추론의 예를 접하기 전에, 베이즈 정리의 형태를 일반적인 경우로 확장할 필요가 있다. 앞의 글에서

posterior.egloos.com

대부분 글의 표현과 이미지는 위 블로그에서 가져온 것임을 먼저 밝힌다.

베이지안 추론

베이지안 추론은 '주관적 확률'을 사용할 수 있다는 점에서 전통적 절차와 큰 차이점을 지닌다.

※주관적 확률이란 어떤 사건의 발생 또는 어떤 명제가 참임에 대한 믿음의 정도 (degree of belief) 를 0 에서 1 사이의 숫자로 나타낸 것이다. 이를테면 동전을 하나 던졌을 때 앞면이 나올 확률이 0.5라고 말하는 것은 '앞면과 뒷면이 나올 가능성은 동일하다' 라는 믿음을 반영하는 것이다.

배경 지식을 반영할 수 있다는 엄청난 이점과, 이를 통해 여러 '주관적 확률 가설' 중 어느것이 더 확률적으로 그럴듯한지 비교해볼 수 있다.

대표적인 예시로 장마철 기상청은 장마 시기의 비올 확률이라는 사전 지식을 예측에 활용한다.

최근 예측 결과가 좀 좋지 않은데 여러 가설을 이용해보거나, 아예 사전 지식을 빼보면 어떨까?

베이즈 정리

모든 베이지안 통계분석 절차는 베이즈 정리의 특수한 적용 사례에 불과하다. 베이즈정리의 토대가 되는 개념인 조건부확률을 살펴보자.

※조건부확률이란 어떤 사건(명제)이'참'일 때 다른 사건(명제)이 참일 확률을 의미한다.

'동전이 공평함' 이라는 전제 하에 동전이 앞면이 나올 확률이 0.5

P('앞면' | '공평한 동전') = 0.5

'동전이 심하게 굽음' 전제 하에 앞면이 나올 확률이 0.8

P('앞면' | '굽은 동전') = 0.8

조건부확률의 개념을 토대로, 베이즈정리는 다음과 같은 공식으로 표현된다.

$$P(A|B) = \frac{ P(B|A) \times P(A) }{ P(B) }$$

$P(A|B)$ : 사후 확률

$P(A)$ : B가 참임을 알기 전에 A에 대해 갖고 있던 믿음(확률)을 의미, 사전확률

$P(B|A)$ : 우도, Likelihood

$P(B)$ : 증거, evidence

예시) 동전은 공평한가?

가설이 두개밖에 없다고 가정하자.

만약 동전이 공평하다면, 그것이 앞면이 나올 확률은 0.5이다.
만약 동전이 공평하지 않다면, 그것이 앞면이 나올 확률은 0.4이다.

2번의 시행에서 뒷면, 뒷면의 결과를 얻었다.

이 동전이 공평할 확률은?

$P(A|B)$ : 사후 확률

$P(A)$ : 0.5

$P(B|A)$ : 0.5 X 0.5 = 0.25

$P(B)$ : 0.5 X 0.25 + 0.5 X 0.36

분모의 계산은 분자보다 다소 까다롭다. P(B)가 의미하는 것은 'B가 일어날 확률' 인데, 이것을 조금 확장하여 생각하면 모든 가능한 상황에서 B가 일어날(참일) 확률의 합 이라 볼 수 있다. 그런데 위 경우에서 모든 가능한 상황이란 단 두 가지, 즉 동전이 앞면이 나올 확률이 0.5이거나 0.6인 경우로 제한되었다. 따라서 각각의 상황에서 뒷면이 두 번 나올 확률을 계산하여 더해야 한다. 하지만 여기서 주의할 것은 확률을 그냥 더하면 되는 것이 아니고, 각각의 우도에 사전확률을 가중치로 곱하여 더해야 한다. 이것은 각각의 가능성에 대한 사전믿음을 반영하는 것이다.

$$P(A|B) = \frac{ P(B|A) \times P(A) }{ P(B) } = \frac{0.5 \times 0.25}{ 0.5 \times 0.25 + 0.5 \times 0.36} \approx 0.41 $$

동전이 공평하다는 가능성인 사후확률이 0.41 임을 확인하였다. 상단에서 제시하였지만 사후확률은 여러 가설 중 어떤 가설이 얼마나 현상을 잘 설명하는 가에 대한 지표이다.

앞면이 나올 사전 믿음이 0.4인 경우

$$P(A|B) = \frac{ P(B|A) \times P(A) }{ P(B) } = \frac{0.4 \times 0.36}{ 0.4 \times 0.25 + 0.4 \times 0.36} \approx 0.59 $$

앞면이 나올 확률이 0.4 라고 믿는 경우가 0.5 라고 믿는 경우보다 뒷면이 2번 연속 나온 것을 (0.59 - 0.41) 만큼 더 잘 설명한다.

위 예시는 동전이 앞면이 나올 확률은 0.5이거나 0.6인 경우밖에 없으며, 그 외의 값은 갖지 않는다고 간주했다.

그러나 실제로 베이지안 데이터분석을 할 때는 가설이 이와 같이 뚝뚝 떨어진 (이산적인) 경우는 흔치 않다. 이를테면 동전이 앞면이 나올 확률은 0에서 1 사이의 어느 값이나 가능다고 가정한다. 이런 경우에는 앞에서 설명한 방식으로 베이즈 정리를 사용하는 것은 불가능하다. 따라서 이번 글에서는 그러한 경우에도 일반적으로 사용할 수 있는 베이즈 정리의 형태를 알아보자.

베이즈 정리의 일반적 형태

$$P(H|D) = \frac{P(H) P(D|H)} {P(D)}$$

통계분석 장면에서 가설은 모수치에 대한 어떤 명제를 의미한다. 더 쉽게 말하자면, 통계적 가설은 다음과 같은 형태를 갖는다: '신약의 치료효과는 0과 같다.' '동전이 앞면이 나올 확률은 0.5보다 크다.' 여기서 '신약의 치료효과', '동전이 앞면이 나올 확률' 등은 모수치에 관한 진술로 바꿀 수 있다. 전자의 경우에는 '신약의 치료효과' 를 θ로 나타내기로 하면 가설을 'θ=0' 과 같이 나타낼 수 있다. 후자의 경우에도 비슷하게 'p > 0.5' 와 같이 나타낼 수 있다. 다시 말해, 가설(H)은 모수치(θ)에 관한 진술이다. 따라서 위의 베이즈 정리를 아래와 같이 나타낼 수 있다.

$$P(\theta|D) = \frac{P(\theta) P(D|\theta)} {P(D)}$$

위 공식의 분모 P(D) 는 추론 과정에서 중요한 역할을 하지 않는 경우가 많는데, 상수로 취급되기 때문이다. (아마도 적분해서 1) 경우에 따라서는 중요하기도 하다.

P(θ|D)는 사후확률(posterior), P(θ)는 사전확률(prior), P(D|θ)는 우도(likelihood) 임을 언급했다. 따라서 분모를 비례상수로 취급하면, 다음과 같은 표현을 얻게 된다:

정규분포 베이지안 업데이팅

베이지안에서 가장 흔하고, 가장 간단한 형태인 정규- 정규 모형을 살펴보자.

이 글에서는 모분산을 이미 알고 있다고 가정하고, 단 하나의 자료를 관측했을 때 모평균에 대한 베이지안 추론을 한다.

평균이 θ, 분산이 σ의 제곱인 정규분포 확률밀도함수는 아래와 같다.

간단하게 수식을 통해 증명 과정을 살펴봤으나 생각보다 깨닫게 되는 점은 적다.

이는 우도 (likelihood)에 해당된다. (우도는 P(D|θ)로 표현되었음을 상기하자.) 다시 말해 우도는 모수치가 주어졌을 때 자료(x)의 확률을 계산하는 데 사용되는 함수이다. (MLE 가 주어진 자료를 가장 잘 관찰할 수 있는 likelihood 를 말한다는 것을 떠올려보라!)

그런데 여기서는 분산이 상수라고 가정했기 때문에, 좌변에서 시그마(σ)를 생략해도 무방하다. 따라서 다음과 같이 다시 나타낼 수 있다.

사후확률(사후분포) 을 계산하기 위해서는 사전확률도 필요하다. 사전 확률은 분석가가 사전에 할당하는 내용이다. 우도가 정규분포일 때 흔히 사용되는 정규사전분포(normal prior)를 사용한다.

위 식은 모평균(θ)에 대한 사전믿음을 평균이 m, 표준편차가 s인 정규분포로 표현한다. 좀 더 쉽게 말하자면, 위 사전분포를 사용하는 사람은 모평균이 대략 m이라 믿으며, 그 불확실성이 대략 s만큼이라고 믿는다는 것을 의미한다. 분석가가 s에 작은 값을 할당한다면 그것은 모평균이 m이라는 것에 대해 확신이 있다는 것을 의미하는 것이다. 반대로 큰 s의 값은 모평균이 m이라는 믿음에 대해 확신이 그만큼 없다는 것을 의미한다.

위와 같이 정규분포 우도함수에 정규사전분포를 함께 사용하는 통계모형을 정규-정규 모형(normal-normal model)이라 부른다.

아래의 식을 상기해보자.

이 표현을 위에 적용하면 다음과 같은 결과를 얻게 된다. 편의상 사전분포와 우도의 순서를 바꾸었다. (x가 데이터, D에 해당된다.)

위 식을 θ에 대한 함수(확률밀도함수)로 보고, 이런저런 복잡한 계산과정을 거치면 다음과 같이 정리가 된다. (구체적인 계산 과정은 생략한다. )

수식이 매우 복잡하게 보인다. 하지만 개념적으로만 접근해 보자. 위 식 자체도 사실 정규분포의 공식처럼 보인다. 좀 더 구체적으로는, 위 식은 x가 주어졌을 때 θ 가 정규분포를 따른다는 것을 의미하는데, 이는 모평균에 대한 사후믿음이 정규분포임을 의미한다. (이는 사전분포로 정규분포를 사용한 결과다.)

(정규분포 확률밀도함수랑 비교했을 때 $\sqrt{2\pi}$ 가 생략되었으나 아래 글에 따르면 이는 normalizing constant 라 한다.)

https://math.stackexchange.com/questions/3181774/what-is-the-purpose-of-frac1-sigma-sqrt2-pi-in-frac1-sigma-sqrt

(정규분포 밀도함수 숨은 의미)

https://basicstatistics.tistory.com/entry/%EC%A0%95%EA%B7%9C%EB%B6%84%ED%8F%AC%EC%9D%98-%ED%99%95%EB%A5%A0%EB%B0%80%EB%8F%84%ED%95%A8%EC%88%98-%EC%9D%B4%ED%95%B4%ED%95%98%EA%B8%B0

한편 정규분포 공식(밀도함수)의 형태를 참조하면, 위 식에서 사후분포의 평균과 분산은 다음과 같음을 알 수 있다

m' 은 사후분포의 평균, s' 은 사후분포의 분산을 나타낸다. 다시 말해, x라는 하나의 데이터를 관찰했을 때, 우리의 모평균(θ) 에 대한 믿음은 다시 정규분포로 기술될 수 있으며, 그 평균과 분산은 각각 m' 와 s' 가 된다.

사실 위 업데이트 과정은 베이지안 추론 일반에 적용되는 아주 중요한 의미를 담고 있다. 베이지안 추론은 사전믿음(사전분포)와 데이터에서 획득된 정보 사이의 타협이라는 것이다.

베이지안 업데이팅에 내포된 의미

Precision

베이지안 통계학에서는 정규분포에 대해 이야기할 때, precision 이라는 개념을 분산 대신 사용할 때가 많다. 여기서는 이를 '정밀도' 와 비슷한 개념이라 생각하기로 하자. precision은 분산의 역수로 정의한다.

통계학에서는 흔히 분산을 불확실성의 척도로 본다. 그런데 위 식을 보면 알 수 있지만, 분산이 커질수록 precision은 감소한다. 극단적인 경우, 분산이 무한대가 되면 precision은 0이 되고, 반대로 분산이 0에 가까워지면 precision은 무한대가 된다. 따라서 precision이 클수록 불확실성이 작다는 의미가 된다.

그런데 앞의 글에서 베이지안 업데이팅에 대해 이야기할 때, 모평균에 대한 분산의 업데이트 결과는 다음과 같다는 것을 확인했다.

사후분산(s' 의 제곱)의 역수는 사전분산(s의 제곱)의 역수에 자료 분산의 역수를 더한 것과 같다. 그런데 방금 precision은 분산의 역수라고 말했다. 따라서 앞의 진술을 다시 표현하면, 사후분포의 precision은 사전분포의 precision 과 자료의 precision의 합으로 나타낼 수 있다. (precision은 가법적 additive 이다.)

이것의 함의는 무엇인가? 만약 자료의 precision에 비해 사전분포의 precision 이 매우 크다면, 자료의 precision(분산)은 사후분포의 precision에 별 영향을 끼치지 못할 것이다. 그런데 큰 precision은 사전분포에 대한 강한 믿음을 반영한다. 이는 강한 사전믿음일수록(사전분포가 강할수록) 자료에 의해 영향을 덜 받는다는 것을 의미한다. 반대로 사전분포에 대한 확신이 작다면 사전분포의 precision은 작아질 것이고, 따라서 사후 precision은 사전 precision보다는 자료의 precision에 더 큰 영향을 받게 된다. 이 사실은 향후에 사전분포를 만드는 방법에 대해 논의할 때 다시 등장하게 될 것이다.

이번에는 모평균에 대한 사후분포의 평균을 살펴보자. 정규-정규 모형에서 사후분포의 평균 (m') 은 다음과 같았다.

여기서 분자를 좀 더 자세히 들여다보자. 분자는 다음과 같이 다시 표현할 수 있다.

이것은 무엇을 의미하는가? 사후분포의 평균은 결국 자료(x)와 사전분포의 평균(m)에 의해 결정되는데, 각각에는 가중치가 곱해진다. 그런데 그 가중치들을 자세히 보면, 결국 앞서 이야기했던 precision 들이다. x와 m은 각각의 precision을 가중치로 받는 것이다. 또한 사전분포의 precision 이 클수록 사전평균(m)이 사후평균에 기여하는 정도가 커지고, 자료의 precision이 클수록 자료(x)가 사후평균에 기여하는 정도가 커진다. 따라서 이것은 사전분포나 자료에 대한 확신이 강할수록 그것이 사후적 판단에 끼치는 영향이 더 커야 한다는 우리의 직관을 잘 반영한다.

한 가지 더 확인할 수 있는 것은 이 글 서두에서 말한, 베이지안 업데이팅은 자료와 사전믿음 사이의 타협이라는 것이다. 위 식이 의미하는 것은, 결국 사후믿음(분포)은 자료와 사전믿음의 가중된 합이라는 것이다. 극단적인 경우, 자료의 precision이 0인 경우에는 사후평균은 전적으로 사전평균에 의해 결정된다. 반대로 사전분포의 precision이 0인 경우에는 사후평균은 자료에 의해 전적으로 결정된다. 그러나 두 precision이 모두 0이 아니라면, 사후평균은 x와 m 사이의 어떤 값이 될 것이다. 이는 베이지안 업데이팅이 자료와 사전믿음 사이의 타협이라는 결과를 낳음을 보여 준다.

이 결과는 앞으로도 반복하여 등장할, 베이지안 통계에 내재되어 있는 일종의 '철학' 이라고 간주해도 좋다.

여러 자료로 구성된 표본을 갖고 있는 경우에 대해 예를 들어보자. (이 자료들은 공통의 정규분포에 왔으며, 각각은 독립이라고 가정한다.)

언제나 그렇듯, 베이지안 통계분석의 출발은 아래의 표현이다:

예시를 위해 정규분포에서 온 크기가 5인 표본 (5.1, 4.8, 4.9, 5.5, 5.3) 이 있다고 하자. 그리고 모분산은 0.1로 알려져 있다고 가정하자. 이 상황에서 정규-정규 모형을 이용하여 모평균에 대해 베이지안 업데이팅을 하려고 한다.

일단 사전분포를 설정해야 하는데, 사전분포의 평균이 4라고 가정하자. 그리고 사전분포의 자의성이 분석에 미치는 영향을 최소화하기 위해 precision 을 아주 작게 잡도록 하자. 이를테면 여기서는 0.001 로 잡겠다. 이는 모평균이 4라는 믿음에 대한 확신이 비교적 작음을 의미한다. (앞으로도 이와 같이 약한 사전분포를 사용하는 것을 자주 볼 것이다.)

이제 모평균 θ 에 대한 사전믿음(분포)을 다음과 같이 나타낼 수 있다.

이제는 우도를 결정해야 한다. 그런데 정규분포에서 온 자료가 있을 때, 이 자료가 모평균에 대해 주는 정보는 표본평균(sample mean)에 모두 들어 있다. 이와 같이 어떤 표본이 있을 때, 표본이 모수치에 대해 제공하는 모든 정보를 담고 있는 통계량을 충분통계량(sufficient statistic) 이라 부르며, 베이지안 통계에서 중요한 위치를 차지한다. 대개 어떤 자료가 있을 때, 그것을 이용하여 모수치에 대한 추론을 할 때는 전체 자료 대신 충분통계량만 사용하면 되는 경우가 많다. 충분통계량에 대한 자세한 수학적 묘사는 생략한다.

한편 앞서의 글들에서 베이지안 업데이팅의 결과는 다음과 같다고 언급했었다.

이제 이 공식을 이용하여 베이지안 업데이팅을 해 보자. (위 공식에서 x 대신 표본평균이 들어갈 것이다.) 사후분산 (s') 은 이미 알려진 숫자들을 이용하여 쉽게 구할 수 있다. 자료의 분산은 0.1로 이미 알려져 있다고 가정했으므로 크기가 5인 자료의 표본평균의 분산은 이것을 자료 크기로 나눈 0.02가 된다. 따라서 자료의 precision은 1/0.02=50 이 된다. 한편 사전분포의 precision은 0.001로 가정했다. 따라서 사후 precision은 50+0.001 = 50.001 이 된다. 수학적 표현은 다음과 같다.

이제 m' 을 업데이트해 보자. 자료가 여러 개 있을 때, 이 값의 분자에는 다소의 수정이 가해진다. x가 더이상 하나의 숫자가 아닌 표본평균(충분통계량) 이 되고, 그 precision도 재조정되어 표본평균의 분산의 역수가 된다. 따라서 다음과 같은 형태가 된다.

한편 자료의 평균은 5.12 이다. 이제 사후평균을 구하기 위한 준비는 모두 끝났다. 한 가지 팁이라면, 사후평균의 분모는 사후 precision 과 같다는 것이다. 이제 숫자들을 대입해 보자.

사전분포에 대한 믿음을 아주 약하게 주었기 때문에, 사후평균은 표본평균에 아주 가까운 것을 확인할 수 있다. 이제 사후분포를 확정해 보자. 위에서 구한 사후평균과 사후 precision을 활용하면 된다.

그런데 만약 사전분포에 대한 믿음이 강했다면, 다시 말해 사전 precision이 컸다면 결과는 어땠을까? precision을 0.001에서 10으로 늘려 보도록 하자. 그러면 사후분포의 평균에 대한 베이지안 업데이팅 결과는 다음과 같이 바뀐다.

이전의 업데이팅 결과에 비해 사전평균 (4) 쪽으로 좀 더 옮겨간 것을 확인할 수 있다. 이 사례는 베이지안 통계절차가 사전믿음과 자료 사이의 타협이며, 양자에 대한 확신의 강도에 의해 사후 판단이 영향을 받을 수 있다는 것을 잘 보여준다.

한가지 명확하게 하고 싶은 점은, 왜 표본 평균과 표본 평균의 분산을 사용했다는 점이다.

위글을 읽고 아래의 글을 읽으면 정리하는데 도움이 된다.

https://zzaebok.github.io/machine_learning/mle-bayes-mathematical-proof/

최대 우도 추정과 베이즈 정리의 간단한 수학적 증명

zzaebok.github.io

https://gaussian37.github.io/ml-concept-basic_bayesian_theory/

기초 베이지안 이론 (Basic Bayesian Theory)

gaussian37's blog

gaussian37.github.io

https://github.com/markdregan/Bayesian-Modelling-in-Python

GitHub - markdregan/Bayesian-Modelling-in-Python: A python tutorial on bayesian modeling techniques (PyMC3)

A python tutorial on bayesian modeling techniques (PyMC3) - GitHub - markdregan/Bayesian-Modelling-in-Python: A python tutorial on bayesian modeling techniques (PyMC3)

github.com

켤레 사전 분포

우도함수(데이터 생성모형)가 있을 때, 사전분포를 적절히 설정하면 사후분포가 사전분포와 같도록 만들 수 있다. 이러한 사전분포를 '켤레사전분포' (Conjugate prior distribution) 라 부르며, 베이지안 통계에서 흔히 사용한다. 켤레사전분포를 사용하면 사후분포가 우리가 잘 아는 분포가 되기 때문에 사후평균, 사후분산 등을 매우 쉽게 구할 수 있다.

켤레사전분포를 사용하는 이유는 계산이 편해지기 때문이다. 이를테면 정규-정규 모형에서 우도함수의 분산을 이미 안다고 가정하는 경우, 모평균의 기댓값에 대한 업데이팅은 다음과 같이 이루어짐을 이미 확인하였다:

이 과정에는 어떠한 프로그래밍이나 시뮬레이션도 필요하지 않으며, 단지 이미 아는 숫자들을 대입하기만 하면 된다. 사실 분산을 모른다고 가정하는 경우에도 분산에 대해 사전믿음을 켤레사전분포로 설정하면, 일련의 수학적 증명을 통해 분산이 어떻게 업데이트되는지 보일 수 있다. 이 과정에서도 단지 몇 가지의 간단한 숫자나 통계량(표본분산) 등을 대입하기만 하면 된다. (참고로 정규-정규 모형에서 분산에 대한 켤레사전분포로는 흔히 감마분포나 역감마분포, 역카이제곱분포라는 이름의 분포들을 즐겨 사용한다.)

만약 사전분포가 켤레사전분포가 아니라면 수학적으로만 사후분포를 얻는 것은 매우 어려운데, 사후분포를 친숙한 분포의 형태로 구하는 것이 난해하기 때문이다. 따라서 사후분포로부터 평균이나 분산 등의 통계치를 얻기를 원하거나, 사후분포를 시각화하려는 경우에는 컴퓨터 시뮬레이션의 힘을 빌릴 수밖에 없다. 1990년대 이전에는 이것은 매우 어려웠다. 이론적으로도 힘들었거니와 당대의 컴퓨터의 성능이 이와 같은 복잡한 시뮬레이션을 수행하기에는 부족했기 때문이다. 그러나 기술의 눈부신 발전과 이론적 발전에 힘입어, 최근 들어서는 사전분포가 켤레사전분포가 아닌 경우에도 비교적 짧은 시간 안에 사후분포에 대한 시뮬레이션 결과를 얻을 수 있게 되었다. 이는 베이지안 통계학이 주류로 들어올 수 있게 해 준 중요한 계기가 되었다.

하지만 최근에도 켤레사전분포의 사용은 계속되고 있는데, 이는 켤레사전분포를 사용이 시뮬레이션 방법의 사용을 줄일 수 있게 해 주며 따라서 각종 시간적, 계산적 비용을 절감해줄 수 있기 때문이다.

정규분포 확률밀도함수 유도

알 수 없는 사용자 — Thu, 15 Sep 2022 22:55:54 +0900

정규분포의 확률밀도함수 유도정도는 이해하고 있어야 추후 여러 수학 공식 이해가 쉬울 것으로 보인다.

https://www.youtube.com/watch?v=sFMjrnI93b4

아래와 같은 과녁 중심을 향해 화살을 쏜다고 가정하자.

목표가 과녁 중심이기에 아래가 성립한다.

1. 과녁의 중심에서 멀어지면 확률이 낮다.

2. 중심에서 거리가 같은 곳에 맞출 확률은 같다.

3. x좌표와 y좌표는 독립적이다.

x, y 좌표에 의해 확률이 정해지므로

$f(x,y)$ : (빨간 점에 맞을 확률)

(x, y는 서로 독립이므로)

$f(x,y) = f(x \cap y) = f(x)f(y)$

과녁을 중심으로 같은거리의 점들은 모두 맞을 확률이 같으므로,

반지름 r 만으로 확률이 정해진다.

빨간점에 맞을 확률: $g(r)$

(x, y는 서로 독립이므로)

$f(x,y) = f(x\cap y) = f(x)f(y)$

$x = r \cos \theta$

$y = r \sin \theta$

$f(x,y) = f(x)f(y) = g(r)$

확률 밀도함수를 구하기 위한 식

$$f(x,y) = f(x)f(y) = g(r)$$

$x = r \cos \theta \rightarrow \frac{\partial x}{\partial \theta} = -r \sin \theta $

$y = r \sin \theta \rightarrow \frac{\partial y}{\partial \theta} = r \cos \theta$

확률 밀도함수를 구하기 위한 식을 $\theta$ 에 대해 미분하면,

※곱의 미분

$\{f(x)g(x)\}' = f'(x)g(x) + f(x)g'(x)$

$$ 0 = \frac{\partial f(x)}{\partial \theta} \times f(y) + f(x) \times \frac{\partial f(y)}{\partial \theta}$$

$$= \frac{\partial f(x)}{\partial x} \times \frac{\partial x}{\partial \theta} \times f(y) + f(x) \times \frac{\partial f(y)}{\partial y} \times \frac{\partial y}{ \partial \theta}$$

$$ 0 = f'(x) \times (-r \sin \theta) \times f(y) + f(x) \times f'(y) \times r \cos \theta$$

모든 x,y 에 대해서 이 등식이 성립해야 하므로 이 값은 상수밖에 될 수 없다.

※ $(\ln (x))' = \frac{1}{x} $

합성함수 미분

$(\ln(|f(x)|))' = \ln'(f(x))(f(x))' = f'(x) \times \frac{1}{f(x)} = \frac{f'(x)}{f(x)}$

$$A = \sqrt{\frac{k}{2 \pi}}$$

적분 제곱

https://math.stackexchange.com/questions/2693076/simplifying-square-of-integral-in-general

[백준] - 다이나믹 프로그래밍 동전 1

알 수 없는 사용자 — Thu, 15 Sep 2022 15:31:52 +0900

동전 1

시간 제한메모리 제한제출정답맞힌 사람정답 비율

0.5 초 (추가 시간 없음)

4 MB

45880

20871

15733

45.615%

문제

n가지 종류의 동전이 있다. 각각의 동전이 나타내는 가치는 다르다. 이 동전을 적당히 사용해서, 그 가치의 합이 k원이 되도록 하고 싶다. 그 경우의 수를 구하시오. 각각의 동전은 몇 개라도 사용할 수 있다.

사용한 동전의 구성이 같은데, 순서만 다른 것은 같은 경우이다.

입력

첫째 줄에 n, k가 주어진다. (1 ≤ n ≤ 100, 1 ≤ k ≤ 10,000) 다음 n개의 줄에는 각각의 동전의 가치가 주어진다. 동전의 가치는 100,000보다 작거나 같은 자연수이다.

출력

첫째 줄에 경우의 수를 출력한다. 경우의 수는 231보다 작다.

예제 입력 1 복사

예제 출력 1 복사

모든 개수라고 하니 당연히 dfs 로 풀어야 할 것 같았다.

다만, 문제 시간이 0.5 초라 dfs 로는 불가능할 것임을 짐작할 수 있었다.

combination 으로 푸는 것은 개수가 10개가 넘어서 절대 불가능하고, 애초에 dfs 로 안되는 시점에서 combination은 불가능하다.

dp 로만 풀 수 있다.

문제보다 약간 더 hard case 인 k =20, coin = 2, 5, 12 인 경우이다.

해당 문제의 알고리즘은 다음과 같다.

다른 코인으로 k 를 몇개 만들 수 있는 가 + 현재 주어진 코인으로 k 를 만들 수 있는가?

현재 주어진 코인으로 k 를 만들 수 있는가는

dp[index - coin]

으로 간단하게 이전 index에서 가능했나 확인하면 된다.

다른 코인으로 k 를 몇개 만들 수 있는가는 dp 의 특성인 반복해서 array를 업데이트 함으로써 확인 가능하다.

위 표를 보며 아래 설명을 읽어보자.

예를 들어 숫자 10은 coin 2 로 만들 수 있어서 1 이다.

숫자 10은 coin 5로도 만들 수 있다.

이에 따라 1 + 1 로 경우의 수는 2 이다.

그 다음 업데이트 상황을 살펴보자.

예를 들어 숫자 15는 coin 2로 만들 수 없어서 0 이다.

하지만 15는 5로 만들 수 있다.

10을 만드는 경우의 수는 아래 2개 였다.

2 coin X 5
5 coin X 2

5는 이 경우의 수를 그대로 이어 받는다.

2 coin X 5 + coin 5
5 coin X 2 + coin 5 (5 coin X 3)

즉, 다른 코인으로는 15를 바로 만들 수 없으나, 10을 이어받은 5는 만들 수 있기에 경우의 수는 2 이다.

해당 문제는 위 설명의 반복으로 해결 된다.

import sys 
input = sys.stdin.readline 

n,k = map(int,input().split())

coin = [0] * n

for i in range(n):
    coin[i] = int(input())

dp = [0] * (k+1)

for i in range(1,n+1):
    for j in range(coin[i-1], k+1):
        if j == coin[i-1]:
            dp[j] = dp[j-coin[i-1]] + dp[j] + 1
        else:
            dp[j] = dp[j-coin[i-1]] + dp[j]


print(dp[k])

코드 개선

if j == coin[i-1]:
	dp[j] = dp[j-coin[i-1]] + dp[j] + 1

위 공식이 필요하지 않다.

간단하게

dp[0] = 1

처리하면 된다.

즉, dp[0] 은 항상 dp 를 만들어나갈 때 초석이 되는 element 로 활용된다는 것을 기억하면 앞으로 문제에서 이번같이 비효율적으로 코드를 작성할 일이 없어진다.

[백준] - 다이나믹 프로그래밍 동전 2

알 수 없는 사용자 — Wed, 14 Sep 2022 20:54:55 +0900

동전 2

시간 제한메모리 제한제출정답맞힌 사람정답 비율

1 초 (추가 시간 없음)

128 MB

52312

15520

10880

28.955%

문제

n가지 종류의 동전이 있다. 이 동전들을 적당히 사용해서, 그 가치의 합이 k원이 되도록 하고 싶다. 그러면서 동전의 개수가 최소가 되도록 하려고 한다. 각각의 동전은 몇 개라도 사용할 수 있다.

사용한 동전의 구성이 같은데, 순서만 다른 것은 같은 경우이다.

입력

첫째 줄에 n, k가 주어진다. (1 ≤ n ≤ 100, 1 ≤ k ≤ 10,000) 다음 n개의 줄에는 각각의 동전의 가치가 주어진다. 동전의 가치는 100,000보다 작거나 같은 자연수이다. 가치가 같은 동전이 여러 번 주어질 수도 있다.

출력

첫째 줄에 사용한 동전의 최소 개수를 출력한다. 불가능한 경우에는 -1을 출력한다.

예제 입력 1 복사

예제 출력 1 복사

다이나믹 알고리즘을 얼마나 손쉽게 푸느냐가 내 알고리즘 머리 아닐까 하는 생각이 들었다.

굉장히 간단해보이는 문제였지만 풀기가 굉장히 까다로웠다.

문제의 동전 예시는 1, 5, 12 로 굉장히 easy 한 케이스라 조금 더 복잡한 케이스를 생성해서 아이디에이션을 해보았다.

n = 3, k = 20

2, 5, 12 인 경우,

첫번째로 동전을 채우는 과정을 dfs 로 풀려 했는데 당연히 시간 초과가 났다.

재귀함수로 3곳을 다 방문하도록 했는데 이는 방문 횟수가 너무 많다.

easy case 에서도 약 7~ 8 배 차이는 난 것 같다. 복잡해질 수록 이 수는 더 증가한다.

다음과 같은 순서로 알고리즘이 작동한다.

위 표는 순서대로

첫 번째줄: index

두 번째줄: coin 2

세 번째줄: coin 5

네 번째줄: coin 12 이다.

먼저 동전을 채우는 방식이다.

기존에 나는 동전을 채울 때

if index % coin == 0

와 같이 나눠서 0으로 떨어지는 경우를 확인하도록 했는데 이렇게 접근해서는 지금 알고리즘에 도달하기 쉽지 않다.

처음 coin 으로 각 값을 만드는데 필요한 개수를 업데이트를 한다.

그 다음 coin 으로 새롭게 업데이트를 하고 싶다. (이 부분이 골자이다.)

예를 들어 coin 2로 먼저 채우고서 5로 새롭게 업데이트를 하면 우리 머리속에서는

min(coin 2로 채운 값, 5 * x (몇번째 5 coin인가)+ 2 * y(5로 채운 이후 index)) 로 개수를 업데이트 하게 될 것이다.

이는 동전의 개수가 늘어나게 되면 그 개수에 따라 더욱 복잡한 문제가 된다.

이와 같이 우리의 원래 상식으로 해결이 안되는 문제들이 어려운 알고리즘 문제라고 생각한다.

이를 해결하기 위해서 dp 문제에서는 업데이트 되는 array 의 값을 사용한다.

min(coin 2로 채운 값, 5 * x (몇번째 5 coin인가)+ 2 * y(5로 채운 이후 index))

와 유사한 알고리즘이나, 업데이트 되는 array 의 값을 이용하면 동전이 아무리 여러개여도 가장 최근에 업데이트 한 array 값을 사용하기에 array 에 작성된 최소 값에만 집중하면 된다.

이를 구현하기 위해서는 array 값만을 이용해서 coin 개수를 업데이트 할 수 있어야 한다.

이 구현이 바로 아래와 같다.

dp[j] = min(dp[j - coin[i-1]] + 1, dp[j])

array 에는 현재 가능한 최소 값이 기입되어 있으므로 여기서 coin 의 크기만큼 1개를 더해준 것과, 원래 array 에 기입되어 있던 최소 개수를 비교하면 어떤 것이 최소 개수 인지 알 수 있다.

알고보면 어렵지는 않지만 우리 삶에서 찾아볼 수 없는 형태이기에 떠올리기 어려운 알고리즘 이었다.

물론 min 으로 업데이트 해야 하기에 초기 값은 큰 수로 설정해야 하고 array 의 첫 index 값만 0으로 설정해줘야

dp[index - coin 크기] + 1

이 가능하다.

또한 각 coin 의 크기에 따라 dp 에 접근하는 index 의 초기값을 coin 의 크기로 설정해줘야 한다.

최종 구현은 아래와 같다.

import sys 
input = sys.stdin.readline 

n,k = map(int,input().split())

coin = [0] * n
for i in range(n): coin[i] = int(input())
dp = [10001] * (k+1)
dp[0] = 0

for i in range(1, n+1):
    for j in range(coin[i-1], k+1):
        cnt+=1 
        dp[j] = min(dp[j - coin[i-1]] + 1, dp[j]) 

print(dp[k] if dp[k] != 10001 else -1)

[백준] - 다이나믹 프로그래밍 LCS

알 수 없는 사용자 — Mon, 12 Sep 2022 17:55:26 +0900

LCS

시간 제한메모리 제한제출정답맞힌 사람정답 비율

0.1 초 (하단 참고)

256 MB

56865

23037

16944

40.292%

문제

LCS(Longest Common Subsequence, 최장 공통 부분 수열)문제는 두 수열이 주어졌을 때, 모두의 부분 수열이 되는 수열 중 가장 긴 것을 찾는 문제이다.

예를 들어, ACAYKP와 CAPCAK의 LCS는 ACAK가 된다.

입력

첫째 줄과 둘째 줄에 두 문자열이 주어진다. 문자열은 알파벳 대문자로만 이루어져 있으며, 최대 1000글자로 이루어져 있다.

출력

첫째 줄에 입력으로 주어진 두 문자열의 LCS의 길이를 출력한다.

예제 입력 1 복사

ACAYKP
CAPCAK

예제 출력 1 복사

출처

Knapsack 문제이다.

ACAYKP

CAPCAK

이와같이 연속되지 않은 경우 어떻게 해야 겹치는 개수를 카운트 할 수 있을까?

바로 전 문제에서 다뤘던 것과 동일한 방법이다.

연속적이지 않은 누적 합을 구할 때 항상 이 방법을 떠올리면 된다.

https://myjamong.tistory.com/317

백준 9251 파이썬 - LCS - 동적 계획법

백준 9251 파이썬 https://www.acmicpc.net/problem/9251 9251번: LCS LCS(Longest Common Subsequence, 최장 공통 부분 수열)문제는 두 수열이 주어졌을 때, 모두의 부분 수열이 되는 수열 중 가장 긴 것을 찾는..

myjamong.tistory.com

겹친 순간 부터 뒤 까지 모두 겹친 수를 반영해준다. 이로써 추후 업데이트가 가능하다.

추가적으로 이 문제의 경우 밑에서 올라오는 수가 기존 값을 넘어설 수 있으므로

그전 값에서 업데이트 되는 값과 이번에 새롭게 올라온 값의 비교를 해주어야 한다.

A = input().rstrip()
B = input().rstrip()

a = len(A)
b = len(B)
dp = [[0] * (len(B)+1) for _ in range(len(A)+1)]


for i in range(1, a+1):
    for j in range(1, b+1):
            if A[i-1] == B[j-1]: 
                dp[i][j] = dp[i-1][j-1] + 1 
            else:
                dp[i][j] = max(dp[i][j-1], dp[i-1][j])

print(dp)
print(dp[len(A)][len(B)])

그리고 항상 캐시를 초기화 할 때 크기를 N 에 맞춰서 하고 싶은 마음이 있는데, 이 경우 index 0 이전 즉, 오히려 최종 index 에 접근하게 된 경우 예상치 못한 값을 반영할 수 있기 때문에 유의해줘야한다.

다만 이 문제에서는

https://itforfun.tistory.com/231

[백준] 다이나믹 프로그래밍 - 평범한 가방

평범한 배낭 시간 제한메모리 제한제출정답맞힌 사람정답 비율 2 초 512 MB 75395 27716 18066 35.260% 문제 이 문제는 아주 평범한 배낭에 관한 문제이다. 한 달 후면 국가의 부름을 받게 되는 준서는 여

itforfun.tistory.com

이 문제에서는 할 수 없었던 배열 1개 이용하여 업데이트가 가능하다.

여기서는 단어가 겹치는 경우에 무조건 cnt 가 더 업데이트 되어 있기 때문이다.

import sys
read = sys.stdin.readline

word1, word2 = read().strip(), read().strip()
l1, l2 = len(word1), len(word2)
cache = [0] * l2

for i in range(l1):
    cnt = 0
    for j in range(l2):
        if cnt < cache[j]:
            cnt = cache[j]
        elif word1[i] == word2[j]:
            cache[j] = cnt + 1
print(max(cache))

다만 시간 차이는 별로 없고, 이 경우는 모든 경우에 적용 가능한 것이 아니므로 1번을 더 잘 알고 있는 것이 좋은 것 같다.

추후 유사문제를 풀려 하는데 알고리즘이 떠오르지 않았다.

이는 저번에 풀 때 완벽하게 이해하지 못하고 풀어서 인 듯 하다.

해당 문제 알고리즘을 다시 한번 정리해보자면,

ACAYKP

CAPCAK

ACAYKP

CAPCAK

...

ACAYKP

CAPCAK

한칸씩 돈다.

한칸씩 돌 때 다음의 조건을 만족한다.

현재 가장 길게 유지되고 있는 길이가 몇인지 확인할 수 있어야 한다.
새롭게 일치하게 되면 그전까지 index의 값들보다 1이 커진다.
새롭게 일치해지면 당연히 그 이후 index의 값들도 앞선 index 의 크기가 커진만큼 커져야 한다.

LCS 2

계산식을 역으로 해야한다.

[백준] 다이나믹 프로그래밍 - 평범한 가방

알 수 없는 사용자 — Mon, 12 Sep 2022 15:33:10 +0900

평범한 배낭

시간 제한메모리 제한제출정답맞힌 사람정답 비율

2 초

512 MB

75395

27716

18066

35.260%

문제

이 문제는 아주 평범한 배낭에 관한 문제이다.

한 달 후면 국가의 부름을 받게 되는 준서는 여행을 가려고 한다. 세상과의 단절을 슬퍼하며 최대한 즐기기 위한 여행이기 때문에, 가지고 다닐 배낭 또한 최대한 가치 있게 싸려고 한다.

준서가 여행에 필요하다고 생각하는 N개의 물건이 있다. 각 물건은 무게 W와 가치 V를 가지는데, 해당 물건을 배낭에 넣어서 가면 준서가 V만큼 즐길 수 있다. 아직 행군을 해본 적이 없는 준서는 최대 K만큼의 무게만을 넣을 수 있는 배낭만 들고 다닐 수 있다. 준서가 최대한 즐거운 여행을 하기 위해 배낭에 넣을 수 있는 물건들의 가치의 최댓값을 알려주자.

입력

첫 줄에 물품의 수 N(1 ≤ N ≤ 100)과 준서가 버틸 수 있는 무게 K(1 ≤ K ≤ 100,000)가 주어진다. 두 번째 줄부터 N개의 줄에 거쳐 각 물건의 무게 W(1 ≤ W ≤ 100,000)와 해당 물건의 가치 V(0 ≤ V ≤ 1,000)가 주어진다.

입력으로 주어지는 모든 수는 정수이다.

출력

한 줄에 배낭에 넣을 수 있는 물건들의 가치합의 최댓값을 출력한다.

예제 입력 1 복사

예제 출력 1 복사

다이나믹 프로그래밍이라면 증가하는 수열이나 간단한 점화식 문제만 풀어봤었다.

해당 문제 유형은 Knapsack 라고 불린다.

유형을 모르고 접근하다 몇가지 실수를 범했다.

첫 번째로 해당 문제를 만약 brute force 로 돌면 최악의 경우 N = 100 * K = 100,000 로 약 천만번을 돌아야한다는 생각에 index 에 바로 접근할 수 있는 dictionary 사용을 고려했다.

import sys 
from collections import defaultdict 
import copy
input = sys.stdin.readline
N, K = map(int, input().split())

dp = defaultdict(lambda: 0)

for i in range(N):
    W, V = map(int,input().split())
    if dp[W] < V:
        dp[W] = V
    tmp = copy.deepcopy(dp)
    for w,v in tmp.items():
        if w != W and w+W < K+1:
            dp[w+W] = max(dp[w+W], v+V)


print(max(dp.values()))

위와 같이 코드를 짜고서 당당하게 제출했으나 약 80%정도에서 틀렸다.

그 이유는 해당 코드가 가방에 동일한 무게의 물건이 있을경우 처리가 불가하기 때문이다.

동일한 무게가 있을 때 처리가 불가능하다.

그럼 동일한 무게는 어떻게 처리해야 할까?

우선 2D list 를 만들어 각 스텝별로 나눈다.

그 후, 매 스텝별로 업데이트를 한다.

해당 내용에 대한 자세한 설명은

https://ca.ramel.be/33

백준 12865번: 평범한 배낭 (Python, PyPy3)

접근 대표적인 동적 계획법(Dynamic Programming) 문제 중 Knapsack 문제이다. 일단 (N + 1) * (K + 1) 행렬을 준비하여 문제를 풀게 된다. 행 별로 채워가면서 해당 무게별 채울 수 있는 가장 큰 값을 채워나

ca.ramel.be

위 블로그에 너무 잘 정리되어 있다.

N,K = map(int,input().split())

dp = [[0] * (K+1) for i in range(N+1)]
w = [0]
v = [0]
for i in range(N):
    W, V = map(int, input().split())
    w.append(W)
    v.append(V)

for i in range(1,N+1):
    for j in range(1,K+1):
        if j >= w[i]:
            dp[i][j] = max(dp[i-1][j-w[i]] + v[i], dp[i-1][j])
        else:
            dp[i][j] = dp[i-1][j]

print(dp[N][K])

[백준] - 다이나믹 프로그래밍 병사 배치하기, 가장 긴 증가하는 부분 수열 2

알 수 없는 사용자 — Mon, 12 Sep 2022 15:25:26 +0900

병사 배치하기

시간 제한메모리 제한제출정답맞힌 사람정답 비율

1 초

256 MB

6064

2393

1834

41.093%

문제

N명의 병사가 무작위로 나열되어 있다. 각 병사는 특정한 값의 전투력을 보유하고 있으며, 병사를 배치할 때는 전투력이 높은 병사가 앞쪽에 오도록 내림차순으로 배치를 하고자 한다. 다시 말해 앞쪽에 있는 병사의 전투력이 항상 뒤쪽에 있는 병사보다 높아야 한다.

또한 배치 과정에서는 특정한 위치에 있는 병사를 열외시키는 방법을 이용한다. 그러면서도 남아있는 병사의 수가 최대가 되도록 하고 싶다.

예를 들어, N=7일 때 나열된 병사들의 전투력이 다음과 같다고 가정하자.

이 때 3번 병사와 6번 병사를 열외시키면, 다음과 같이 남아있는 병사의 수가 내림차순의 형태가 되며 5명이 된다. 이는 남아있는 병사의 수가 최대가 되도록 하는 방법이다.

병사에 대한 정보가 주어졌을 때, 남아있는 병사의 수가 최대가 되도록 하기 위해서 열외해야 하는 병사의 수를 출력하는 프로그램을 작성하시오.

입력

첫째 줄에 N이 주어진다. (1 ≤ N ≤ 2,000) 둘째 줄에 각 병사의 전투력이 공백을 기준으로 구분되어 차례대로 주어진다. 각 병사의 전투력은 10,000,000보다 작거나 같은 자연수이다.

출력

첫째 줄에 남아있는 병사의 수가 최대가 되도록 하기 위해서 열외해야 하는 병사의 수를 출력한다.

예제 입력 1 복사

7
15 11 4 8 5 2 4

예제 출력 1 복사

LIS , 즉 증가하는 가장 긴 수열이라는 알고리즘은 사실 그냥 떠올리는 것도 어렵지 않다.

해당 문제도 그냥 떠올려서 풀었다.

import sys 
input = sys.stdin.readline 

N = int(input())
sol = list(map(int,input().split()))
sol = [[1,i] for i in sol]

for i in range(1, N):
    for j in range(i-1,-1,-1):
        if sol[i][1] < sol[j][1]:
            sol[i][0] = max(sol[i][0], sol[j][0]+1)


print(N-max([i[0] for i in sol]))

증가하는 가장 긴 수열이 아니라 감소하는 가장 긴 수열로 풀었다.

매번 원소마다 그전의 길이를 참고하여 최대 길이를 업데이트 하는 방식이다.

워낙 쉬운 문제라 별다른 설명은 달지 않는다.

그러나, 이 문제를 해결하고 다른 사람들의 답안을 살피다가 놀란 결과를 확인했다.

사람들이 나보다 약 20배의 빠른 속도로 문제를 해결했다.

살펴보니, binary search 를 사용하여 문제를 해결할 수 있다는 것을 확인했다.

본 문제보다 input 값이 훨씬 많고, 동시에 구하고자 하는 것이 단지 길이일 때 binary search 를 통해 해결 가능하다.

이해한 알고리즘은 아래와 같다.

1 3 5 9

위와 같은 수열이 있다고 하자.

추후 들어오는 수가 1 ~ 9 사이의 값이라면 input 값 보다 값이 크면서 가장 가까운 수를 선택해서 input값으로 대체한다.

이를 대체하는 이유는 대체 과정을 통해 추후 들어오는 수가 뒤에 이어 붙을 수 있도록 최소 값으로 대체하는 것이다.

1 3 5 9 에 2가 들어왔다고 예를 들어보자.

이 경우 1 2 5 9 가 된다. 이는 2를 그냥 대체하는 것은 실제 구하게 될 수열과 다르다고 할 수 있으나, 길이는 동일하다.

추후 3이 들어오게되면 기존에는 3 이후 5 위치에 들어올 수 없었으나 이제 들어올 수 있다.

1 2 3 9

추후 4,5 와 같이 3보다 큰 숫자만 들어오면 이어붙여서 가장 긴 수열을 이어나갈 수 있도록 한다.

가장 긴 증가하는 부분 수열 2

시간 제한메모리 제한제출정답맞힌 사람정답 비율

1 초

512 MB

30486

12399

8658

42.092%

문제

수열 A가 주어졌을 때, 가장 긴 증가하는 부분 수열을 구하는 프로그램을 작성하시오.

예를 들어, 수열 A = {10, 20, 10, 30, 20, 50} 인 경우에 가장 긴 증가하는 부분 수열은 A = {10, 20, 10, 30, 20, 50} 이고, 길이는 4이다.

입력

첫째 줄에 수열 A의 크기 N (1 ≤ N ≤ 1,000,000)이 주어진다.

둘째 줄에는 수열 A를 이루고 있는 Ai가 주어진다. (1 ≤ Ai ≤ 1,000,000)

출력

첫째 줄에 수열 A의 가장 긴 증가하는 부분 수열의 길이를 출력한다.

예제 입력 1 복사

6
10 20 10 30 20 50

예제 출력 1 복사

binary search 를 수행하며 다음의 경우가 필요할 때가 있다.

찾는 값이 없으나 찾고자 하는 값보다 크면서 가장 가까운 값
찾는 값이 없으나 찾고자 하는 값보다 작으면서 가장 가까운 값

해당 문제는 찾는 값이 없으나 찾고자 하는 값보다 크면서 가장 가까운 값을 찾으면 된다 .

아래 블로그에 잘 정리되어있다!

https://yiyj1030.tistory.com/230

이진 검색 binary search의 여러 가지 형태(파이썬 코드)

1. 다음은 가장 잘 알려진 이진 검색 코드다. 찾으려는 값을 target으로 넣어주면 그 값에 해당하는 인덱스를 빠르게 찾아 리턴한다. a= [1,4,5,8,12] def binary_search(target): left = 0 right = len(a)-1 whil..

yiyj1030.tistory.com

위 블로그에서 틀린 부분이 있어서 수정.

import sys 
input = sys.stdin.readline 

N = int(input())
lst = list(map(int,input().split()))
dp = [lst[0]] 


def bisearch(dp, c):
    start = 0 
    end = len(dp)-1

    while(start <= end):
        mid = (start + end) // 2
        if dp[mid] == c:
            return mid 
        elif dp[mid] > c:
            result = mid 
            end = mid -1 
        elif dp[mid] < c: 
            start = mid + 1

    return result 


for i,c in enumerate(lst[1:]):
    if c > dp[-1]:
        dp.append(c)
    else:
        idx = bisearch(dp, c)
        dp[idx] = c


print(len(dp))

알고리즘의 골자는 다음과 같다.

해당 알고리즘은 개수를 구할 때만 사용 가능하다.

첫 원소를 리스트에 추가한다.
input 원소가 리스트의 최종 원소보다 크면 추가한다.
만약 최종 원소보다 input원소가 작으면 리스트내 input 원소보다 크면서 가장 가까운 원소를 택하여 값을 교체한다.

여기서 골자는 input 원소보다 크면서 가장 가까운 원소를 택하여 값을 교체 이 부분이 왜 가능하냐이다.

한마디로만 적자면, input 원소로 대체하여도 어차피 뒤에 있는 원소들이 더 크기가 크기에 원소 대소 비교하여 추가하는 상황에서 문제가 발생하지 않고, 교체하여 리스트가 전반적으로 달라지면 실제로 해당 원소들로 리스트를 꾸릴 수 있는 상황이다.

좀 설명이 어려운데, 직접 손으로 해보면 금방 이해된다.

[백준] - 다이나믹프로그래밍 정수 삼각형

알 수 없는 사용자 — Fri, 9 Sep 2022 17:18:25 +0900

        7
      3   8
    8   1   0
  2   7   4   4
4   5   2   6   5

위 그림은 크기가 5인 정수 삼각형의 한 모습이다.

맨 위층 7부터 시작해서 아래에 있는 수 중 하나를 선택하여 아래층으로 내려올 때, 이제까지 선택된 수의 합이 최대가 되는 경로를 구하는 프로그램을 작성하라. 아래층에 있는 수는 현재 층에서 선택된 수의 대각선 왼쪽 또는 대각선 오른쪽에 있는 것 중에서만 선택할 수 있다.

삼각형의 크기는 1 이상 500 이하이다. 삼각형을 이루고 있는 각 수는 모두 정수이며, 범위는 0 이상 9999 이하이다.

첫째 줄에 합이 최대가 되는 경로에 있는 수의 합을 출력한다.

예제 입력 1 복사

예제 출력 1 복사

위와 같이 삼각형 문제를 풀 때면 항상 input 을 어떻게 받는 것이 효율적일까에 대한 고민을 많이 한다.

항상 아래와 같이 input 을 받았다.

그냥 2N + 1의 크기로 모든 array 를 받고, 말그대로 직관적으로 indexing 을 하는 것이다.

하지만, 생각보다 위와 같이 푸는건 메모리도, 약간의 시간도 그리고 결정적으로 코딩을 하는데 정신적 로드가 크다.

위와 같이 풀면 코드는 아래와 같다.

import sys
input = sys.stdin.readline 

N = int(input())

tri = [[0] * (2*N+1) for _ in range(N)]

for i in range(N):
    tmp = list(map(int, input().split()))
    for j,c in enumerate(tmp):
        tri[i][N-(i)+j*2] = c 

for i in range(1, N):
    for j in range(N-(i), N+(i+1), 2):
            tri[i][j] = tri[i][j] + max(tri[i-1][j-1], tri[i-1][j+1])


print(max([max(i) for i in tri]))

나쁜 코드는 아니다. 직관적이다. 하지만 위 코드를 자세히보면 생각보다 인덱싱이 좀 까다로운 것을 알 수 있다.

N = int(input())
dp = []

for i in range(N):
    dp.append(list(map(int, input().split())))

for i in range(1, N):
    for j in range(i+1):
        up_left = 0 if j == 0 else dp[i-1][j-1]  
        up_right = 0 if j == i else dp[i-1][j]
        dp[i][j] = dp[i][j] + max(up_left, up_right)

print(max(dp[-1]))

하지만 위와 같이 array를 만들지 않아도 index 를 벗어날 경우를 예외 처리하고, 왼쪽 위, 오른쪽 위 index 를 접근하는 것이 각각 current x 좌표 -1, current x 좌표 라는 것을 알면 더 간단하게 코딩하고 정신적 로드도 훨씬 덜하다.

심지어 메모리도 아끼고, 속도도 빠르다.

[백준] - 이진탐색 공유기 설치

알 수 없는 사용자 — Wed, 7 Sep 2022 01:39:18 +0900

공유기 설치

문제

도현이의 집 N개가 수직선 위에 있다. 각각의 집의 좌표는 x1, ..., xN이고, 집 여러개가 같은 좌표를 가지는 일은 없다.

도현이는 언제 어디서나 와이파이를 즐기기 위해서 집에 공유기 C개를 설치하려고 한다. 최대한 많은 곳에서 와이파이를 사용하려고 하기 때문에, 한 집에는 공유기를 하나만 설치할 수 있고, 가장 인접한 두 공유기 사이의 거리를 가능한 크게 하여 설치하려고 한다.

C개의 공유기를 N개의 집에 적당히 설치해서, 가장 인접한 두 공유기 사이의 거리를 최대로 하는 프로그램을 작성하시오.

입력

첫째 줄에 집의 개수 N (2 ≤ N ≤ 200,000)과 공유기의 개수 C (2 ≤ C ≤ N)이 하나 이상의 빈 칸을 사이에 두고 주어진다. 둘째 줄부터 N개의 줄에는 집의 좌표를 나타내는 xi (0 ≤ xi ≤ 1,000,000,000)가 한 줄에 하나씩 주어진다.

출력

첫째 줄에 가장 인접한 두 공유기 사이의 최대 거리를 출력한다.

예제 입력 1 복사

예제 출력 1 복사

힌트

공유기를 1, 4, 8 또는 1, 4, 9에 설치하면 가장 인접한 두 공유기 사이의 거리는 3이고, 이 거리보다 크게 공유기를 3개 설치할 수 없다.

좀처럼 잘 이해가 가지 않았으나 아래 블로그 글을 참고하고 이해를 할 수 있었다.

https://my-coding-notes.tistory.com/119

[ 1 / 백준 2110 / 파이썬] 공유기 설치

2110번: 공유기 설치 첫째 줄에 집의 개수 N (2 ≤ N ≤ 200,000)과 공유기의 개수 C (2 ≤ C ≤ N)이 하나 이상의 빈 칸을 사이에 두고 주어진다. 둘째 줄부터 N개의 줄에는 집의 좌표를 나타내는 xi (0 ≤

my-coding-notes.tistory.com

전에 유사한 문제를 풀이한 적 있었는데, 그때의 풀이는 완전히 잊어버리고 한참 고민을 했다.

결론적으로 정리하자면 공유기를 C개 설치하고자 하는데, 이 중 인접한 두 공유기 사이의 거리를 최대로 하는 경우를 찾아야 한다.

우리의 머리는 이를 아래와 같은 알고리즘으로 풀이한다.

1) 최초 포인트(1)을 잡는다.

2) C 개에 맞춰 얼추 어느정도 거리를 최초점(직전점)으로부터 띄어서 잡는다.

3) 2번 반복

즉 최초포인트로부터 일정 크기 만큼 떨어지기 잡은 포인트들이 총 C개인지 그리고 적절하게 떨어졌는지가 문제해결의 포인트다.

두 점 사이의 거리를 조정하며 포인트가 총 C 개가 될 수 있는 상황 중, 인접한 두 공유기 사이의 거리인 최소 거리를 최대로 하는 경우를 찾아야 한다.

import sys 
input = sys.stdin.readline

N, C = map(int,input().split())

cord = [0] * N

for i in range(N):
    cord[i] = int(input())

cord.sort()

print(cord)

start, end = 1, cord[-1] - cord[0]

if C == 2:
    print(cord[-1] - cord[0])
    exit()

while (start <= end): 
    mid = (start + end) // 2
    tmp = cord[0]
    cnt = 1 
    for i in range(1, N):
        if tmp  + mid <= cord[i]:
            cnt += 1 
            tmp = cord[i]
    if cnt >= C:
        result = mid 
        start = mid + 1 
    else: 
        end = mid - 1

print(result)

해당 문제 풀이에서는 중요하게 고려해야 하는 부분이 있다.어쩌면 당연하게 받아들여야 하는 부분인데 내가 받아들이지 못하는 것일 수도 있다. 다만, 나와 같이 오인한 경우에는 해당 문제를 풀 수 없기에 글을 남긴다.

집에 공유기 C개를 설치하려고 한다. 최대한 많은 곳에서 와이파이를 사용하려고 하기 때문에, 한 집에는 공유기를 하나만 설치할 수 있고, 가장 인접한 두 공유기 사이의 거리를 가능한 크게 하여 설치하려고 한다.

C개의 공유기를 N개의 집에 적당히 설치해서, 가장 인접한 두 공유기 사이의 거리를 최대로 하는 프로그램을 작성하시오.

한 집에 공유기를 하나만 설치할 수 있다는 내용을 적기 위해 최대한 많은 곳에서 와이파이를 사용하려고 한다는 문제이다.

하지만, 문제를 오인하여 최대한 많은 곳, 즉 최대한 많은 좌표에서 와이파이를 사용할 수 있어야 한다고 오인했다.

문제를 해결할 때 사용하는 gap 은 인터넷 수신 거리가 아니다. 애초에 인터넷 수신 거리는 아예 제공된 정보가 아니다.

하지만 gap 을 인터넷 수신 거리로 오인해서 문제를 해결하려고 하니 접근이 어려웠다.

이 전 + gap <= 이후 는 최소한으로 되어야 gap 이 수신기 사이 최소거리로 인정받을 수 있다.

간단한 문제도 오인하면 굉장히 어렵게 느껴진다는 것을 배웠다.

Python Collections

알 수 없는 사용자 — Thu, 1 Sep 2022 20:50:12 +0900

Python Collections Libaray

from collections import Counter

Counter 는 원소의 개수를 세서 dictionary 로 return 해준다.

아주 유용한 기능은 str 의 경우에도 처리가 가능하다는것.

if key in dict:

를 안해도 한줄로 str 의 모든 단어도 count 할 수 있다.

from collections import defaultdict

dictionary 에서 만약 접근한 key 값이 존재하지 않을 때 key error 를 내는 것이 아니라 사전 설정해놓은 값으로 설정

defaultdict(lambda: 0)

이런식으로 설정 가능

from collections import deque

queue 를 호출

원소의 개수가 많아질 수록 list의 append pop 이 아닌, queue 의 사용은 필수이다.

그 이유는 list 의 append 와 pop 은 list 의 크기를 조정하는데 비용이 발생하기 때문이다.

[백준] - DFS 연산자 끼워넣기

알 수 없는 사용자 — Thu, 1 Sep 2022 18:42:31 +0900

연산자 끼워넣기

시간 제한메모리 제한제출정답맞힌 사람정답 비율

2 초

512 MB

68464

35831

22847

49.465%

문제

N개의 수로 이루어진 수열 A1, A2, ..., AN이 주어진다. 또, 수와 수 사이에 끼워넣을 수 있는 N-1개의 연산자가 주어진다. 연산자는 덧셈(+), 뺄셈(-), 곱셈(×), 나눗셈(÷)으로만 이루어져 있다.

우리는 수와 수 사이에 연산자를 하나씩 넣어서, 수식을 하나 만들 수 있다. 이때, 주어진 수의 순서를 바꾸면 안 된다.

예를 들어, 6개의 수로 이루어진 수열이 1, 2, 3, 4, 5, 6이고, 주어진 연산자가 덧셈(+) 2개, 뺄셈(-) 1개, 곱셈(×) 1개, 나눗셈(÷) 1개인 경우에는 총 60가지의 식을 만들 수 있다. 예를 들어, 아래와 같은 식을 만들 수 있다.

1+2+3-4×5÷6
1÷2+3+4-5×6
1+2÷3×4-5+6
1÷2×3-4+5+6

식의 계산은 연산자 우선 순위를 무시하고 앞에서부터 진행해야 한다. 또, 나눗셈은 정수 나눗셈으로 몫만 취한다. 음수를 양수로 나눌 때는 C++14의 기준을 따른다. 즉, 양수로 바꾼 뒤 몫을 취하고, 그 몫을 음수로 바꾼 것과 같다. 이에 따라서, 위의 식 4개의 결과를 계산해보면 아래와 같다.

1+2+3-4×5÷6 = 1
1÷2+3+4-5×6 = 12
1+2÷3×4-5+6 = 5
1÷2×3-4+5+6 = 7

N개의 수와 N-1개의 연산자가 주어졌을 때, 만들 수 있는 식의 결과가 최대인 것과 최소인 것을 구하는 프로그램을 작성하시오.

입력

첫째 줄에 수의 개수 N(2 ≤ N ≤ 11)가 주어진다. 둘째 줄에는 A1, A2, ..., AN이 주어진다. (1 ≤ Ai ≤ 100) 셋째 줄에는 합이 N-1인 4개의 정수가 주어지는데, 차례대로 덧셈(+)의 개수, 뺄셈(-)의 개수, 곱셈(×)의 개수, 나눗셈(÷)의 개수이다.

출력

첫째 줄에 만들 수 있는 식의 결과의 최댓값을, 둘째 줄에는 최솟값을 출력한다. 연산자를 어떻게 끼워넣어도 항상 -10억보다 크거나 같고, 10억보다 작거나 같은 결과가 나오는 입력만 주어진다. 또한, 앞에서부터 계산했을 때, 중간에 계산되는 식의 결과도 항상 -10억보다 크거나 같고, 10억보다 작거나 같다.

예제 입력 1 복사

2
5 6
0 0 1 0

예제 출력 1 복사

30
30

예제 입력 2 복사

3
3 4 5
1 0 1 0

예제 출력 2 복사

35
17

예제 입력 3 복사

6
1 2 3 4 5 6
2 1 1 1

예제 출력 3 복사

54
-24

문제의 핵심은 다음과 같다.

1) 단순 구현으로 brute force 로 풀 수 있는가?

2) 풀 수 없다면 어떤 방법으로 풀어야 하는가?

1) Brute Force

Brute force 로 풀기 위해서는 연산자를 각각 자리에 끼워맞춰 봐야 한다.

각 자리에 연산자를 끼워넣는 방법은?

먼저 permutation 과 combination의 차이를 생각해보자.

아래의 글은 기본 이해를 돕는다.

https://mathbang.net/547

순열과 조합 - 조합이란

순열에 이어 조합이에요. 조합과 순열은 너무 비슷해서 구분하기 어려워요. 정확히 말하면 문제를 푸는 식이 특별히 어려운 게 아닌데 서술형으로 된 문제를 읽고 순열로 풀어야 하는지 조합

mathbang.net

5번의 시행에서 사건 A가 3번 일어날 확률을 구한다고 가정하자.

해당 사건은 한가지만 있는 것이 아니다.

실제는 아래와 같다.

$ ^n C_{r} $

순서를 고려하지 않는 조합이다.

반면 순서를 고려하면 순열이다.

하지만 우리의 경우에는 10번의 시행에서 가지고 있는 모든 경우의 수가 일어나야 한다.

즉 10번의 시행에서 주어진 연산자가 모두 시행되어야 한다.

그리고 (a,b,c,d) 와 (b,c, a,d) 를 같은 것으로 보는 것이 조합이므로 10번의 시행에서 10개 연산자를 모두 시행하는 경우의 수는 단 1개이다.

10번의 시행에서 10개의 연산자의 순서를 섞어 시행하는 경우를 구하려면 바로 permutation 이 필요하고 이는 10! 번의 시행이다. ($10 \times 9 \times 8 \times ... 1$)

다만, 동일한 연산자가 동일 위치에 들어가는 경우는 고려하지 않아도 되므로

set(permutations(lst, n))

set 처리하면 된다.

from itertools import permutations

N = int(input())
lst = list(map(int,input().split()))

#+ - x //
opers = list(map(int,input().split()))
new_opers = []

new_opers += ['+'] * opers[0]
new_opers += ['-'] * opers[1]
new_opers += ['*'] * opers[2]
new_opers += ['//'] * opers[3]

ans = set(permutations(new_opers ,N-1))

ops = {"+": (lambda x,y: x+y), "-": (lambda x,y: x-y), "*": (lambda x,y : x*y), "//": (lambda x,y: x//y if x > 0 else -(-x // y))}

result_min = 1e9
result_max = -1e9

for Noper in ans:
    result = lst[0]
    for i,j in zip(lst[1:], Noper):
        result = ops[j](result, i)
    result_min = min(result, result_min)
    result_max = max(result, result_max)

print(result_max)
print(result_min)

코드 구현 센스라면 수와 연산자를 zip 처리하여 한줄로 깔끔하게 구현할 수 있다.

혹시 list 를 돌지말고 queue 를 선언하면 더 빠를까 싶어서 사용해봤는데 끽해야 원소 개수가 11개인 해당 문제에서는 queue 생성 시간이 더 걸린다. queue 생성 시간은 얼추 20ms 로 생각보다 빠르다는 것을 확인했다. (물론 길이가 길 수록 시간이 더 걸리긴 하겠지만..)

이 문제를 풀면서 주요했던 포인트는 아래와 같다.

permutations vs combinations
set 의 사용
lambda 의 사용으로 깔끔한 코드 정리
zip을 사용함으로써 깔끔한 코드 정리

2) DFS

해당 문제를 DFS 로도 해결이 가능하다는데 도저히 감이 안와서 블로그 글을 참고한다.

https://data-flower.tistory.com/72

[백준 14888번] 연산자 끼워넣기 - 파이썬

문제 링크: https://www.acmicpc.net/problem/14888 14888번: 연산자 끼워넣기 첫째 줄에 수의 개수 N(2 ≤ N ≤ 11)가 주어진다. 둘째 줄에는 A1, A2, ..., AN이 주어진다. (1 ≤ Ai ≤ 100) 셋째 줄에는 합이 N-..

data-flower.tistory.com

N = int(input())
lst = list(map(int,input().split()))

#+ - x // N-1 
opers = list(map(int,input().split()))

ans = lst[0]

result_max = -1e9
result_min = 1e9

def dfs(k, ans):
    global result_max, result_min
    if k == N:
        result_max = max(result_max, ans)
        result_min = min(result_min, ans)

    if opers[0] != 0:
        opers[0] -= 1
        dfs(k+1, ans + lst[k])
        opers[0] += 1
    if opers[1] != 0:
        opers[1] -= 1
        dfs(k+1, ans - lst[k])
        opers[1] += 1
    if opers[2] != 0:
        opers[2] -= 1
        dfs(k+1, ans * lst[k])
        opers[2] += 1
    if opers[3] != 0: 
        opers[3] -= 1
        dfs(k+1, ans // lst[k] if ans >0 else -(-ans // lst[k]) )
        opers[3] += 1

dfs(1, ans)

print(result_max)
print(result_min)

해당 문제는 생각해보면 brute force 로 푼 내 풀이방법도 궁극적으로는 재귀로 구현을 못해서 돌려 구현한 샘이다.

brute force에 set 을 적용한다는 것이 재귀로 각 연산자를 위치에 반복되지 않게 배치할 방법을 구현못한다는 뜻이다.

DFS 에 대한 올바른 이해가 없었다.

나는 DFS 를 노드 방문 문제에서만 풀다보니 DFS 가 정확히 어떤 알고리즘인지 몰랐던 것 같다.

DFS의 깊이 우선 탐색을 한다는 것은 목적지까지 한번 방문하고, 한번씩 전 단계로 돌리면서 방문할 수 있는 모든 경우의 수를 확인하는 알고리즘이다.

그리고 이를 구현하기 위하여 재귀함수를 사용하면서, 재귀함수의 특성을 사용하여

opers[1] += 1 
recursion
opers[1] -= 1

와 같은 테크닉을 사용해야 한다.

이번 문제와 같이 모든 경우의 수를 확인하는 경우 문제들이 종종 있는데 이때 DFS 로 해결가능하다는 것을 기억하자.

ln (x-1) 의 미분

알 수 없는 사용자 — Sun, 28 Aug 2022 01:14:26 +0900

필자에게 자신을 돌아볼 충격적인 일이 있었다.

ln(x - 1)을 미분하는데, 두가지 방법에 따라 결과값이 다르게 나온 것이다.

1) 합성 함수의 미분

$$\ln(x-1)' = g'(f(x))f'(x) $$

$$\ln(x-1)' = \ln'(x-1)(x-1)' $$

$$\ln(x-1)' = \frac{1}{x-1} (-1)$$

$$-\frac{1}{x-1}$$

2) 미분 계수 정의 이용

$$\lim_{h \to 0} \frac{\ln(x-1+h) - \ln(x-1)}{h}$$

$$\lim_{h \to 0} \frac{1}{h} \ln{(\frac{(1-x)+h}{1-x})}$$

$$\lim_{h \to 0} \frac{1}{h} \ln{(1 + \frac{h}{1-x})}$$

$$\lim_{h \to 0} \ln{(1 + \frac{h}{1-x})^{\frac{1}{h}}}$$

$$\lim_{h \to 0} \ln{ \{ (1 + \frac{h}{1-x})^{\frac{1-x}{h}} \} ^{\frac{1}{1-x}}}$$

$$\frac{1}{1-x} \ln{e} = \frac{1}{1-x}$$

2) 미분 계수 정의를 활용한 것에 어떤 문제도 못 느끼고 있었는데, 문뜩 내가 ln 을 함수로 생각하고 있지 않다는 것을 깨달았다.

미분계수 정의를 활용할 때는 또 함수처럼 사용하고 있었지만,

결론만 말하자면 ln 함수안에 x-1 이라는 함수가 있으니, 이건 합성함수로 해결해야만 하는 문제였다 .

미분 계수 정의를 활용해서 합성함수를 다시 증명해보자.

$i(x)$ 는 합성함수

$$\lim_{h \to 0} \frac{i(x+h) - i(x))}{x+h - x}$$

$$\lim_{h \to 0} \frac{g(f(x+h)) - g(f(x))}{f(x+h) - f(x)} \cdot \frac{f(x+h) -f(x)}{x+h - x}$$

$$\rightarrow \textrm{x+h -x 를 옆으로 미루고, 서로 소거되는 f(x+h) - f(x)를 생성} $$

$$\textrm{위 과정으로 인하여} = g'(f(x)) \cdot f'(x)$$

$$\textrm{위 과정과 동일하게} \lim_{h \to 0} \frac{ln(1-x+h) - ln(1-x)}{x+h - x}$$

$$\lim_{h \to 0} \frac{ln(1-x-h) - ln(1-x)}{1-x-h - (1-x)} \cdot \frac{1-x-h - (1-x)}{x+h - x} $$

$$ln'(1-x) \cdot -1$$

이렇게 증명이 된다.

한순간의 착각으로 인해 이해를 하는데 오랜 시간이 걸렸지만, 그래도 결국 잘 이해해냈다.

혹시 최악의 가독성으로 인해 이해가 잘 안가시는 분들은

https://www.youtube.com/watch?v=cLdXZNo2dxs

영상을 추천한다.

[백준] - BFS 특정 거리의 도시 찾기

알 수 없는 사용자 — Fri, 26 Aug 2022 22:00:20 +0900

특정 거리의 도시 찾기

어떤 나라에는 1번부터 N번까지의 도시와 M개의 단방향 도로가 존재한다. 모든 도로의 거리는 1이다.

이 때 특정한 도시 X로부터 출발하여 도달할 수 있는 모든 도시 중에서, 최단 거리가 정확히 K인 모든 도시들의 번호를 출력하는 프로그램을 작성하시오. 또한 출발 도시 X에서 출발 도시 X로 가는 최단 거리는 항상 0이라고 가정한다.

예를 들어 N=4, K=2, X=1일 때 다음과 같이 그래프가 구성되어 있다고 가정하자.

이 때 1번 도시에서 출발하여 도달할 수 있는 도시 중에서, 최단 거리가 2인 도시는 4번 도시 뿐이다. 2번과 3번 도시의 경우, 최단 거리가 1이기 때문에 출력하지 않는다.

입력

첫째 줄에 도시의 개수 N, 도로의 개수 M, 거리 정보 K, 출발 도시의 번호 X가 주어진다. (2 ≤ N ≤ 300,000, 1 ≤ M ≤ 1,000,000, 1 ≤ K ≤ 300,000, 1 ≤ X ≤ N) 둘째 줄부터 M개의 줄에 걸쳐서 두 개의 자연수 A, B가 공백을 기준으로 구분되어 주어진다. 이는 A번 도시에서 B번 도시로 이동하는 단방향 도로가 존재한다는 의미다. (1 ≤ A, B ≤ N) 단, A와 B는 서로 다른 자연수이다.

출력

X로부터 출발하여 도달할 수 있는 도시 중에서, 최단 거리가 K인 모든 도시의 번호를 한 줄에 하나씩 오름차순으로 출력한다.

이 때 도달할 수 있는 도시 중에서, 최단 거리가 K인 도시가 하나도 존재하지 않으면 -1을 출력한다.

예제 입력 1 복사

예제 출력 1 복사

여러모로 유의할 부분이 많았던 문제이다.

1) 시작점이 1이 아닐 수 있다.

2) 출력시 오름차순으로 하나씩 해야한다.

사실 대부분의 최단 거리 문제들이 이와 같을 수 있는데, 문제 푼 경험이 별로 없어서 한 삽질 같다.

주의하자.

3) 최단 거리를 찾는 문제에서는 DFS 는 사용 불가능하다.

DFS 는 깊이 우선 탐색 과정에서 특정 노드를 먼저 방문해버릴 가능성이 있다. 그렇게 되면, 해당 노드로부터 다른 노드까지의 최단 거리가 미리 업데이트 되어 실제로는 최단이 아닌 거리가 반영될 가능성이 있다. (뭐 전체를 매번 돌아보게 한다면 가능하겠지만 이는 너무 너무 비효율적이다.)

따라서 최단 거리에서는 BFS 를 사용해야 하나, 최단 거리에서 BFS 의 경우 사용할 수 있는 경우도 한정이 되어있다.

1. undirected graph 인 경우

2. weight 가 고정값인 경우

그 외에는 다익스트라로 풀어야한다.

시간이 나면 아래글들을 읽어보자.

https://nulls.co.kr/graph/141

[그래프] 27. BFS로 찾은 경로가 최단 경로인 이유

BFS 알고리즘을 이용한 predecessor 방식이 진짜 최단 경로가 맞는지 어떻게 확신할 수 있을까? 이번 장에서는 증명해보겠다. 이것을 이해하기

nulls.co.kr

https://jypthemiracle.medium.com/%EC%B5%9C%EB%8B%A8%EA%B1%B0%EB%A6%AC-%EB%AC%B8%EC%A0%9C-%EC%95%8C%EA%B3%A0%EB%A6%AC%EC%A6%98%EC%97%90-%EB%8C%80%ED%95%9C-%EA%B6%81%EA%B8%88%EC%A6%9D-%EC%A0%95%EB%A6%AC-5b1b813ba1b3

최단거리 문제 알고리즘에 대한 궁금증 정리

DFS, BFS와 다익스트라 알고리즘에 대한 여러가지 의문점

jypthemiracle.medium.com

백준 - 구현 뱀

알 수 없는 사용자 — Fri, 26 Aug 2022 01:49:02 +0900

문제

'Dummy' 라는 도스게임이 있다. 이 게임에는 뱀이 나와서 기어다니는데, 사과를 먹으면 뱀 길이가 늘어난다. 뱀이 이리저리 기어다니다가 벽 또는 자기자신의 몸과 부딪히면 게임이 끝난다.

게임은 NxN 정사각 보드위에서 진행되고, 몇몇 칸에는 사과가 놓여져 있다. 보드의 상하좌우 끝에 벽이 있다. 게임이 시작할때 뱀은 맨위 맨좌측에 위치하고 뱀의 길이는 1 이다. 뱀은 처음에 오른쪽을 향한다.

뱀은 매 초마다 이동을 하는데 다음과 같은 규칙을 따른다.

먼저 뱀은 몸길이를 늘려 머리를 다음칸에 위치시킨다.
만약 이동한 칸에 사과가 있다면, 그 칸에 있던 사과가 없어지고 꼬리는 움직이지 않는다.
만약 이동한 칸에 사과가 없다면, 몸길이를 줄여서 꼬리가 위치한 칸을 비워준다. 즉, 몸길이는 변하지 않는다.

사과의 위치와 뱀의 이동경로가 주어질 때 이 게임이 몇 초에 끝나는지 계산하라.

입력

첫째 줄에 보드의 크기 N이 주어진다. (2 ≤ N ≤ 100) 다음 줄에 사과의 개수 K가 주어진다. (0 ≤ K ≤ 100)

다음 K개의 줄에는 사과의 위치가 주어지는데, 첫 번째 정수는 행, 두 번째 정수는 열 위치를 의미한다. 사과의 위치는 모두 다르며, 맨 위 맨 좌측 (1행 1열) 에는 사과가 없다.

다음 줄에는 뱀의 방향 변환 횟수 L 이 주어진다. (1 ≤ L ≤ 100)

다음 L개의 줄에는 뱀의 방향 변환 정보가 주어지는데, 정수 X와 문자 C로 이루어져 있으며. 게임 시작 시간으로부터 X초가 끝난 뒤에 왼쪽(C가 'L') 또는 오른쪽(C가 'D')로 90도 방향을 회전시킨다는 뜻이다. X는 10,000 이하의 양의 정수이며, 방향 전환 정보는 X가 증가하는 순으로 주어진다.

출력

첫째 줄에 게임이 몇 초에 끝나는지 출력한다.

예제 입력 1 복사

예제 출력 1 복사

# 종료 조건: 뱀이 자신의 몸에 부딪치거나, 벽에 부딪치면 종료

# 사과먹으면 몸이 길어짐, 사과 못 먹으면 길이 유지 (꼬리쪽 길이 없어지고 사과 없는 쪽은 늘어남)

# 즉 일단 늘리고, 사과가 없는 경우 줄이기

# 뱀이 몸을 꺾는 위치가 기록되어 있다.

# 간단하게 board 를 감싸는 벽을 만들고, 뱀의 위치에도 표기를 한다. 벽 혹은 뱀을 만나면 게임은 종료

$\rightarrow$ board 를 감싸는 벽을 꼭 만들 필요는 없긴하다.

#뱀이 꺾는 순간은 2가지로 구현 가능

1. 회전 행렬

뭔가 최근에 회전 행렬을 공부하기도 했고, 쉬울 것 같아서 회전 행렬로 구현하였다.

import sys 
input = sys.stdin.readline
from collections import deque 

N = int(input())
K = int(input())

board = [[0] * (N+2) for _ in range(N+2)]

for i in range(N+2):
    for j in range(N+2):
        if i == 0 or i == N+1 or j == 0 or j == N+1:
            board[i][j] = 2 

for i in range(K):
    r, c = map(int, input().split())
    board[r][c] = 1 
    
L = int(input())

change = []
for i in range(L):
    n, direction = input().split()
    change.append((int(n), direction))
    
time = 0 
i, j = 1, 1
last_i, last_j = 1, 1
time = 0 

board[1][1] = 2
queue = deque([[1,1]])


while(True):
    time += 1 
    j += 1                
   
    if board[i][j] == 1:
        board[i][j] = 2
        queue.append([i,j])
        
    elif board[i][j] == 0:
        board[i][j] = 2 
        queue.append([i,j])
        last_i, last_j = queue.popleft()
        board[last_i][last_j] = 0     

    elif board[i][j] == 2:
        break
        
    for n, direction in change:
        if n == time:
            if direction == 'L':
                board = list(map(list,zip(*board[::-1])))
                i,j = j,i 
                j = N+1 - j 

                queue = deque([[last_j, N+1 - last_i] for last_i, last_j in queue])

            elif direction == 'D':
                board = list(zip(*board[::-1]))
                board = list(zip(*board[::-1]))
                board = list(map(list,zip(*board[::-1])))
                i,j = j,i 
                i = N+1 - i 
                queue = deque([[N+1 - last_j, last_i] for last_i, last_j in queue])
                
print(time)

하지만 회전 행렬로 구현을 하면 다음과 같은 문제가 발생했다.

회전 시키면 기존 index 의 위치도 회전을 시켜줘야 한다.
뱀의 길이가 줄어 들기위해 저장해놓은 위치는 회전에 회전을 거듭한다. 그렇기 때문에 자료구조에 저장을 해놓고 회전할때마다 index 를 변경해줘야한다. 이를 위해 queue 를 사용했다.

정리하자면 회전을 시키는 것 뿐만 아니라 indexing 을 동시에 하고 있을 때는 회전 행렬을 사용하는 것이 쉽지 않다는 것을 깨달았다.

여러번의 회전이 중첩되면서 indexing 이 아예 꼬이는 경우가 발생할 수 있다는 것을 알았다.

회전 행렬로도 문제를 잘 해결했지만, 이 문제는 방향으로 구현할 때 훨씬 수월하다는 것을 배웠다.

2. 방향으로 구현

import sys 
input = sys.stdin.readline
from collections import deque 

N = int(input())
K = int(input())

board = [[0] * (N+2) for _ in range(N+2)]

for i in range(N+2):
    for j in range(N+2):
        if i == 0 or i == N+1 or j == 0 or j == N+1:
            board[i][j] = 2 

for i in range(K):
    r, c = map(int, input().split())
    board[r][c] = 1 
    
L = int(input())

change = []

for i in range(L):
    n, direction = input().split()
    change.append((int(n), direction))

dx = [1, 0, -1, 0]
dy = [0, 1, 0, -1] 

idx = 0
y = 1
x = 1
time = 0
board[y][x] = 2

tail = deque([[1,1]])


while True: 
    x += dx[idx]
    y += dy[idx]

    time += 1
    print(board)

    if board[y][x] == 1:
        board[y][x] = 2
        tail.append([y,x])

    elif board[y][x] == 0 :
        board[y][x] = 2 
        tail.append([y,x])
        t_y, t_x = tail.popleft()
        board[t_y][t_x] = 0
    
    elif board[y][x] == 2:
        break

    for n, direction in change: 
        if time == n:
            if direction == 'D':
                idx = (idx+1) % 4
            elif direction == 'L':
                idx = (idx+3) % 4
            
print(time)

훨씬 더 빠르게 구현할 수 있었다.

실제 동작 속도나 메모리 사용은 유사하다.

※목표: 최적의 코드를 참고해보자.

최적의 코드를 참고해본 결과 나와의 차이는 단순하다.

1)아래의 사진처럼 나는 board 를 감싸는 벽을 만들었으나, 최적 코드는 벽을 감싸지 않고 그냥 0 $\leq$ N 로 구현하였다.

2) for 문으로 방향을 트는 시간이 되었는지 확인하는 건 readability 가 떨어진다. direction 과 time 을 따로저장하거나 dictionary 에 저장하여 in 으로 확인하는 것이 더 좋아보인다.

[프로그래머스] 구현 - 자물쇠와 열쇠

알 수 없는 사용자 — Wed, 24 Aug 2022 20:16:20 +0900

문제 요약 자물쇠와 열쇠

특이한 형태의 자물쇠와 열쇠가 있다.

잠겨있는 자물쇠는 격자 한 칸의 크기가 1 x 1 인 N x N 크기의 정사각 격자 형태이고 특이한 모양의 열쇠는 M x M 크기인 정사각 격자 형태로 되어 있다.

자물쇠에는 홈이 파져있고 열쇠 또한 홈과 돌기 부분이 있다. 열쇠는 회전과 이동이 가능하며, 열쇠 돌기 부분을 자물쇠의 홈 부분에 딱 맞게 채우면 자물쇠가 열린다.

자물쇠 영역을 벗어난 부분에 있는 열쇠와 홈의 돌기는 자물쇠를 여는데 영향을 주지 않지만, 자물쇠 영역 내에서는 열쇠의 돌기부분과 자물쇠의 홈 부분이 정확히 일치해야하며

열쇠의 돌기와 자물쇠의 돌기가 만나서는 안 된다. 자물쇠 모든 홈을 채워 비워있는 곳이 없어야 한다.

아이디어

회전 행렬 에대한 개념이 필요하다.

2D 리스트의 index 에 대한 이해가 필요하다. (어떤 기능이 가능하고 불가능한지 numpy와 혼동하기 쉽다.)

Lock 에 Key 를 각각 껴보기 위해서는 Key 의 블록들이 이동해야한다. 하지만 각 원소를 이동시키는 것은 구현이 어렵다. 간단하게 Lock의 크기를 키워서 key 를 커진 Lock을 순회하며 껴보면 된다.

※ 주의 사항: 더 큰 list 에 작은 list 의 값들을 복사하기 위해서는 전체 원소를 돌며 복사해야 한다. 한번에 복사하는 방법은 list에 없다.

import copy

def check(tmp_ex_lock, N, M):
    for i in range(N):
        for j in range(N):
            if tmp_ex_lock[N+i][N+j] != 1:
                return False
    return True
        

def solution(key, lock):
    answer = False
    
    M = len(key)    
    N = len(lock)
    ex_lock = [[0]*(3*N) for i in range(3*N)]
    
    for i in range(N):
        for j in range(N):
            ex_lock[N+i][N+j] = lock[i][j]
            
    for k in range(4):
        key = list(zip(*key[::-1]))    
        for i in range(2*N):
            for j in range(2*N):  
                tmp_ex_lock = copy.deepcopy(ex_lock)
                for r in range(M):
                    for c in range(M):
                        tmp_ex_lock[i+r][j+c] += key[r][c]
                if check(tmp_ex_lock, N, M):
                    answer = True
                    return answer
    return answer

구현 - 문자열 압축

알 수 없는 사용자 — Tue, 23 Aug 2022 12:58:10 +0900

문자열 압축

한번 풀었던 문제라 간단하게 해결하고 싶었으나 엄청나게 해맸다.

ababcdcdababcdcd
2ab2cd2ab2cd : 2개 단위
2ababcdcd : 8개 단위
문자열을 1개 이상 단위로 압축 할 때 가장 짧은 것의 길이를 return
문자열은 제일 앞부터 정해진 길이만큼 잘라야 한다. 따라서 주어진 문자열을 x/ ababcdcd / ababcdcd 로 자르는 것은 불가능
한번만 나타난 경우 1 은 생략

해당 문제의 해결 골자는 다음과 같다.

반복이 될 수 있는 경우는 글자 1개 ~ 총 글자 // 2 이다.

총 글자 // 2 를 넘어선 순간 반복하면 총 글자 수를 넘어가서 반복이 불가능하다.

문제에서 구하고자 하는 답은 "반복 하는 경우 중 가장 글자 수가 적은 경우" 이다.

즉 반복이 될 수 있는 경우는 글자 1개 ~ 총 글자 // 2 중 가장 총 글자 수가 적은 경우를 찾아야 한다.

앞 뒤 반복을 확인하며 다음의 경우가 발생한다.

1) 몇번 반복되었느냐에 단어의 수가 결정된다.

2) 반복이 멈추는 경우가 앞선 반복 단어의 수가 결정되는 순간이다.

3) 반복을 확인 할 때 앞 단어 그 다음 단어를 비교해서 결정하다 보니 최종 반복 단어는 비교할 다음 단어가 없어 누락될 수 있다.

구현에서 이를 고려해줘야 한다.

4) 반복 수에서 남는 글자들은 나열되므로 총 단어수 % 반복 수로 그 수를 더해준다.

문제 풀이

S = input().rstrip()

lst = []

for i in range(1, len(S)//2 +1):
    first = S[0:i]
    ans = 0
    cnt = 0
    for j in range(i, len(S) -i+1, i):
        next_ = S[j:j+i]
        if first == next_:
            cnt += 1 
        else:
            if cnt != 0:
                ans += (i+1)
                cnt = 0 
            else:
                ans += i

        first = next_
    ans += (i+1) if cnt != 0 else i
    ans += (len(S)%i)
    lst.append(ans)

print(lst)

짧지만 가독성도 떨어지고 생각보다 예외처리 및 구현에 어려움을 겪었다.

아래는 한창 코딩테스트 감이 좋을 때 풀었던 풀이이다.

개선된 풀이방법

def solution(s):
    if len(s) == 1: return 1 

    lst = []
    for i in range(1, len(s)//2+1):
        lst.append([s[j : j + i] for j in range(0, len(s) - i + 1, i)])
    
    answer = []
    for i in lst:
        tmp = 1
        tmp_ans = ''
        for a,b in zip(i, i[1:]+['']):
            if a == b:
                tmp += 1 
            else: 
                tmp_ans += (str(tmp) + a) if tmp > 1 else a
                tmp = 1 
        
        tmp_ans += s[len(''.join(i)):]    
        answer.append(len(tmp_ans))
    
    return min(answer)

문제를 zip 으로 풀 생각은 해봤으나 반복되는 수도 바뀌고 항목을 접근 할 때 어떻게 반복 되는 글자들을 묶어줄지 아이디어가 안떠올랐는데, 그 당시의 나는 떠올랐었던듯 하다. 다만 당시에는 구하고자 하는 정답이 길이임을 고려하여 길이만 처리했으면 되는데 굳이 문자열을 만들고자 했었다. 하지만 사실 반복되는 횟수가 2자리를 넘어갈 수도 있기때문에 이는 문자열을 만드는 것이 유리한 문제였다.

zip 으로 풀때의 장점은 총 두가지이다.

1) 코드의 readability 가 높다.

2) 최종 case 에 대한 처리를 따로 안해줘도 되게 짤 수 있다. - 하지만 이는 경우에 따라 다르긴하다.

정리하자면 리스트를 돌면서 내부의 원소끼리 비교하는 등의 처리를 할 때 처음이나 마지막에 처리가 잘 되는지 않되는지등의 파악을 항상 해주어야 한다.

이번 경우에는 앞 원소와 뒤 원소를 비교하고 다른 경우 앞 원소의 개수를 반영하는 식으로 하다보니 마지막 원소의 개수가 반영이 되지 않았었다.

※ 부록

def solution(S):
    if len(S) == 1: return 1 
    lst = []

    for i in range(1, len(S)//2 +1):
        lst.append([S[j: j+i] for j in range(0, len(S)-i+1 ,i)])


    result = 10e9
    
    for data in lst:
        cnt = 0
        ans = 0 
        for first, second in zip(data, data[1:] + [' ']):
            if first == second:
                cnt += 1 
            else: 
                ans += (len(first) + 1) if cnt != 0 else len(first) 
                cnt = 0
        result = min(ans, result)
    
    return result

위 풀이법으로 개수만 구해서 풀어보려 했으나 많은 경우 실패

비교책이 한개 더 많아져서 첫번 째 겪었던 문제와 유사한 문제 발생.

또한 반복된 문자가 10개 넘어가면 반복 문자 길이 + 1 에서 1 이 2 가 되어야 한다.

즉, 해당 문제는 문자열로 해결하는 것이 가장 지혜롭다.

두 가지 비교

rest = len(S) % len(first) 
if len(ans) + rest< result:
    result = len(ans) + rest

ans += S[len(''.join(data)):]

%가 꽤 빠를 줄 알았는데 비슷하다.

그리디 기출 문제 06 무지의 먹방 라이브

알 수 없는 사용자 — Sun, 21 Aug 2022 16:14:13 +0900

회전판 위 N 개의 음식
각 음식은 1 ~ N 까지의 번호
각 음식 섭취에는 일정 시간 소요

다음의 방법으로 음식 섭취

1. 무지는 1번 음식부터 먹는다. 회전판 번호가 증가하는 순서대로 음식을 무지 앞으로 가져다 놓는다.

2. 마지막 번호의 음식 섭취 후 회전판에 의해 다시 1번 음식이 무지 앞으로 온다.

3. 무지는 음식 하나를 1초 동안 섭취한 후 남은 음식은 그대로 두고, 다음 음식을 섭취 (다음 음식이란 아직 남은 음식 중 가장 가까운 번호의 음식)

4. 회전판이 다음 음식을 무지 앞으로 가져오는데 걸리는 시간은 없다.

import sys 
input = sys.stdin.readline 

food_times = list(map(int,input().split()))
k = int(input())

n = len(food_times)
tmp = 0 

for i in range(k):
    if food_times[(i+tmp)%n] == 0 :
        tmp += 1 
    food_times[(i+tmp)%n] -= 1 

print(food_times)
print((i+tmp+1)%n +1)

간단하게 음식 섭취 시간 리스트를 돌며 답을 구했는데, 정답지는 다른 답을 요구한다.

food_times 의 길이가 1 이상 200,000 이하이고

원소의 개수는

1이상 100,000,000 이하의 자연수,

그리고 k는

1이상 2 x 10의 13 승 이하의 자연수 라는 것을 고려하자.

그냥 brute force 로 도는 것은 시간적으로 문제가 있다.

작은걸 먼저 처리해야 하지 않을까 라는 생각은 했지만 구체적인 알고리즘까지는 잘 연결되지 않았다.

문제 풀이를 위한 알고리즘은 다음과 같다.

먼저 음식 섭취 시간에 따라 우선순위 queue 에 넣는다.

넣을 때는 (섭취 시간, 순서) 로 넣는다.

그 후 우선 순위 queue 에서 첫번째 즉 가장 작은 시간이 걸리는 원소를 뽑아내고 전체 음식 개수를 곱한다.

예를 들어 3 이 가장 작은 시간이라하고 전체 음식 개수가 5개라 할 때 가장 작은 시간이 0 되는 기점은 3 X 5 = 15 만큼 지난 시점이라는 것을 알 수 있다.

K 값에 따라 다르지만 만약 K 값이 굉장이 큰 경우, 다음과 같이 접근을 해야 문제 풀이가 가능하다.

K 값이 작은 경우 예를 들어 4정도라고 생각해보자. 그 때는 간단한 문제이므로 나열식으로 하나씩 접근하면 어려울 것이 없다.

참고한 코드 구현은 다음과 같다.

import sys 
input = sys.stdin.readline 
import heapq
food_times = list(map(int,input().split()))
K = int(input())
heap = []

for i in range(1, len(food_times)):
    heapq.heappush(heap, (food_times[i-1] , i))

n = 0
tmp = 0



while(heap):
    t, idx = heapq.heappop(heap)
    if K - t * len(heap)+1 >= 0:
        K -= t * len(heap)+1
        food_times = [i - K for i in food_times]
    else:
        for i in food_times:
            if i == 0:
                continue
            else:
                tmp += 1 
        tmp = tmp % (len(heap))
        break 

print(tmp+1)

정답지의 구현 방식을 한번 참고해본다.

우선 전체 음식을 먹는 시간보다 k 가 크거나 같은 경우의 처리이다.

if sum(food_times) <= k:
	return -1

queue 에서 빼서 줄인 음식 시간 만큼 다른 음식 시간에서도 빼줘야 한다.

위 구현에서는 이 부분을 실수로 반영하지 않았다.

이와 같은 실수를 하지 않기 위해서는 구현 전에 아이디어를 명확하게 잡고 시작해야한다.

sum_value = 0 # 먹기 위해 사용한 시간
previous = 0 # 직전에 다 먹은 음식 시간 


length = len(food_times)

while sum_value + (heap[0][0] - previous) * length <= K: 
    now = heapq.heappop(heap)[0]
    sum_value = (now - previous) * length 
    length -= 1
    previous = now

해당의 경우 K 변수를 건드리지 않기 위해서 sum_value 라는 변수를 사용했다.

또한 length 변수를 사용했다. 하지만 sum_value 는 K 로 대체 가능하고, len(heap)이 length 변수를 대체할 수 있다.

코드를 더 정리해보자면 아래와 같다.

while K - heap[0][0] * len(heap) > 0:
    tmp = heapq.heappop(heap)[0]
    K -= (tmp - previous) * (len(heap)+1) 
    previous = tmp

또한 최종 나열을 위해서 내 구현과 같이 복잡하게 for 문을 돌 필요가 없다.

heap.sort(key = lambda x: x[1])
print(heap[(K-1) % len(heap)][1])

0인 경우 뛰어넘는다는 뜻은 해당 값을 빼버리면 된다는 뜻이다.

즉 idx 를 기준으로 sort 해주면 해결된다.

for 문을 도는게 조금 더 빠를 수 있지만, 어차피 몇개 안되기 때문에 sort 를 쓰는 것이 깔끔하다.

※여기서는 왜 sort대신 heap sort 를 사용할까?

https://stackoverflow.com/questions/24666602/python-heapq-vs-sorted-complexity-and-performance

Python heapq vs. sorted complexity and performance

I'm relatively new to python (using v3.x syntax) and would appreciate notes regarding complexity and performance of heapq vs. sorted. I've already implemented a heapq based solution for a greedy '...

stackoverflow.com

The heapq is faster than sorted in case if you need to add elements on the fly i.e. additions and insertions could come in unspecified order. Adding new element preserving inner order in any heap is faster than resorting array after each insertion.

The sorted is faster if you will need to retrieve all elements in order later.

즉 정렬 된 list 에 새로운 원소를 집어넣는 경우 heap 은 넣기만 하면 되는데 sort 는 다시 sort 를 사용해야 하므로 더 오래 걸린다.

해당 문제는 반복해서 sort 를 할 필요는 없으므로 그냥 sort 를 쓰는 것이 우선순위 큐를 쓰는 것보다 빠를 수 있다.

그리디 기출 문제 05 볼링공 고르기

알 수 없는 사용자 — Sat, 20 Aug 2022 19:31:50 +0900

문제

A,B 두 사람이 볼링을 치고 있습니다. 두 사람은 서로 무게가 다른 볼링공을 고르려고 합니다. 볼링공은 총 N개가 있으며 각 볼링공마다 무게가 적혀 있고, 공의 번호는 1번부터 순서대로 부여됩니다. 또한 같은 무게의 공이 여러 개 있을 수 있지만, 서로 다른 공으로 간주합니다. 볼링공의 무게는 1부터 M까지의 자연수 형태로 존재합니다.
예를 들어 N이 5이고, M이 3이며 각각의 무게가 차례대로 1,3,2,3,2일 때 각 공의 번호가 차례대로 1번부터 5번까지 부여됩니다. 이때 두 사람이 고를 수 있는 볼링공 번호의 조합을 구하면 다음과 같습니다.

(1번, 2번), (1번, 3번), (1번, 4번), (1번, 5번), (2번, 3번), (2번, 5번), (3번, 4번), (4번, 5번)

결과적으로 두 사람이 공을 고르는 경우의 수는 8가지입니다. N개의 공의 무게가 각각 주어질 때, 두 사람이 볼링공을 고르는 경우의 수를 구하는 프로그램을 작성하세요.

입력

첫째 줄에 볼링공의 개수 N, 공의 최대 무게 M이 공백으로 구분되어 각각 자연수 형태로 주어집니다. (1<=N<=1,000 ,1<=M<=10)
둘째 줄에 각 볼링공의 무게 K가 공백으로 구분되어 순서대로 자연수 형태로 주어집니다. (1<=K<=M)

입력

5 3 
1 3 2 3 2

8 5 
1 5 4 3 2 4 5 2

출력

풀이:

간단하게

1) 순서 신경 안쓴다. 2) 같은 무게 불가능

을 적용해서 조합을 만들고 거기서 같은 수가 반복된 경우를 제거했다

import time
import sys 
input = sys.stdin.readline 
from itertools import combinations

N, M = map(int, input().split())

lst = list(map(int, input().split()))
save = [0] * (M+1)

start = time.time()
ans = list(combinations(lst, 2))

answer = len(ans)
for i in range(len(ans)):
     a,b = ans[i]
     if a == b:
         answer -= 1

print(answer)

 ans = 0

 for i in range(len(lst)-1):
     for j in range(i+1, len(lst)):
         if lst[i] == lst[j]:
             continue 
         ans += 1
         #ans.append((lst[i],lst[j]))

for 문을 돌리면 다음과 같다.

그러나 답지는 더 나은 대안을 제시한다.

for i in lst:
    save[i] += 1 

answer = 0
for i in range(1, M+1):
    N -= save[i]
    answer += (N * save[i])
    
print(answer)

내 풀이는 원소가 8개 일 때

8 + 7 + ... 1 = 36 이다.

그러나 문제지의 방법은

8 + 5 = 13 약 2~ 3 배정도 효율적이다.

아이디어를 정리하자면

A , B 가 선택을 할 때 A 의 선택에 따라 남는 것이 B의 선택이 된다는 논리이다.

1번 볼링	2번 볼링	3번 볼링	4번 볼링	5번 볼링
1	2	1	2	2
7	5	4	2	0

1번 볼링 1개를 선택하면 총 볼링에서 7개가 남는다.

2번 볼링 2개를 선택하면 총 볼링에서 5개가 남는다. (순서는 신경쓰지 않으므로 7 - 2 = 5)

3번 볼링 1개를 선택하면 총 볼링에서 4개가 남는다. (순서는 신경쓰지 않으므로 5 - 1 = 4)

4번 볼링 2개를 선택하면 총 볼링에서 2개가 남는다. (순서는 신경쓰지 않으므로 2 - 2 = 2)

5번 볼링 2개를 선택하면 총 볼링에서 0개가 남는다. (순서는 신경쓰지 않으므로 2 - 2 = 0)