만년필잉크의 데이터 분석 지식 저장소

Python-기초:3.2. 정규 표현식(3) - 메타 문자로 만드는 정규 표현식 패턴

만년필잉크 — Wed, 15 Dec 2021 00:09:49 +0900

이전 포스트까지 정규 표현식이 무엇인지, Python에서 정규 표현식을 어떻게 탐색하는지에 대해 알아보았다. 이번 포스트에서는 가장 중요한 "메타 문자로 정규 표현식 패턴 만들기"에 대해 알아보도록 하겠다.

1. 메타 문자로 정규 표현식 패턴 만들기

메타 문자로 정규 표현식 만들기는 크게 3가지 방법으로 돌아간다.

패턴 문자열 생성: 찾고자 하는 패턴 문자열(문자 클래스)을 생성한다.
패턴 문자의 반복 지정: 패턴 문자열이 몇 번 반복되는지 지정하기
패턴 문자의 위치 지정: 패턴 문자열로 시작하거나 패턴 문자열로 끝나는지 지정한다.

위 3개 과정은 다 함께 진행될 수도 있고, 하나만 진행될 수도 있다. 이 외에도 문자의 패턴들을 그룹으로 만들거나 |(or)를 이용하여, 원하는 패턴이 존재하는 경우를 선택하게 할 수도 있다.
각 부분에 해당하는 메타 문자는 이전 포스트인 <Python-기초:3.0. 정규 표현식(1) - 소개: 정규 표현식과 메타 문자>를 보면 깔끔하게 표로 정리해놨으니, 이를 참고하기 바란다.

2. 패턴 문자열 생성 하기

2.1. 문자 클래스 [ ]

문자 클래스(character class)라고 하며, [ ] 안에는 1개 이상의 문자를 넣을 수 있고, 그 문자 중 하나라도 일치한다면 일치하는 패턴으로 판단한다.

# [abc]라는 정규 표현식 패턴 생성
>>> pattern = "[abc]"
>>> regex_pattern = re.compile(pattern)

>>> Text_cat = "cat"
>>> print(regex_pattern.findall(Text_cat))
<re.Match object; span=(0, 1), match='c'>


>>> print(regex_pattern.findall(Text_cat))
['c', 'a']

"[abc]"는 3개의 문자가 들어 있는 것으로 보이지만, [ ]는 문자 하나로 인식한다.
cat은 "[abc]" 내부의 c와 일치하므로, match 되는 값인 'c'를 반환하였다.
findall() 메서드로 탐색 시, 일치하는 패턴인 ["c", "a"]를 하나하나 반환하였다.

2.2. 문자 클래스 [ ]와 범위 특수 문자 "-"

[ ] 안에 들어간 특수문자는 메타 문자가 아닌 원본 문자의 의미로 사용된다.
그러나, "-"와 "^"는 별개의 의미를 갖는다.
"-"는 문자 클래스 내에서 범위를 의미한다.

>>> pattern = "[0-9]"
>>> regex_pattern = re.compile(pattern)

>>> Text_data = "I have 10 Cats"
>>> print(regex_pattern.findall(Text_data))
['1', '0']

"[0-9]"는 0에서 9까지의 숫자를 의미한다.

>>> pattern = "[a-z]"
>>> regex_pattern = re.compile(pattern)

>>> Text_data = "I have 10 Cats"
>>> print(regex_pattern.findall(Text_data))
['h', 'a', 'v', 'e', 'a', 't', 's']

"[a-z]"는 a부터 z까지의 영문자, 즉 소문자를 의미한다.

>>> pattern = "[A-Z]"
>>> regex_pattern = re.compile(pattern)

>>> Text_data = "I have 10 Cats"
>>> print(regex_pattern.findall(Text_data))
['I', 'C']

[A-Z]는 A부터 Z까지의 영문자, 즉 대문자를 의미한다.

>>> pattern = "[a-z]"
>>> regex_pattern = re.compile(pattern, re.IGNORECASE)

>>> Text_data = "나는 미국의 Hormel Foods의 스팸 통조림 10개를 가지고 있다."
>>> print(regex_pattern.findall(Text_data))

re.compile() 안에 re.IGNORECASE(re.I)를 넣으면 대소문자 구분 없이 사용할 수 있다.

>>> pattern = "[a-zA-Z0-9]"
>>> regex_pattern = re.compile(pattern)

>>> Text_data = "나는 미국의 Hormel Foods의 스팸 통조림 10개를 가지고 있다."
>>> print(regex_pattern.findall(Text_data))
['H', 'o', 'r', 'm', 'e', 'l', 'F', 'o', 'o', 'd', 's', '1', '0']

"[a-z]", "[A-Z]", "[0-9]"는 한 문자 클래스 안에서 동시에 사용될 수 있다.

>>> pattern = "[가-힣]"
>>> regex_pattern = re.compile(pattern)

>>> Text_data = "나는 미국의 Hormel Foods의 스팸 통조림 10개를 가지고 있다."
>>> print(regex_pattern.findall(Text_data))
['나', '는', '미', '국', '의', '의', '스', '팸', '통', '조', '림', '개', '를', '가', '지', '고', '있', '다']

"[가-힣]"을 쓰면 한글에 대해서도 정규 표현식을 사용할 수 있다.

>>> pattern = "[가\-힣]"
>>> regex_pattern = re.compile(pattern)

>>> Text_data = "나는 미국의 Hormel Foods의 스팸 통조림 10개를 가지고 있다. - 힣힣"
>>> print(regex_pattern.findall(Text_data))
['가', '-', '힣', '힣']

"\-"처럼 특수 문자 앞에 역슬래시를 사용하면 본래 문자를 그대로 쓸 수 있다.

2.3. 문자 클래스 [ ]와 반대 특수 문자 "^"

문자 클래스 [ ] 안에 "^"가 들어가면, 그 내용이 반대가 된다.

>>> pattern = "[^가-힣]"
>>> regex_pattern = re.compile(pattern)

>>> Text_data = "나는 미국의 Hormel Foods의 스팸 통조림 10개를 가지고 있다."
>>> print(regex_pattern.findall(Text_data))
[' ', ' ', 'H', 'o', 'r', 'm', 'e', 'l', ' ', 'F', 'o', 'o', 'd', 's', ' ', ' ', ' ', '1', '0', ' ', ' ', '.']

한글을 제외한 모든 문자열이 반환된 것을 볼 수 있다.
공백(" ")도 하나의 문자이며, 이는 문자 클래스 안에 띄어쓰기로 표현할 수 있다.

>>> pattern = "[^가-힣 ]"
>>> regex_pattern = re.compile(pattern)

>>> Text_data = "나는 미국의 Hormel Foods의 스팸 통조림 10개를 가지고 있다."
>>> print(regex_pattern.findall(Text_data))
['H', 'o', 'r', 'm', 'e', 'l', 'F', 'o', 'o', 'd', 's', '1', '0', '.']

>>> pattern = "[\^a-z]"
>>> regex_pattern = re.compile(pattern)

>>> Text_data = "나는 미국의 Hormel Foods의 스팸 통조림 10개를 가지고 있다."
>>> print(regex_pattern.findall(Text_data))
['o', 'r', 'm', 'e', 'l', 'o', 'o', 'd', 's']

"-"와 마찬가지로 앞에 역슬래시를 붙여 "\^"로 만들면 문자열 자체로 사용할 수 있다.

2.4. 별도 표기법을 가진 문자 클래스

앞서 학습한 문자 클래스 중 "[a-z]", "[A-Z]", "[0-9]", "[ ]"는 꽤나 빈번하게 사용되는 문자 클래스기 때문에 이를 별도의 표기법으로도 제공한다.
대표적인 문자 클래스는 6가지로 다음과 같다.

문자 클래스	기능	유사한 기능을 하는 문자 클래스
\d	숫자	[0-9]
\D	숫자가 아닌 것	[^0-9]
\s	공백 문자(공백은 단순 띄어쓰기부터 내려쓰기, 탭 등을 포함)	[ \t\n\r\f\v]
\S	공백 문자가 아닌 것	[^ \t\n\r\f\v]
\w	문자 + 숫자 + 언더바("_")	[a-zA-Z0-9_]
\W	문자 + 숫자 + 언더바("_")가 아닌 것	[^a-zA-Z0-9_]

\t, \n, \r, \f, \v는 이스케이프 문자(Escape Sequence)라 하며, 이에 대한 내용은 이전 포스트 <참고: Python-기초: 2.0. 문자열(1) - 문자열 생성과 이스케이프 문자>를 참고하기 바란다.
대문자는 소문자 문자 클래스의 반대이다.
"\w"와 "\W"의 문자는 단순 영문뿐만 아니라 한글도 포함한다.

>>> pattern = "\W"
>>> regex_pattern = re.compile(pattern)

>>> Text_data = "나는 미국의 Hormel Foods의 스팸 통조림 10개를 가지고 있다."
>>> print(regex_pattern.findall(Text_data))
[' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '.']

위에서 소개한 별도 표기법을 가진 문자 클래스는 [ ] 안에 담을 수도, 따로 사용할 수도 있다.

>>> pattern = "\d"
>>> regex_pattern = re.compile(pattern)

>>> Text_data = "나는 미국의 Hormel Foods의 스팸 통조림 10개를 가지고 있다."
>>> print(regex_pattern.findall(Text_data))
['1', '0']


>>> pattern = "[\d]"
>>> regex_pattern = re.compile(pattern)

>>> Text_data = "나는 미국의 Hormel Foods의 스팸 통조림 10개를 가지고 있다."
>>> print(regex_pattern.findall(Text_data))
['1', '0']

한 문자 클래스에 대해선 별 의미가 없으나, 두 문자 클래스를 동시에 사용할 땐 크게 다르다.

>>> pattern = "\s\d"
>>> regex_pattern = re.compile(pattern)

>>> Text_data = "나는 미국의 Hormel Foods의 스팸 통조림 10개를 가지고 있다."
>>> print(regex_pattern.findall(Text_data))
[' 1']

"\s\d"는 공백 뒤에 숫자가 오는 패턴이므로 '통조림 10개를'에서 ' 1'에 매치된다.

>>> pattern = "[\s\d]"
>>> regex_pattern = re.compile(pattern)

>>> Text_data = "나는 미국의 Hormel Foods의 스팸 통조림 10개를 가지고 있다."
>>> print(regex_pattern.findall(Text_data))
[' ', ' ', ' ', ' ', ' ', ' ', '1', '0', ' ', ' ']

"[\s\d]"는 공백과 숫자를 함께 넣은 문자 클래스 "[ 0-9]"와 같으므로, 다른 결과를 반환한다.

2.5. 모든 문자를 의미하는 Dot "."

"."은 모든 문자열 한자리를 의미한다.
단 "." 은 줄 바꿈 문자 "\n"는 제외한다.

>>> pattern = "\d."
>>> regex_pattern = re.compile(pattern)

>>> Text_data = "나는 미국의 Hormel Foods의 스팸 통조림 10개를 가지고 있다."
>>> print(regex_pattern.findall(Text_data))
['10']

숫자 뒤에 문자가 하나 오는 경우인 10을 가지고 왔다.

>>> pattern = ".\d."
>>> regex_pattern = re.compile(pattern)

>>> Text_data = "나는 미국의 Hormel Foods의 스팸 통조림 10개를 가지고 있다."
>>> print(regex_pattern.findall(Text_data))
[' 10']

공백도 Dot에 해당하므로 ' 10'을 가지고 왔다.

>>> pattern = "\d..."
>>> regex_pattern = re.compile(pattern)

>>> Text_data = "나는 미국의 Hormel Foods의 스팸 통조림 10개를 가지고 있다."
>>> print(regex_pattern.findall(Text_data))
['10개를']

추천하는 방법은 아니지만 Dot를 여러 개 붙여서 문자열의 길이도 지정할 수 있다.
Dot(".")은 기본적으로 줄 바꿈 문자인 "\n"을 제외하지만, re.DOTALL(re.S) 파라미터를 추가함으로써 줄 바꿈 문자도 포함할 수 있다.

>>> pattern = "\d..."
>>> regex_pattern = re.compile(pattern, re.DOTALL)

>>> Text_data = "나는 미국의 Hormel Foods의 스팸 통조림 10개\n 20개를 가지고 있다."
>>> print(regex_pattern.findall(Text_data))
['10개\n', '20개를']

3. 패턴 문자열의 반복 지정

앞서 패턴 문자열을 만드는 법을 배워봤다. 문자 클래스(Character class)는 기본적으로 한 자리이므로, 사용자가 원하는 패턴을 찾아내려면 패턴 문자열의 반복 수를 지정해주면 된다.
반복 수를 지정하는 방법은 다음과 같다.

메타 문자	의미
+	앞의 패턴 문자열이 1번 이상 반복되어야 한다.
*	앞의 패턴 문자열이 0번 이상 반복되어야 한다.
?	앞의 패턴 문자열은 존재할 수도 있고, 없을 수도 있다(0 이상 1 이하).
{n, m}	앞의 패턴 문자열은 n번 이상 m번 이하 반복되어야 한다.
{n, }	앞의 패턴 문자열은 n번 이상 반복되어야 한다.
{n}	앞의 패턴 문자열을 n번 반복되어야 한다.

앞서 학습한 패턴 문자열 작성 방식과 위의 반복 수를 이용해서 문장 내 원하는 패턴을 찾아보도록 사자.
다음과 같은 문장이 있다고 가정해보자.

>>> Sentence = "마동석씨의 핸드폰 번호는 010-1234-5678, 이메일 주소는 Email_ID.1234@naver.com이다."

여기서 핸드폰 번호를 추출해보자.
핸드폰 번호는 01[016789]-[0-9]{4}-[0-9]{4}의 패턴을 갖는다.

>>> pattern = "01[016789]-[0-9]{4}-[0-9]{4}"
>>> regex_pattern = re.compile(pattern)

>>> print(regex_pattern.findall(Sentence))
['010-1234-5678']

아주 쉽게 원하는 패턴을 찾아내었다.
이번에는 이메일 주소를 추출해보자.
이메일 주소의 패턴은 [a-zA-Z]+[a-zA-Z0-9_.]+[@][a-z]+[.][a-z]+[.]?[a-z]? 이다.

>>> pattern = "[a-zA-Z]+[a-zA-Z0-9_.]+[@][a-z]+[.][a-z]+[.]?[a-z]?"
>>> regex_pattern = re.compile(pattern)

>>> print(regex_pattern.findall(Sentence))
['Email_ID.1234@naver.com']

이메일 주소의 패턴에는 "?"가 들어갔는데, 이메일 주소의 도메인은 아래와 같이 존재하는 경우도 있기 때문이다.

>>> Sentence = "나문희씨의 이메일 주소는 Email_ID@company.co.kr이다."

>>> pattern = "[a-zA-Z]+[a-zA-Z0-9_.]+[@][a-z]+[.][a-z]+[.]?[a-z]?"
>>> regex_pattern = re.compile(pattern)

>>> print(regex_pattern.findall(Sentence))
['Email_ID@company.co.k']

정규 표현식의 첫 포스트에서 제시한 아래 예제에서 휴대전화 번호, 집 전화번호, 이메일 주소 들을 따로 추출해보자.

data = [
    "010.1234.5678", "010-1234-5678", "02-1234-5678", "031-123-4567", "042.987.6543",
    "emailID01@naver.com", "emailID02@gmail.com", "Email.03@daum.net", "EM_example.01@gmail.com",
    "email_1234@company.co.kr"
]

>>> pattern = "[a-zA-Z]+[a-zA-Z0-9_.]+[@][a-z]+[.][a-z]+[.]*[a-z]*"
>>> regex_pattern = re.compile(pattern)

>>> print(regex_pattern.findall(data))

re 모듈은 기본적으로 하나의 텍스트 데이터에 대해 동작하므로, for문을 이용해서 하나하나씩 비교하고, 해당하는 list에 담아보도록 하자.

# Data가 담길 기본 list를 생성한다.
cellphone_list = []
homephone_list = []
email_list = []


# 각 카테고리별 패턴
cellPhone_pattern = re.compile("01[016789][\-.][0-9]{4}[\-.][0-9]{4}")
homePhone_pattern = re.compile("0[2-6][1-5]?[\-.][0-9]{3,4}[\-.][0-9]{4}")
email_pattern = re.compile("[a-zA-Z]+[a-zA-Z0-9_.]+[@][a-z]+[.][a-z]+[.]*[a-z]*")


for target in data:
    
    cellPhone_Object = cellPhone_pattern.match(target)
    homePhone_Object = homePhone_pattern.match(target)
    email_Object = email_pattern.match(target)
    
    if cellPhone_Object != None:
        
        cellphone_list.append(cellPhone_Object.group())
        
    if homePhone_Object != None:
        
        homephone_list.append(homePhone_Object.group())
        
    if email_Object != None:
        
        email_list.append(email_Object.group())

>>> print(f"휴대전화 번호: {cellphone_list}")
>>> print(f"휴대전화 번호: {homephone_list}")
>>> print(f"휴대전화 번호: {email_list}")
휴대전화 번호: ['010.1234.5678', '010-1234-5678']
휴대전화 번호: ['02-1234-5678', '031-123-4567', '042.987.6543']
휴대전화 번호: ['emailID01@naver.com', 'emailID02@gmail.com', 'Email.03@daum.net', 'EM_example.01@gmail.com', 'email_1234@company.co.kr']

앞서 학습한 패턴 문자열 생성과 패턴 문자열의 반복 횟수만 지정해주니 아주 간단하게 원하는 패턴만 추출하는 데 성공하였다.

4. 패턴 문자열의 위치 지정

패턴 문자열이 맨 뒤에 있는지, 맨 앞에 있는지만을 지정할 수 있다.
'^': 패턴 문자열 앞에 위치하며, 텍스트의 맨 왼쪽이 해당 패턴 문자열로 시작해야 한다.
'$': 패턴 문자열 뒤에 위치하며, 텍스트의 맨 오른쪽이 해당 패턴 문자열로 끝나야 한다.
아래와 같은 이름 데이터가 있다고 가정해보자.

>>> name = "김영수, 김나연, 최영호, 김영식, 박순자, 최정훈, 박성훈, 김상훈, 최현정, 박성민"

>>> name_pattern = re.compile("^김..")
>>> print(name_pattern.findall(name))
['김영수']


>>> name_pattern = re.compile("^최..")
>>> name_pattern.findall(name)
[]


>>> name_pattern = re.compile("박..$")
>>> name_pattern.findall(name)
['박성민']


>>> name_pattern = re.compile("김..$")
>>> name_pattern.findall(name)
[]

'^', '$' 패턴은 문자열의 맨 처음과 맨 끝만 중요하게 판단한다.
성이 김으로 시작하는 사람을 찾고 싶다면, 물론 간단한 패턴 문자열 생성으로 해결할 수야 있다.

>>> name_pattern = re.compile("[ ]?김..")
>>> name_pattern.findall(name)
['김영수', ' 김나연', ' 김영식', ' 김상훈']

그러나 간단한 몇 개의 조작만 한다면, '^', '$' 메타 문자만을 이용해서도 찾을 수 있다.
먼저 각 이름의 구분자인 ', '를 줄 바꿈 문자인 '\n'으로 바꿔주자.

>>> name_LF = re.sub(", ", "\n", name)
>>> name_LF
'김영수\n김나연\n최영호\n김영식\n박순자\n최정훈\n박성훈\n김상훈\n최현정\n박성민'

re.sub(pattern, repl, string): string에서 pattern에 해당하는 문자열을 repl 문자열로 치환한다.
re.compile에 추가 파라미터 re.MULTILINE(re.M)를 하나 넣어줘 보자.

>>> name_pattern = re.compile("^김..", re.MULTILINE)
>>> name_pattern.findall(name_LF)
['김영수', '김나연', '김영식', '김상훈']

re.MULTILINE은 문자열 전체의 처음이나 끝이 아닌 각 라인의 처음이나 끝으로 설정해주는 파라미터이다.
즉, '^'와 '$'를 각 줄에 적용할 수 있다는 것이다.
이름이 "훈"으로 끝나는 사람도 쉽게 찾을 수 있다.

>>> name_pattern = re.compile("..훈$", re.MULTILINE)
>>> name_pattern.findall(name_LF)
['최정훈', '박성훈', '김상훈']

이 외에도 "\A", "\Z"가 존재하는데, 각각 "^", "$"와 동일한 기능을 갖는다. 유일한 차이라면, re.MULTILINE 파라미터가 있어도 전체에 대해서 작동한다는 것이다.

5. 기타 메타 문자

앞서 소개한 메타 문자 중 "|"와 "()" 이 두 가지를 아직 다루지 않았는데, "|"만 다루고, "()"는 다음 포스팅에서 다루도록 하겠다.
"()"는 Grouping이라는 것으로, 꽤나 복잡한 녀석이라 다음 포스트에서 자세히 설명해보도록 하겠다. 이번 포스트에선 "|"까지만 다루겠다.

5.1. "|": 또는(Or)

"A|B" 패턴 문자열이 있다면, A에 해당하는 패턴 문자열이나 B에 해당하는 패턴 문자열에 대해 가지고 온다.

>>> Text_data = "Banana, Apple, WaterMelon, Melon, StrawBerry"

>>> pattern = "Apple|Banana"
>>> regex_pattern = re.compile(pattern)
>>> print(regex_pattern.findall(Text_data))
['Banana', 'Apple']

지금까지 기본적인 정규 표현식 문법 작성 방법에 대해 알아보았다. 지금까지 다룬 내용만으로도 정규 표현식을 사용하는 것은 크게 어렵지 않으나, 혹시나 정규 표현식에 대해 보다 자세히 학습해보고 싶은 사람이 있을 수도 있으므로, 다음 포스트에서는 정규 표현식에 대한 보다 어려운 부분도 다뤄보도록 하겠다.

Python-기초:3.1. 정규 표현식(2) - Python re 모듈

만년필잉크 — Tue, 14 Dec 2021 16:56:51 +0900

이전 포스트에서 정규 표현식이 무엇인지, 메타 문자가 무엇인지에 대해 가볍게 알아보았다. 앞서 학습한 메타 문자를 예제를 기반으로 제대로 다뤄보려면, 자신이 만든 정규 표현식 패턴이 제대로 만들어졌는지를 확인할 필요가 있다.

이번 포스트에서는 Python에서 정규 표현식을 어떻게 지원하는지 re 모듈을 통해 알아보도록 하겠다. 이번 포스트에서 예제로 정규 표현식으로 만든 패턴을 일부 사용하긴 할 것이나, 이는 다음 포스트에서 자세히 다룰 것이므로 이번에는 참고만 하도록 하자.

1. Python과 re 모듈

정규 표현식으로 만든 패턴 문자열이 제대로 작동하는지 알기 위해선 Python에서 기본적으로 제공하는 re 모듈에 대해 알 필요가 있다.

re 모듈은 Python에서 정규 표현식을 지원하기 위해 제공하는 기본 라이브러리이다.
re 모듈은 컴파일러 객체를 선언하고, 다음과 같은 메서드를 통해 작동한다.

# re 모듈을 가지고 온다.
import re

pattern = "cat"

regex_pattern = re.compile(pattern)

re 모듈의 컴파일 객체는 다음과 같은 메서드를 통해 작동한다.
컴파일 객체는 regex_pattern이 아닌 다른 변수명에 담아도 상관없다.

Method/Attribute	기능
match()	문자열의 왼쪽(시작)부터 컴파일된 정규 표현식 패턴 객체가 일치하는지 판단한다.
search()	문자열 전체에서 정규 표현식 패턴 객체와 일치하는 첫 문자의 위치를 찾는다.
findall()	정규 표현식 패턴 객체와 일치하는 모든 문자열을 찾아 리스트로 반환한다.
finditer()	정규 표현식 패턴 객체와 일치하는 모든 문자열을 찾아 이터레이터(Iterator)로 반환한다.

1.1. match()

match 함수는 왼쪽(시작)부터 정규 표현식 패턴이 일치하는 곳까지를 반환해준다.
왼쪽부터라는 것이 무슨 뜻인지 아리송한 감이 있는데, 이게 정확히 어떻게 돌아가는지 알아보도록 하자.
다음과 같은 정규 표현식 패턴과 Text_data가 있다고 가정해보자.

>>> pattern = "cats"

>>> regex_pattern = re.compile(pattern)

>>> Text_data = "I love cats and I wish I had cats."

Text_data에는 pattern인 cats가 들어 있으므로, 문제없이 찾을 수 있을 것 같다.
이를 match 메서드를 이용해서 탐색해보자.

>>> m = regex_pattern.match(Text_data)
>>> print(m)
None

분명히 "cats"이라는 단어가 Text_data 안에 있음에도 탐색되지 않았다.
이는 match() 메서드가 왼쪽에서부터 탐색하기 때문으로, 주어진 "cats"라는 pattern은 Text_data의 문장 중간에 존재하지, 앞에서부터는 존재하지 않기 때문이다.
"cats"가 나오도록 패턴을 조금 수정해보자.
- 새로운 패턴은 다음 포스트에서 자세히 다룰 것이므로, 일단 따라가 보자!

>>> pattern = ".*cats"
>>> regex_pattern = re.compile(pattern)
>>> Text_data = "I love cats and I wish I had cats."

>>> m = regex_pattern.match(Text_data)
>>> print(m)
<_sre.SRE_Match object; span=(0, 33), match='I love cats and I wish I had cats'>

pattern으로 '.*cats'를 사용하였는데, '.*'는 cats 앞에 문자가 0개 이상 존재한다는 의미다.
즉, 0개 이상 문자가 앞에 존재하는 cats와 일치하는 문장을 탐색한 것이다.
match 메서드는 _sre.SRE_Match 객체를 리턴한다.
_sre.SRE_Match 객체는 Match 된 문자열의 위치, Match 된 문자열을 반환한다.
이를 통해, Match 메서드 시작부터 패턴이 일치하는지 판단한다는 것을 알 수 있다.

이번에는 pattern을 아주 조금만 수정해서 match() 메서드의 성질을 보다 자세히 보자.

>>> pattern = ".*cats "
>>> regex_pattern = re.compile(pattern)
>>> Text_data = "I love cats and I wish I had cats."

>>> m = regex_pattern.match(Text_data)
>>> print(m)
<_sre.SRE_Match object; span=(0, 12), match='I love cats '>

앞서 사용한 pattern 뒤에 스페이스(space)를 추가하자, "I love cats "까지만 출력되었다.
즉, match 메서드는 전체 문장이 얼마나 길든 간에 처음부터 pattern과 일치되는 곳까지만 반환하는 것을 알 수 있다.

1.1.1. match 객체가 제공하는 메서드

앞서 match는 _sre.SRE_Match 객체를 반환한다고 하였는데, 이는 다음과 같은 메서드를 이용해 내부 정보에 접근할 수 있다.

Method / Attribute	기능
group()	매치된 문자열 출력
start()	매치된 문자열의 시작 지점 출력
end()	매치된 문자열의 끝 지점 출력
span()	매치된 문자열의 시작 지점과 끝 지점을 튜플로 출력

예제를 통해 보도록 하자.

>>> pattern = ".*cats "
>>> regex_pattern = re.compile(pattern)
>>> Text_data = "I love cats and I wish I had cats."

>>> m = regex_pattern.match(Text_data)

>>> print(m.group())
>>> print(m.start())
>>> print(m.end())
>>> print(m.span())
I love cats 
0
12
(0, 12)

1.2. search()

search 메서드는 문자열 전체에서 정규 표현식 패턴 객체와 일치하는 첫 문자의 위치를 반환한다.
앞서 만든 예제에 그대로 적용해보도록 하자.

>>> pattern = "cats"
>>> regex_pattern = re.compile(pattern)
>>> Text_data = "I love cats and I wish I had cats."

>>> m = regex_pattern.search(Text_data)
>>> print(m)
<_sre.SRE_Match object; span=(7, 11), match='cats'>

search 메서드도 match 메서드와 동일하게 _sre.SRE_Match 객체를 반환한다.
search 메서드는 match 메서드와 달리 pattern이 처음부터 일치할 필요는 없으며, Text_data 내 가장 먼저 일치하는 문자열의 위치와 문자열을 반환한다.
만약 존재하지 않는 문자열을 검색하면, match와 마찬가지로 None을 반환한다.

>>> pattern = "dogs"
>>> regex_pattern = re.compile(pattern)
>>> Text_data = "I love cats and I wish I had cats."

>>> m = regex_pattern.search(Text_data)
>>> print(m)
None

search() 메서드는 match() 메서드와 동일한 _sre.SRE_Match 객체를 반환하므로, match와 동일한 방법을 통해, 원하는 값을 출력할 수 있다.

>>> pattern = "cats"
>>> regex_pattern = re.compile(pattern)
>>> Text_data = "I love cats and I wish I had cats."

>>> m = regex_pattern.search(Text_data)
>>> print(m.group())
>>> print(m.start())
>>> print(m.end())
>>> print(m.span())
cats
7
11
(7, 11)

1.3. findall()

findall() 메서드는 가장 설명이 깔끔하면서, 유용한 기능을 제공하는 메서드다.
말 그대로, 문장 안에 원하는 텍스트가 존재하면 그 텍스트를 리스트(List)로 모두 가지고 오는 기능으로, 이를 이용해서 해당 문장 안에 패턴에 일치하는 문자열이 몇 개 존재하는지도 쉽게 확인할 수 있다.

>>> pattern = "cats"
>>> regex_pattern = re.compile(pattern)
>>> Text_data = "I love cats and I wish I had cats."

>>> m = regex_pattern.findall(Text_data)
>>> print(m)
['cats', 'cats']

match, search와 달리 리스트를 바로 반환하므로, group, start, end, span과 같은 함수를 사용하지 않는다.

1.4. finditer()

finditer()는 findall()의 진화 버전이라고 할 수 있는 메서드로, Python 초보자라면 그 기능을 알기 쉽지 않다.
finditer()와 findall()의 차이는 결과를 이터레이터(Iterator)로 출력할 것인지 리스트(List)로 출력할 것인지로, List로 출력하면, 사용하기는 단순하나 단지 패턴에 일치하는 단어들을 List에 담아 출력하므로, 그 기능이 한정적이다.
그러나 finditer()는 이터레이터를 통해 값을 반환하므로, 더 많은 정보를 담을 수 있고, 엄청나게 큰 Text_data가 대상일 때, 메모리 측면에서도 훨씬 유리하다.
이터레이터에 대해서는 나중에 자세히 다룰 것이므로, 간단하게 내가 원할 때, 순서대로 값을 반환할 수 있는 녀석이라고 생각하면 된다.
이터레이터는 모든 데이터를 메모리에 올려놓지 않기 때문에 findall()보다 용량을 덜 차지한다는 장점이 있다.

>>> pattern = "cats"
>>> regex_pattern = re.compile(pattern)
>>> Text_data = "I love cats and I wish I had cats."

>>> m = regex_pattern.finditer(Text_data)
>>> print(m)
<callable_iterator object at 0x000001EB3D932358>

출력된 결과가 앞서 봤던 match(), search(), findall()과 다르게 전혀 알아볼 수 없는 녀석이 나왔다.
Python의 이터레이터는 next() 또는 for와 같은 함수를 이용해야 값을 출력할 수 있다.

# 첫 번째 next
>>> next(m)
<_sre.SRE_Match object; span=(7, 11), match='cats'>

# 두 번째 next
>>> next(m)
<_sre.SRE_Match object; span=(29, 33), match='cats'>

# 세 번째 next
>>> next(m)

next()로 이터레이터 안에 있는 값을 꺼내자 _sre.SRE_Match 객체가 반환되는 것을 볼 수 있다.
이터레이터 안에는 2개의 객체만 존재하므로, 마지막 객체 반환 시, StopIteration을 출력하는 것을 볼 수 있다.
이번에는 for문으로 이터레이터 안의 객체를 꺼내보자.

>>> pattern = "cats"
>>> regex_pattern = re.compile(pattern)
>>> Text_data = "I love cats and I wish I had cats."

>>> m = regex_pattern.finditer(Text_data)

>>> for i in m: 
>>>    print(i)
    
<_sre.SRE_Match object; span=(7, 11), match='cats'>
<_sre.SRE_Match object; span=(29, 33), match='cats'>

finditer() 메서드는 findall() 메서드와 달리 _sre.SRE_Match 객체를 반환하므로, 문장 내 패턴에 일치하는 대상들의 위치 정보도 쉽게 반환할 수 있다.

>>> pattern = "cats"
>>> regex_pattern = re.compile(pattern)
>>> Text_data = "I love cats and I wish I had cats."

>>> m = regex_pattern.finditer(Text_data)

>>> for i in m:
>>>    print(i.span())

(7, 11)
(29, 33)

이번 포스트에서는 Python에서 기본적으로 제공하는 re 모듈에 대해 한 번 다뤄봤다. 텍스트 데이터를 다룰 때, re 모듈은 매우 유용하게 사용되므로 꼭 숙지하도록 하자.

다음 포스트에서는 메타 문자를 이용하여, 예제 데이터에 대한 정규 표현식 패턴을 만들어보고, re 모듈로 이를 검증해보도록 하자.

Python-기초:3.0. 정규 표현식(1) - 소개: 정규 표현식과 메타 문자

만년필잉크 — Tue, 14 Dec 2021 14:33:30 +0900

이전 포스트까지 문자열(String)을 다루는 기본적인 방법에 대해 알아보았다. 텍스트 데이터의 양이 적고, 패턴이 매우 단순하다면 앞서 다룬 방법만으로도 충분하겠지만, 이를 넘어서는 텍스트 데이터를 다룰 땐 앞서 다룬 방법만으로는 데이터를 다루기가 보다 곤란하다. 이때 등장하는 것이 문자열이 갖는 특정 규칙을 이용해 패턴을 표현하는 정규 표현식이다.

1. 정규 표현식(Regular Expression)이란?

위키피디아에선 정규 표현식을 다음과 같이 설명한다 <출처: 위키백과, 정규 표현식>.

정규 표현식은 특정 규칙을 가진 문자열의 집합을 표현하는 데 사용하는 형식 언어로, 정규 표현식은 많은 텍스트 편집기와 프로그래밍 언어에서 문자열의 검색과 치환을 위해 지원하고 있으며, 특히 펄과 Tcl은 언어 자체에 강력한 정규 표현식을 구현하고 있다.

이를 이해하기 쉽게 아~~~주 간단하게 표현하면 다음과 같다.

"대상 문자열이 가지고 있는 특정 패턴을 정규 표현식이라는 이름의 패턴 문자열을 이용해서 찾아내는 방법"

당신이 "연락처"라는 데이터를 수집했다고 가정해보자, 응답자들은 단순히 연락처를 적으라고 하였으므로, 휴대전화 번호, 집전화번호, 이메일 주소와 같은 다양한 종류의 연락처를 입력하였고, 당신의 보스는 당신에게 휴대전화 번호와 집전화번호, 이메일 주소를 각각 분리해서 가지고 오라고 지시를 하였다. 애초에 이를 따로 수집했으면 이런 귀찮은 일도 안 생기겠지만, 이미 저질러진 일을 어쩌겠는가!라는 상황에서 유용하게 사용할 수 있는 것이 정규 표현식이다.

정규표현식에 대한 이해를 돕기 위해 수집한 데이터의 예시를 눈으로 보도록 하자.

data = [
    "010.1234.5678", "010-1234-5678", "02-1234-5678", "031-123-4567", "042.987.6543",
    "emailID01@naver.com", "emailID02@gmail.com", "Email.03@daum.net", "EM_example.01@gmail.com",
    "email_1234@company.co.kr"
]

위 예제 데이터를 보면, 휴대전화 번호와 집전화번호, 이메일 주소마다 고유한 패턴을 가지고 있는 것을 볼 수 있다.

다음 패턴은 위 데이터만 대상으로 놓고 분류한 것이다.
휴대전화 번호는 010 특수 기호 '.', '-' 숫자 4자리 '.', '-' 숫자 4자리로 구성되어 있다.
집전화번호는 0 뒤에 1~9의 숫자가 1개에서 2개가 오고 그 뒤에 특수 기호 '.', '-' 숫자 3 ~ 4 자리, '.', '-' 숫자 4자리로 구성되어 있다.
이메일 주소는 ID와 Domain으로 나눠지며, 그 사이에는 '@'가 존재한다.
ID는 영문 대, 소문자와 숫자, 특수문자 '.', '_"로 이루어져 있으며, 맨 앞에는 특수문자가 들어갈 수 없다.
Domain은 소문자로만 이루어져 있으며, 특수문자 '.'를 기준으로 소문자가 1개에서 2개의 그룹으로 연결된다.

정규 표현식은 위 패턴을 하나의 문법으로 만들어 그 문법에 해당하는 대상을 찾거나 바꿀 수 있는 도구다. 즉, 휴대전화 번호만 찾고 싶다면 휴대전화 번호의 기본적인 패턴을 문법으로 만들고 그 문법에 해당하는 텍스트 데이터를 조회하여, 휴대전화 번호만 가지고 오게 할 수 있다.

※ 팁

한 가지 팁이라면, 데이터만 보고 정규 표현식을 사용하는 것보다. 해당 데이터의 생성 방식을 먼저 찾아보고 정규 표현식을 사용하는 것이 일반화 측면에서 더 좋다. 다음과 같은 정보는 잠깐만 인터넷 검색을 해보면 알 수 있는 정보이다.

휴대전화 번호의 통신망 식별번호
- 010, 011, 016, 017, 018, 019
지역번호
- 02, 031, 032, 033, 041, 042, 043, 044, 051, 052, 053, 054, 055, 061, 062, 063, 064

정규 표현식 문법은 각종 특수문자가 섞여 있고, 문법 작성 방식이 가독성과 거리가 꽤 멀기 때문에 지저분해 보인다는 단점이 있어, 많은 데이터 분석 입문자들이 기피하는 경향이 있다. 그러나, 텍스트 데이터를 다룰 때, 정규 표현식을 다룰 수 있고 없고의 차이는 매우 크므로, 조금 고통스럽더라도 함께 공부해보도록 하자(막상 공부해보면 보기보다 할만하다!).

2. 정규 표현식 문법과 메타 문자

Python으로 정규 표현식을 다루는 법을 알기 전에 먼저 정규 표현식 문법부터 알아보도록 하자.
정규 표현식은 언어마다 문법이 조금씩 다르므로, 사용하려는 프로그램 언어에 맞는 정규 표현식 문법을 공부하는 것이 좋다.
정규 표현식 사용 방법은 일반적으로 다음과 같은 순으로 진행된다.

정규 표현식 문법 작성
작성된 문법을 이용한 조작(탐색, 대체 등)

2.1. 메타 문자(Meta characters)

평상시, 큰 의미 없이 사용했던 특수 문자들이 정규 표현식에서는 특정한 기능을 갖는데, 이를 메타 문자라고 한다.
정규 표현식 문법은 이 메타 문자와 찾고자 하는 Text 데이터로 구성된다.
이 특수 문자를 문자 그대로 사용하려면 앞에 '\'(역 슬래시)를 넣어줘야 한다.
역 슬래시는 한국인이 사용하는 일반적인 키보드에서 '￦'로 표기되며, '￦'는 보이기에만 이렇지 실제로는 역 슬래시로 작용하므로, 이를 그냥 사용해도 문제없다.
메타 문자는 크게 '문자의 패턴', '문자의 반복', '문자열의 위치', '기타 기능'으로 구성된다.
대표적인 메타 문자는 다음과 같다.

문자의 패턴		문자의 반복
[]	문자 클래스	+	앞 문자 패턴이 1개 이상
.	임의의 한 문자	*	앞 문자 패턴이 0개 이상
\d	숫자	?	앞 문자가 없거나 하나 있음
\D	숫자가 아닌 것	{n, m}	앞 문자 패턴이 n개 이상 m개 이하
\w	문자, 숫자, _	{n, }	앞 문자 패턴이 n개 이상
\W	문자, 숫자, _가 아닌 것	{n}	앞 문자 패턴이 n개
\s	공백 문자
\S	공백 문자가 아닌 것

문자열의 위치		기타 기능
^	문자열의 시작	\|	또는(or)
$	문자열의 끝	()	문자열 패턴의 그룹화

이번 포스트에서는 정규 표현식이 무엇인지 알아보고, 정규 표현식에 사용되는 메타 문자가 무엇인지 알아보았다. 다음 포스트에서는 Python에서 정규 표현식의 기능을 어떻게 제공하는지 파악해보도록 하자.

Pandas-데이터 프레임, 데이터 조회하기-3. Boolean으로 조회하기.

만년필잉크 — Fri, 10 Dec 2021 18:00:27 +0900

지금까지 Index와 위치를 이용해서 데이터를 조회하는 방법에 대해 알아보았다. Index, 위치를 이용하여 행을 조회하는 것이 가장 빠르지만, 현실적으로 내가 원하는 데이터의 Index와 행의 위치를 미리 아는 것은 불가능하므로 이번 포스팅에서는 특정 조건으로 내가 원하는 행을 찾아내는 방법에 대해 학습해보도록 하겠다.

Pandas와 Boolean

불리언(Boolean)은 논리 자료형이라고도 하며, 참(True)과 거짓(False)을 나타낼 때 사용된다. Python에서 참(True)은 1, 거짓(False)은 0의 정수 값을 가지며, 이 특성을 잘 활용하면 재밌는 코드를 많이 만들어낼 수 있다.

>>> print(f"True의 Type: {type(True)}")
>>> print(f"False의 Type: {type(False)}")
>>> print("----"*10)
>>> print(f"True를 수치로 표현 시: {int(True)}")
>>> print(f"False를 수치로 표현 시: {int(False)}")
>>> print("----"*10)
>>> print(f"True를 수치로 표현 시: {float(True)}")
>>> print(f"False를 수치로 표현 시: {float(False)}")
True의 Type: <class 'bool'>
False의 Type: <class 'bool'>
----------------------------------------
True를 수치로 표현 시: 1
False를 수치로 표현 시: 0
----------------------------------------
True를 수치로 표현 시: 1.0
False를 수치로 표현 시: 0.0

Pandas는 Boolean Series를 이용하여 True인 행은 출력하고, False인 행은 출력하지 않을 수 있다. 이를 더 쉽게 이야기해보면, "내가 원하는 행만 True로 만들면 그 행만 조회할 수 있다"는 것이다.

1. 예제 데이터와 라이브러리 가지고 오기

※ 예제 데이터

이번 포스트에서도 지금까지 사용한 "시험점수.csv" 파일을 예제 데이터로 사용해보도록 하겠다.

사용할 라이브러리는 pandas지만, pandas와 함께 다니는 친구인 numpy도 혹시 쓸 일이 있을지 모르니 가져와주도록 하자.

시험점수.csv

0.00MB

>>> import pandas as pd
>>> import numpy as np

>>> FILE_PATH = "시험점수.csv"

>>> 시험점수 = pd.read_csv(FILE_PATH, encoding="euckr")
>>> 시험점수

해당 예제 데이터는 이름, 성별, 학년, 반, 국어, 수학, 영어, 사회, 과학 총 9개의 열과 80개의 행으로 구성되어 있다.
한글이 깨지는 경우, 위 코드처럼 pd.read_csv(File_path, encoding='euckr')로 불러오면 된다.

2. Series와 Boolean

DataFrame에서 조회할 대상을 가정해보자.

조회할 대상: 3학년이고 2반에 있으며, 국어 점수가 70점 이상인 여학생을 찾는다.

위 대상에 해당하는 속성이 4개나 되므로, 한 번에 찾기는 쉽지 않다.
위 문구를 구성하는 조건을 최소 단위로 쪼개보자.

조건 1: 학년 == 3
조건 2: 반 == 2
조건 3: 국어 >= 70
조건 4: 성별 == "여자"

문구를 최소 단위로 쪼개 보니 꽤 단순해졌다!
방금 정의한 "조회할 대상"은 위 조건 4개에 대해 모두 참(True)인 행이다.
즉, 위 조건 4개에 대해 모두 True인 행을 표현만 할 수 있다면, 위 행에 해당하는 사람의 데이터만 가지고 올 수 있다는 것이다.
지금까지 우리는 Pandas에서 다양한 변수를 담고 있는 데이터(다변량 데이터) 타입인 DataFrame을 다뤄봤는데, 이번엔 단 하나의 변수만 담고 있는 데이터(단변량 데이터) 타입인 시리즈(Series)로 접근을 해보도록 하자.

2.1. 단변량 데이터를 담는 시리즈(Series)

시리즈는 데이터 프레임에서 하나의 컬럼만 뽑으면 쉽게 만들 수 있다.
데이터 프레임 "시험점수"에서 "성별" 시리즈를 뽑아보자.

>>> 시험점수["성별"]
0     남자
1     남자
2     남자
3     남자
4     남자
      ..
75    여자
76    여자
77    여자
78    여자
79    여자
Name: 성별, Length: 80, dtype: object

시리즈는 각 Value에 대한 Index 정보, 시리즈의 이름(Name), 시리즈를 구성하는 원소의 수(Length), 시리즈의 데이터 타입(dtype) 정보를 담고 있다.
이를 하나의 변수만 담고 있는 데이터 프레임이라고 생각해도 큰 문제는 없다.
- 시리즈는 데이터 프레임에서 사용 가능한 함수의 대부분을 지원하므로, 데이터 프레임을 쓸 줄 안다면 큰 어려움 없이 익숙해질 수 있다.
- 단, "시리즈 = 하나의 변수만 담긴 데이터 프레임"은 절대 아니다! 주의하도록 하자!
시리즈는 DataFrame을 만들었던 방법처럼 list나 numpy array 등을 이용해 쉽게 만들 수 있다.

>>> Test_list = ["감", "바나나", "포도", "딸기"]
>>> pd.Series(data=Test_list, name="과일")
0      감
1    바나나
2     포도
3     딸기
Name: 과일, dtype: object

3. Boolean Series를 이용하여 원하는 행을 조회하기.

3.1. 단변량 데이터인 시리즈에 조건 걸기

"시험점수" 데이터 프레임에서 "성별" 시리즈를 뽑고, "여자"인 대상을 찾아보자.
Python은 기본적으로 다음과 같은 비교 연산자를 제공한다.

뜻	같다	다르다	크다	작다	이상	이하
기호	==	!=	>	<	>=	<=

위 비교 연산자를 이용하여 "성별" == "여자"인 대상자를 찾아보자.

>>> 시험점수["성별"] == "여자"
0     False
1     False
2     False
3     False
4     False
      ...  
75     True
76     True
77     True
78     True
79     True
Name: 성별, Length: 80, dtype: bool

비교 연산자를 사용하자 True와 False로 이루어진 Series가 출력되었다.
이 Series에서 True는 "성별" == "여자"인 행을 뜻하며, False는 "성별" != "여자"인 행을 뜻한다.
위에서 생성한 Boolean 시리즈를 이용해서, 제대로 탐색을 하였는지 확인해보도록 하자.

>>> 시험점수[시험점수["성별"] == "여자"].head(10)

출력되는 결과가 매우 길어 df.head(n) 함수를 이용해 상위 n개의 행만 출력되게 하였다.
Pandas의 데이터 프레임은 df[Boolean Series]를 하면, Boolean Series에서 True에 해당하는 행만 출력한다.
앞서, Boolean은 True는 1, False는 0의 값을 갖는다고 하였는데, 이 성질을 이용하면 "성별"=="여자"인 대상의 수를 알 수 있다.

>>> sum(시험점수["성별"] == "여자")
40

sum()은 괄호 안의 list, array, series 등의 Data type에 대해 합계를 내주는 함수로, 40이 나왔으므로 1이 40개 있다는 것을 보여준다.
이는 "성별"=="여자"인 행이 40개 있다는 것으로, 여성의 수가 40명이라는 것을 의미한다.
등호가 돌아가는 원리를 알았으니 이번엔 부등호를 조건으로 걸어보자.

이번엔 부등호로 조회를 해보자.
이번에는 국어 점수가 70점 이상인 대상을 찾아보자.

>>> 시험점수[시험점수["국어"] >= 70].head(10)

국어 점수가 70점 이상인 상위 10명을 뽑아 보았다.
부등호도 등호와 마찬가지로 쉽게 뽑을 수 있다.

3.2. 동시에 2개 이상의 조건 걸기

앞서 시리즈를 이용해 단변량 데이터에 대해 조건을 걸어보았다.
이번엔 2개의 시리즈를 동시에 사용하여 다변량 데이터에 대한 조건을 걸어보도록 하겠다.
이때 사용되는 것이 옛날에 배웠던 집합(Set)이다.
Python에서 주로 사용되는 집합은 교집합, 합집합, 차집합이며, 이들은 다음과 같은 기호를 통해 사용할 수 있다.

집합	교집합	합집합	차집합
기호	&	\|	-

2개의 Boolean Series를 가지고 와보자.

>>> 여자_Boolean_Sr = 시험점수["성별"] >= "여자"
>>> 국어_Boolean_Sr = 시험점수["국어"] >= 70

>>> print(여자_Boolean_Sr)
>>> print("----"*10)
>>> print(국어_Boolean_Sr)
0     False
1     False
2     False
3     False
4     False
      ...  
75     True
76     True
77     True
78     True
79     True
Name: 성별, Length: 80, dtype: bool
----------------------------------------
0      True
1     False
2      True
3      True
4      True
      ...  
75    False
76     True
77    False
78    False
79     True
Name: 국어, Length: 80, dtype: bool

두 Boolean 시리즈를 교집합 해보자.

>>> 여자_Boolean_Sr & 국어_Boolean_Sr
0     False
1     False
2     False
3     False
4     False
      ...  
75    False
76     True
77    False
78    False
79     True
Length: 80, dtype: bool

두 시리즈 모두 True인 행만 True로 나오고, 둘 중 하나라도 False인 행은 False가 되었다.
교집합은 두 가지에 모두 해당해야 한다는 의미이므로, 모두 True인 대상을 가지고 온다.
즉, 두 조건에 동시에 해당하는 행만 교집합 시, True로 출력된다.

>>> 시험점수[여자_Boolean_Sr & 국어_Boolean_Sr].head(10)

이를 이용하면, 조건이 아무리 많다고 할지라도 내가 원하는 대상을 구체적으로 찾아낼 수 있다.
남은 조건인 "학년"==3, "반"==1을 추가하여 앞서 선언한 "조회할 대상"을 찾아보자.

>>> 시험점수[
        (시험점수["성별"] == "여자") &
        (시험점수["학년"] == 3) &
        (시험점수["반"] == 1) &
        (시험점수["국어"] >= 70)
        ]

꽤 복잡한 조건이었음에도 Boolean Series를 사용하여 쉽게 찾아내었다.
2개 이상의 Boolean Series를 변수에 담지 않고 바로 조회하려면 꼭 괄호 안에 넣어주기 바란다(괄호 미사용 시 에러 발생).

지금까지 조건에 해당하는 행 조회 방법에 대해 알아보았다. 다음 포스트에서는 Pandas의 str을 이용하여, 원하는 문자열에 해당하는 행을 탐색하는 방법에 대해 다뤄보도록 하겠다.

Pandas-데이터 프레임, 데이터 조회하기-2. 위치와 슬라이싱

만년필잉크 — Fri, 10 Dec 2021 15:17:51 +0900

이전 포스트에서는 DataFrame의 Index를 기반으로 데이터를 조회하는 방법에 대해 알아보았다. 이번 포스트에서는 위치를 기반으로 데이터를 조회하는 슬라이싱(Slicing)과 iloc[]함수에 대해 알아보도록 하겠다.

슬라이싱(Slicing)을 이용한 데이터 조회

이전 포스트에서 데이터를 조회하는 방법으로 다음과 같은 방법이 있다고 소개하였다.

행의 고유한 key인 Index를 이용하여 내가 원하는 데이터 조회
데이터의 위치를 이용해서 데이터 조회(Slicing)
조건을 이용한 데이터 조회(Boolean)

이번 포스트에서는 "2. 데이터의 위치를 이용한 데이터 조회(Slicing)"에 대해 다뤄보도록 하겠다.

경우에 따라선 데이터의 위치가 조회에 있어 중요한 key로 작동하기도 한다. 그 예는 다음과 같다.

고등학교 중간고사 전교 30등까지의 데이터를 조회
30명이 있는 반에서 6 ~ 12번째 주번이 누구인지 조회
월 소득의 상위 10% 데이터 조회 또는 하위 10% 조회

위와 같은 위치를 이용한 조회를 하려면 기본적으로 행의 순서가 일정한 규칙에 따라 나열되어 있어야 한다. 데이터가 아무런 규칙 없이 위치해 있다면 사용하기 힘들다. 때문에 규칙대로 데이터를 나열하는 정렬(Sort)과 함께 쓰이는 경우가 잦다.

Pandas의 DataFrame은 기본적으로 0부터 n까지의 index를 순서대로 자동 생성하므로, Index를 기반으로 한 조회와 위치를 이용한 조회의 차이를 알기 어려울 수 있으나 Index와 위치는 다음과 같은 차이를 갖는다.

Index는 단순 행의 위치뿐만 아니라 다양한 정보를 담은 특정한 key로 만들 수 있다.
위치 기반 조회는 Index로부터 자유롭게 단순 위치로 데이터를 조회할 수 있다.

예제를 통해 위치를 이용한 데이터 조회를 해보도록 하자.

1. 예제 데이터 가지고 오기

※ 예제 데이터

이번 포스트에서도 저번 포스트에서 사용한 예제 데이터를 그대로 사용해보도록 하겠다.

시험점수.csv

0.00MB

>>> import pandas as pd
>>> import numpy as np

>>> FILE_PATH = "시험점수.csv"

>>> 시험점수 = pd.read_csv(FILE_PATH, encoding="euckr")
>>> 시험점수

해당 예제 데이터는 이름, 성별, 학년, 반, 국어, 수학, 영어, 사회, 과학 총 9개의 열과 80개의 행으로 구성되어 있다.
한글이 깨지는 경우, 위 코드처럼 pd.read_csv(File_path, encoding='euckr')로 불러오면 된다.

2. 순서를 이용해서 데이터를 가지고 오기

순서를 이용해서 데이터를 가지고 오는 방법은 크게 2가지로 다음과 같은 코드를 사용할 수 있다.

df[start:end]
df.iloc[]

두 함수는 기능은 거의 동일하나, 엄밀히 따지면 첫 번째 코드인 df[start:end]를 슬라이싱(Slicing)이라 하며, df.iloc[]는 어려운 말로 명시적 포지션 검색이라 한다.
간단하게 말해서 첫 번째 녀석은 start부터 end까지를 잘라서 보여주는 것이고, 두 번째 녀석은 해당 위치에 있는 것을 가져오는 것으로 이전 포스팅에서 소개한 df.loc[]와 성격이 유사하다.

2.1. 슬라이싱을 통한 데이터 조회

예제 데이터인 "시험점수"의 10번부터 20번까지 데이터를 조회해보도록 하자.
df[start:end]

시험점수[10:20]

아주 간단한 코드를 통해 데이터를 자를 수 있다.
슬라이싱을 통해 가지고 오는 행의 번호는 start 이상, end 미만이다.
슬라이싱은 단순히 처음과 끝만 설정할 수 있는 것이 아니라 간격도 설정해줄 수 있다.
DataFrame 시험점수의 10번부터 20번까지를 2를 간격으로 조회해보도록 하자.
df[start:end:step]

>>> 시험점수[10:20:2]

start나 end 둘 중 하나를 지정해주지 않으면, "start부터 끝까지" 또는 "처음부터 end"까지로 슬라이싱할 수도 있다.
68번째 이후의 데이터를 전부 조회해보고, 처음부터 15번째까지의 데이터를 조회해보도록 하자.

>>> 시험점수[68:]

>>> 시험점수[:15]

여기서도 간격을 설정해줄 수 있다.

>>> 시험점수[:15:2]

2.2. 슬라이싱을 이용한 역순 조회

2.2.1. Step을 이용한 역순 조회

슬라이싱의 각 인자들을 음수로 부여하면 역순으로 조회할 수 있다.
전체 데이터를 역순으로 조회하려면 step을 -1로 지정하면 된다.

>>> 시험점수[::-1]

step을 -1로 설정하고 start를 지정해주면 start부터 역순 조회도 가능하다.

>>> 시험점수[4::-1]

step을 -1로 설정하고 end를 설정하면, 맨 뒤에서부터 시작하여 end까지로 조회된다.

>>> 시험점수[:4:-1]

step을 음수로 지정해주면, DataFrame의 순서를 깔끔히 뒤집어 조회하는 것을 볼 수 있다.

2.2.2. Step을 지정하지 않은 역순 조회

step을 음수로 지정하고 조회하면 데이터가 반대로 뒤집혀서 조회되는 것을 보았다.
step을 음수로 지정하지 않고 start나 end만 음수로 지정하면 데이터를 뒤집지 않은 본래의 상태에서 뒤에서부터 조회가 된다.
start를 음수 m으로 지정하고 end를 지정하지 않으면 뒤에서부터 m개의 행을 반환한다.

>>> 시험점수[-4:]

start를 지정하지 않고 end를 음수 n으로 지정하면 뒤에서부터 n개의 행을 제외하고 반환한다.

>>> 시험점수[:-4]

start를 음수 m으로 end를 음수 n으로 입력 시 뒤에서부터 m:n의 행을 가지고 온다.
단, start의 음수 m이 end의 음수 n보다 커야 한다(그렇지 않다면, 행이 하나도 조회되지 않는다).

>>> 시험점수[-7:-4]

>>> 시험점수[-4:-4]

>>> 시험점수[-2:-4]

2.3. 슬라이싱과 인덱스

슬라이싱은 기본적으로 행의 순서를 기반으로 행을 조회하지만, 인덱스를 대상으로도 조회가 가능하긴 하다.
시험점수 DataFrame의 "이름"칼럼을 Index로 설정하고, "지원"부터 "민서"까지의 행을 조회해보자.

>>> 시험점수.set_index("이름", inplace=True)
>>> 시험점수["지원":"민서"]

해당 기능은 앞서 다뤘던 Index의 범위를 이용한 조회와 유사하다.

>>> 시험점수.loc["지원":"민서"]

다만, 해당 방법은 중복이 있는 Index에 대해서 Slicing을 할 곳을 특정할 수 없으므로, 동작하지 않는다.

>>> 시험점수.loc["영호":"하윤"]

또, 인덱스를 다른 숫자로 정의한다면, 인덱스를 무시하고 순서로 슬라이싱을 한다.

# 30에서 110까지의 정수를 새로운 인덱스로 정의하였다.
>>> 시험점수.reset_index(drop=False, inplace=True)
>>> 시험점수.index = range(30, 110)
>>> 시험점수

>>> 시험점수[30:40]

30에서 110으로 Index를 바꿨으므로, Index로 슬라이싱 되면 30에서 40까지의 Index로 출력되어야 하나, 30번째 행에서 40번째 행에 위치한 Index인 60~69가 출력되었다.

2.4. df.iloc[]를 이용한 조회

앞서 슬라이싱을 이용한 순서 기반 조회를 해보았다.
슬라이싱은 Pandas의 DataFrame, Series뿐만 아니라 list, numpy array 등 Python의 다양한 data type에서 지원하는 기능이지만, Pandas는 여기에 더해서 df.iloc[] 또는 Sr.iloc[] 함수를 통해 위치 기반 조회를 할 수 있다.

>>> 시험점수.reset_index(drop=True, inplace=True)
>>> 시험점수.loc[5]
이름     순자
성별     여자
학년      1
반       1
국어     80
수학    100
영어     75
사회     70
과학     65
Name: 5, dtype: object

>>> 시험점수.loc[5:10]

iloc는 기본적으로 슬라이싱과 기능이 매우 유사하므로, 슬라이싱에서 다뤘던 기능들이 대부분 동일하게 실행된다.
단, iloc는 인덱스 기반 조회는 불가능하다.

>>> 시험점수.set_index("이름", inplace = True)
>>> 시험점수.iloc["지원":"민서"]

이번 포스트에서는 위치를 기반으로 필요한 행을 조회하는 슬라이싱과 iloc함수를 알아보았다. 다음 포스트에서는 특정 조건을 기반으로 행을 조회하는 Boolean 기반 행 조회 방법에 대해 알아보도록 하자.

Pandas-데이터 프레임, 데이터 조회하기-1. Index로 조회하기

만년필잉크 — Thu, 9 Dec 2021 10:10:19 +0900

얼마만의 포스팅인지... 가장 최근에 한 포스팅이 2021년 05월 17일이니, 반년 조금 넘는 기간 동안 포스팅을 안 했다.

나름의 변명이라면 올해 4월에 새로운 직장에 가고, 프로젝트를 하나 둘 맡아서 하다 보니 정신이 없기도 했고, 프로젝트를 어느 정도 마무리 짓고 여유가 나자 그놈의 디아블로 2가 나와버리는 바람에 시간이 슉 지나가버렸다.

너무도 감사하고, 죄송스럽게도 많은 분들께서 찾아와 주셔서, 미약한 실력이나마 도움이 될 수 있기를 바라며 다시 한번 포스팅을 해보고자 한다. 과연, 포스팅하고자 했던 것들을 전부 올리고, 새로운 영역을 파헤쳐 갈 수 있을까?

데이터 프레임, 데이터 조회하기

Python을 사용하는 데이터 분석가에게 가장 기초가 되는 Pandas를 다룬 것이 올해 초인 2021.02.24일이었으니, 다음에 뭘 다루려 했었는지 가물가물하다. 앞서 DataFrame의 Index와 Column명을 가지고 노는 법에 대해 알아봤으니, 이번 포스팅에서는 Index와 Column명을 이용해서 내가 원하는 데이터만 가지고 오는 법에 대해 알아보도록 하겠다.

데이터 프레임의 가장 큰 장점은 누구든지 이해하기 쉬운 형태로 데이터를 볼 수 있다는 것이지만, 데이터의 양이 많아질수록 한눈에 들어오지 않을 정도로 데이터가 거대해지기 때문에, 내게 필요한 데이터만 조회하는 법을 알아야 한다.

데이터 프레임의 조회 방식은 크게 index와 column 명으로 조회하는 방법, 데이터의 순서를 기반으로 조회하는 방법, Boolean으로 조회하는 방법이 있는데, 이를 찬찬히 알아보도록 하자.

내가 원하는 데이터를 가지고 오기

내가 원하는 데이터를 가지고 오는 방법은 크게 3 가지가 있다.

내가 원하는 행을 가지고 오기
내가 원하는 열을 가지고 오기
내가 원하는 행과 열을 가지고 오기

여기서 내가 원하는 행을 가지고 오는 방법이 비교적 복잡하며, 원하는 행을 가지고 온 후 내가 필요한 열을 설정해주면, 문제는 쉽게 해결된다.
그러므로, 행을 가지고 오는 방법을 위주로 다뤄보도록 하자.
Pandas의 DataFrame에서 내가 원하는 행을 가지고 오는 방법도 크게 3가지가 있다.

Index를 이용해서 가지고 오기(loc)
위치를 이용해서 가지고 오기(슬라이싱, iloc)
조건을 이용해서 가지고 오기(Boolean)

이번 포스트에서는 Index를 이용해 내가 원하는 데이터를 가지고 오는 방법에 대해 다뤄보도록 하자.

1. 예제 데이터 가지고 오기

※ 예제 데이터

해당 예제 데이터는 이름, 성별, 학년, 반, 국어, 수학, 영어, 사회, 과학 총 9개의 열(Column)과 80개의 행(Row)으로 구성된 csv파일이다. 당분간 이 데이터로 학습을 진행해보도록 하자.

시험점수.csv

0.00MB

다운로드 받은 위 예제 데이터("시험점수.csv")파일을 내 워킹 디렉토리(Working Directory)로 이동시키거나, 파일의 경로를 이용해서 불러와보도록 하자.

>>> import pandas as pd
>>> import numpy as np

>>> FILE_PATH = "시험점수.csv"

>>> 시험점수 = pd.read_csv(FILE_PATH, encoding="euckr")
>>> 시험점수

R과 비교되는 파이썬의 가장 큰 장점은 한글 사용이 비교적 자유롭다는 것이다.
파이썬은 utf-8 기반으로 만들어져 있기 때문에 데이터뿐만 아니라 변수명을 한글로 써도 큰 문제가 없다.

혹시 모르는 에러가 발생할 위험이 있으므로, 그래도 영어를 사용하는 것을 추천한다!!
한글이 들어 있는 파일이라면 파일의 경로만을 이용해서 데이터를 가져오는 경우, 한글이 깨지는 경우가 있는데, 이는 대부분 Encoding 문제로, pd.read_csv() 함수의 encoding 파라미터를 "euckr"로 지정하면 거의 해결된다.

2. Index를 이용해서 데이터를 가지고 오기.

데이터 프레임에서 내가 원하는 행을 조회하는 가장 빠른 방법은 Index를 이용하는 것이다.
- Index는 유일하게 존재하는 고유한 값일 수도 있으나, 중복된 값일 수도 있다.
- Index를 이용한다면, 데이터 조회뿐만 아니라 데이터 병합(Merging)도 쉽게 할 수 있다.
Index로 조회하는 방법은 다음과 같다.
df.loc[index]: index에 해당하는 DataFrame의 행을 가지고 온다.

2.1. 하나의 index를 가지고 와보자.

index 60번을 가지고 와보자.

>>> 시험점수.loc[60]
이름    민준
성별    남자
학년     4
반      1
국어    90
수학    75
영어    80
사회    70
과학    60
Name: 60, dtype: object

>>> type(시험점수.loc[60])
pandas.core.series.Series

하나의 index를 조회하자, Series Type으로 해당 index 정보가 조회되는 것을 볼 수 있다.
이 시리즈에서 이름을 하나의 값으로 가지고 와보도록 하자.

>>> Index60_Sr = 시험점수.loc[60]
>>> Index60_Sr["이름"]
'민준'

파이썬의 딕셔너리(Dictionary) 객체처럼 내가 원하는 변수명을 key로 주니, 내가 원하는 값이 반환되는 것을 볼 수 있다.

2.2. 여러 개의 index를 가지고 와보자.

이번에는 여러 개의 index를 한 번에 가지고 와보도록 하자.
15, 20, 30, 45번의 Row를 가지고 와보도록 하겠다.
여러개의 index를 한번에 조회는 내가 원하는 index들이 들어있는 list를 만들어 loc에 넣으면 된다.

>>> 시험점수.loc[[15,20,30,45]]

이전과 다르게 이번에는 index에 해당하는 데이터 프레임으로 결과가 조회되는 것을 볼 수 있다.
위 방법을 응용하면 Index A부터 Index B까지 조회도 가능하다.

>>> index_range = range(15,20) 
>>> 시험점수.loc[index_range]

>>> 시험점수.loc[15:20]

다만 Index의 범위를 이용하여 탐색하는 방법은 위 방법보다 다음에 다룰 Slicing이 더 많이 사용되므로, 이런 것도 있구나~ 하고 넘어가도록 하자.

※ 주의 사항

일반적인 파이썬 슬라이싱 방식은 start:end 일 경우, start부터 end-1까지의 연속된 값을 반환하나, .loc[start:end]는 start 부터 end 까지의 연속된 index를 조회한다.

시험점수[15:20]

일반적인 슬라이싱 방식은 위 방식으로 하며, DataFrame.loc[Index]는 Index에 속해 있는 모든 index의 행을 가지고 온다.

2.3. index와 column으로 조회해보자.

해당 Index에서 특정 Column의 데이터만 보고 싶다면, index와 column을 동시에 넣어 조회하면 된다.
앞서 소개한 df.loc[index]를 아래와 같이 쓰면 된다.
- df.loc[index, column]
16번 index의 국어 점수를 조회해보자.

>>> 시험점수.loc[16, "국어"]
75

해당 방법을 통해 내가 필요한 값을 하나의 원소로 출력하였다.
이번에는 index 16의 이름, 학년, 반, 국어 점수를 동시에 출력해보도록 하자.

>>> 시험점수.loc[16, ["이름", "학년", "반", "국어"]]
이름    정숙
학년     1
반      2
국어    75
Name: 16, dtype: object

내가 필요한 index들을 list에 담아 조회하였듯, 조회하고자 하는 column들을 list에 넣어 조회하면 해결된다.
이번엔 index를 16, 20, 25로 column을 이름, 학년, 반, 국어로 조회해보자.

>>> 시험점수.loc[[16, 20, 25], ["이름", "학년", "반", "국어"]]

2.4. 값을 Index에 넣어 조회해보자.

앞서 다뤘던 방법들은 내가 원하는 Index를 알고 있다는 전제하에 유용하지만, 대부분 Index는 자동으로 설정되는 0~n 사이의 값이므로 이를 활용하는 것은 쉽지 않다.
이럴 땐, 특정 열을 Index로 만들어 조회하는 것으로 이 문제를 해결할 수 있다.
"이름" column을 Index로 만들어보자.
df.set_index(column, drop=True, inplace=False): column을 df의 index로 설정한다.

>>> 시험점수.set_index("이름", inplace=True)
>>> 시험점수

inplace = True로 설정하면, df.set_index의 대상인 df에 바로 이를 적용할 수 있다.
default인 inplace를 False로 하면 df.set_index의 결과만 출력한다.
drop=False로 설정하면, 기존 index를 제거하지 않고 데이터 프레임의 열로 추가한다.
index를 "영철"로 조회해보자.

>>> 시험점수.loc["영철"]

DataFrame의 Index는 고유한 값이 아니어도 설정 가능하므로, 위와 같이 "이름"이 "영철"에 해당하는 Row를 모두 가지고 오는 것을 볼 수 있다.
Index를 초기 상태로 돌려보자.

>>> 시험점수.reset_index(drop=False, inplace=True)
>>> 시험점수

이번에는 학년이 1학년인 사람들만 조회해보도록 하자.

>>> 시험점수.set_index("학년", inplace=True)
>>> 시험점수.loc[1]

2.5. 다중 값을 Index로 조회해보자.

지금까지 하나의 열만 Index로 넣어 조회를 해보았다.
그렇다면, 여러 개의 열을 Index에 넣어 내가 원하는 행만 조회할 수는 없을까?
이때는 크게 2가지 방법이 있다.

Multi Index를 만들어 조회하기
조회를 위한 열을 만들기

먼저 Multi index를 만드는 법부터 알아보도록 하자.
Index를 다시 초기화하고 학년과 반으로 Multi index를 만들어보도록 하겠다.

>>> 시험점수.reset_index(drop=False, inplace=True)
>>> 시험점수.set_index(["학년", "반"], inplace=True)
>>> 시험점수

2학년 1반 사람들을 조회해보도록 하자.
Multi Index는 Python의 Tuple로 생성되므로, Tuple로 조회하면 된다.

>>> 시험점수.loc[(2,1)]

3개 이상의 열을 Multi Index로 만들어 조회도 가능하다.
이번에는 학년, 반, 이름으로 Multi Index를 만들어보자.

>>> 시험점수.reset_index(drop=False, inplace=True)
>>> 시험점수.set_index(["학년", "반", "이름"], inplace=True)
>>> 시험점수

이번에는 2학년 1반의 영철을 조회해보도록 하자.

>>> 시험점수.loc[(2,1,"영철")]
성별     남자
국어    100
수학     80
영어     75
사회     80
과학     45
Name: (2, 1, 영철), dtype: object

위와 같은 방법을 통해 내가 원하는 Column을 Index로 만들어 조회해보았다.
다만, 해당 방법의 한계점은 특정한 하나의 값만 조회가 가능하므로, 수학 점수와 같은 연속형 데이터의 범위에 대해서는 조회가 불가능하다는 단점이 있다.
물론, 이용해 우회하여 해결할 수 있기는 하다.

2.6. 새로운 열을 만들어 조회하기

지금까지는 기존에 존재하는 열을 그대로 Index로 만들어 조회를 하였다.
이번에는 내가 필요로 하는 값에 대한 변수를 만들고, 이 변수를 Index로 만들어 조회를 해보도록 하겠다.
수학 점수가 70점 이상인 사람들을 표시하는 새로운 변수를 만들어보자.
- 조건을 이용한 새로운 변수 만들기는 추후 자세히 다룰 테니 이번엔 단순 참고용으로 보도록 하자.

>>> 시험점수["수학_mask"] = np.where(시험점수["수학"] >=70, "수학_70점_이상", "수학_70점_미만")
>>> 시험점수

70점 이상은 "70점_이상", 70점 미만은 "70점_미만"인 수학_mask"라는 변수를 생성하였다.
새로 만든 "수학_mask"변수를 이용해서 70점 이상인 사람들만 출력해보도록 하자.

>>> 시험점수.set_index("수학_mask", inplace=True)
>>> 시험점수.loc["수학_70점_이상"]

이미지가 너무 커서 일부만 표시해보았다. 길이가 48인 결과가 나왔다면, 제대로 나온 것이다.

>>> len(시험점수.loc["수학_70점_이상"])
48

이번엔 영어 점수가 70점 이상인 사람을 추가해보자.

>>> 시험점수.reset_index(drop=False, inplace=True)
>>> 시험점수["영어_mask"] = np.where(시험점수["영어"] >=70, "영어_70점_이상", "영어_70점_미만")
>>> 시험점수

이번엔 수학 점수가 70점 이상이면서, 영어 점수도 70점 이상인 사람을 출력해보자.
Multi Indexing을 사용할 수도 있으나, 이번에는 수학_mask와 영어_mask를 하나로 합쳐서 Index를 만들어보겠다.

>>> 시험점수["key"] = 시험점수["수학_mask"] + "&"+ 시험점수["영어_mask"]
>>> 시험점수.set_index("key", inplace=True)
>>> 시험점수.loc["수학_70점_이상&영어_70점_이상"]

이미지가 너무 커서 일부만 표현하였으며, 길이가 35가 나오면 정상이다.

>>> len(시험점수.loc["수학_70점_이상&영어_70점_이상"])
35

위와 같은 새로운 변수를 만들어 Index로 바꾸는 방법은 이해를 돕기 위해 변수를 지저분하게 만들었지만, 이보다 깔끔하게 할 수 있는 방법을 다음에 포스팅해보도록 하겠다.

지금까지 Index를 이용한 데이터 프레임 행 조회 방법에 대해 알아보았다. 다음 포스트에서는 위치를 이용한 행 조회에 대해 알아보도록 하겠다.

Python 리눅스 서버에 분석 환경 구축5 - CUDA 세팅(2)

만년필잉크 — Mon, 17 May 2021 20:03:10 +0900

리눅스 서버에 CUDA 세팅하기

이전 포스트에서 CUDA 세팅에 필요한 CUDA와 cuDNN을 다운로드하였다. 이번 포스트에서는 CUDA를 설치해보도록 하겠다.

0. 다른 버전의 CUDA가 설치되어 있는지 확인하기

현재 CUDA를 세팅하는 환경은 wsl2를 이용하여 만들어진 가상 환경이기 때문에 엔비디아 드라이버가 설치되어 CUDA가 꼬일 문제가 없지만, 윈도우 PC나 사용하려는 텐서플로우 버전과 기존 서버에 세팅된 CUDA 버전이 다른 경우, 기존 NVIDIA 파일과 CUDA를 제거해줘야 한다.
현재 환경에 엔비디아 드라이버가 설치되어 있다면, 다음과 같은 방법으로 그래픽 드라이버 정보를 얻을 수 있다.

nvidia-smi
nvcc -V

CUDA가 설치되어 있다면, nvcc -V를 확인하면 된다.
경우에 따라 nvcc -V에서 출력되는 쿠다와 nvidia-smi에서 출력되는 CUDA Version이 다른 경우가 있는데, 이는 CUDA가 꼬여 있는 것일 수 있기 때문에 이후에 Tensorflow 사용 시, 충돌이 일어날 수 있다. 때문에 CUDA 파일과 nvidia 관련 파일을 완전히 제거하여, CUDA를 맞춰주는 것이 좋다.
nvidia-smi 입력 시 출력되는 화면은 다음과 같다.

nvcc -V 입력 시 출력되는 화면은 다음과 같다.

엔비디아 드라이버와 쿠다를 제거하는 방법은 다음과 같다.

# nvidia driver 삭제
sudo apt-get remove --purge '^nvidia-.*'

# CUDA 삭제
sudo apt-get --purge remove 'cuda*'
sudo apt-get autoremove --purge 'cuda*'

# CUDA 남은 파일 삭제
sudo rm -rf /usr/local/cuda
sudo rm -rf /usr/local/cuda-10.1

엔비디아 드라이버와 쿠다 제거 후, 성공적으로 제거되었는지 확인하기 위해, nvidia-smi, nvcc -V와 같은 코드를 입력하여, 제대로 제거되었는지 확인하자.
그러나, CUDA가 여러 개 깔려 있거나, 여러 개의 GPU 서버의 GPU가 연결 되어 있는 경우, 위 방법대로 제거하더라도, nvidia-smi나 nvcc -V가 다시 출력될 수 있다.

1. CUDA 설치하기

이전 포스트에서 다운로드하였던 CUDA 파일을 실행하기 전에 권한을 부여하도록 하자.
이전 포스트까지 Download 디렉터리에 받았던 파일들은 다음과 같다.

위 사진에서 cuda_11.0.2_450.51.05_linux.run에 chmod를 사용하여, 777 권한을 부여하자.

chmod 777 cuda_11.0.2_450.51.05_linux.run
ll

이제 cuda_11.0.2_450.51.05_linux.run을 실행하여 CUDA를 설치하도록 하자.

./cuda_11.0.2_450.51.05_linux.run

gcc 에러 발생

CUDA 설치 시, 다음과 같은 에러가 뜰 수도 있다.
Failed to verify gcc version. See log at /tmp/cuda-installer.log for details.
관련 로그를 확인하기 위해 위 에러가 말해준 위치로 이동해보자.

위 내용을 보니, gcc 가 없어서 발생한 문제임을 알 수 있다.
gcc를 설치하여, 위 문제를 해결해줘야 한다.
위 문제가 뜬 경우 apt를 비롯한 가장 기본적인 세팅도 안되어 있는 것이므로, 가능한 위와 같은 상황에선 인터넷을 열어달라 하여, 위와 같은 기본적인 세팅은 해놓는 것을 추천한다.
위 문제의 해결 방안은 다음과 같다.

sudo apt update
sudo apt install build-essential
sudo apt-get install manpages-dev

위 코드는 sudo 권한이 반드시 필요하기 때문에 지금까지와 달리 꼭 sudo를 입력해주도록 하자.
기본적으로 gcc는 7.5.0으로 설치되므로, 버전도 업그레이드하도록 하자.

sudo apt -y install gcc-8 g++-8
sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-8 8
sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-8 8

CUDA 설치 재진행

다시 CUDA 설치를 진행하도록 하겠다.

./cuda_11.0.2_450.51.05_linux.run

accept를 입력하여 진행하자

위/아래 방향키로 이동, 왼쪽/오른쪽 방향키로 +가 있는 영역 세부 표시, 엔터 입력 시 X 체크 또는 해제를 실시할 수 있다.
지금 같이 CUDA, cuDNN 관련 사항이 완전히 없는 경우, 모두 체크하여 설치를 진행하도록 하자.
Install을 눌러, 계속 진행해보자.

컴파일러 에러 발생

이번에는 컴파일러 버전이 맞지 않아, 컴파일러 에러가 발생하였다.

sudo apt-get install build-essential

경로 문제

위 명령어를 입력하여, 해당 오류 관련 패키지를 설치해주자.
이번에는 다음과 같은 에러가 등장하였다.

특정 디렉터리가 존재하지 않아 발생하는 에러로 보인다.
sudo 권한을 주어 설치하도록 하자.

sudo ./cuda_11.0.2_450.51.05_linux.run

성공적으로 CUDA를 설치하였다.
Toolkit과 Cuda Samples가 설치된 위치를 볼 수 있으며, 이제 cuda를 사용하기 위해 PATH 설정을 하도록 하자.

CUDA PATH 설정

CUDA를 사용하기 위해선 전역 변수를 수정해줘야 한다.
만약 우분투 사용자마다 다른 CUDA를 사용하고자 하는 경우, 사용자의 home 디렉터리의 .bachrc를 수정하면 된다.

cd
sudo vim /etc/bash.bashrc

cd를 입력하여 최초 경로로 돌아가자.
위 명령어를 입력하여 출력된 화면의 맨 마지막에 위 CUDA 설치 후, 출력된 CUDA PATH를 다음과 같이 설정해주도록 하자.

export PATH=/usr/local/cuda-11.0/bin:$PATH
export LD_LIBRARY_PATH=/usr/local/cuda-11.0/lib64:$LD_LIBRARY_PATH
export LD_LIBRARY_PATH=/usr/local/cuda-11.0/extras/CUPTI/lib64:$LD_LIBRARY_PATH

위 입력된 사항을 esc > :wq 를 입력하여 저장하도록 하자.
PATH 지정 후, 위 사항을 터미널에 바로 적용해주도록 하자.

source /etc/bash.bashrc

nvcc -V를 입력하여 CUDA가 성공적으로 설치된 것을 확인하도록 하자.

nvcc -V

성공적으로 CUDA가 설정된 것을 볼 수 있다.

2. cuDNN 설치

cuDNN 설치는 cuDNN 폴더의 압축해제 후, 그 안에 있는 파일들을 이전에 설치하였던 CUDA 파일의 안에 복사해서 옮겨줘야 한다.
그러므로, 이전에 cuda를 설치하였던 경로를 먼저 보도록 하자.

whereis cuda

Download 디렉터리로 돌아가 이전에 다운로드하였던 cuDNN 파일의 압축을 풀도록 하자.

cd Download
ll
tar -xvf cudnn-11.0-linux-x64-v8.0.5.39.tgz

압축 해제 후, 생성된 파일을 확인해보자

ll
cd cuda
ll

cuda 디렉터리 안에 있는 include, lib64 폴더의 하위 파일들을 이전에 설치하였던 cuda의 include와 lib64 폴더로 복사하면 된다.
이전에 확인했던 cuda의 경로로 include의 하위 파일들 lib64 하위 파일들을 각각 해당하는 디렉터리로 이동시키자

sudo cp include/cudnn* /usr/local/cuda-11.0/include
sudo cp lib64/libcudnn* /usr/local/cuda-11.0/lib64/
sudo chmod a+r /usr/local/cuda-11.0/lib64/libcudnn*

cuDNN 설치가 제대로 되었는지 확인해보자

cat /usr/local/cuda-11.0/include/cudnn_version.h | grep CUDNN_MAJOR -A 2

위 내용을 보면 cudnn 8.0.5가 성공적으로 설치된 것을 볼 수 있다.

Python 리눅스 서버에 분석 환경 구축4 - CUDA 세팅(1)

만년필잉크 — Mon, 17 May 2021 16:43:04 +0900

리눅스 서버에 CUDA 세팅하기

이전 포스팅에서 우분투 서버에 주피터 노트북을 세팅하는 방법에 대해 알아보았다. 이번 포스트에서는 우분투 서버에 CUDA를 세팅하고, Tensorflow를 이용해 CUDA 세팅이 제대로 되었는지 확인하는 방법에 대해 알아보도록 하겠다.

1. Tensorflow가 GPU를 정상적으로 인식하고 있는지 확인

Tensorflow를 설치하였더라도, GPU를 사용하기 위해서는 사용하고자 하는 Tensorflow 버전에 맞는 CUDA와 Cudnn을 설치해야 한다.
Tensorflow가 현재 인지하고 있는 사용 가능한 CPU, GPU를 확인하는 방법은 다음과 같다.

from tensorflow.python.client import device_lib
device_lib.list_local_devices()

위 사진을 보면, JSON 형태로 CPU와 GPU가 출력된다. 만약 CPU와 GPU가 1개 이상인 경우 "/device:CPU:0", "/device:CPU:1", "/device:CPU:2",..., "/device:GPU:0", "/device:GPU:1", "/device:GPU:2", ...와 같은 식으로 N개의 해당하는 device와 기종 설명 등 간략한 정보가 출력되게 된다.
해당 번호를 기반으로 Tensorflow 사용 시, 원하는 장비를 선택할 수 있다.

2. 필요한 CUDA와 cuDNN 버전 확인하기

CUDA와 cuDNN을 설치하기 전에 자신이 사용하려고 하는 Tensorflow 버전을 구체적으로 알아야한다.
프로그래밍에 익숙하지 않은 사람이라면, 최신 라이브러리일수록 좋은 것이라고 단순하게 생각할 수 있는데, 최신 버전은 알려지지 않은 오류가 존재할 가능성이 높은 안정되지 않은 상태일 수 있기 때문에, 이러한 이슈를 알아보고 설치하는 것을 추천한다.
이번 포스트에서는 tensorflow-2.4.0을 사용할 것이므로, 그에 해당하는 CUDA와 cuDNN을 설치하도록 하겠다.
Tensorflow 버전별 CUDA와 cuDNN 정보는 Tensorflow 공식 홈페이지를 보면 알 수 있다.
https://www.tensorflow.org/install/source

소스에서 빌드 | TensorFlow

소스에서 TensorFlow pip 패키지를 빌드하고 Ubuntu Linux 및 macOS에 설치합니다. 명령어는 다른 시스템에도 적용될 수 있지만, Ubuntu 및 macOS용으로만 테스트되었으며 지원됩니다. 참고: 잘 테스트되고

www.tensorflow.org

해당 사이트를 보면, tensorflow-2.4.0에 해당하는 GPU는 cuDNN 8.0, CUDA 11.0임을 알 수 있다.

3. CUDA 다운로드하기

CUDA와 cuDNN 다운 및 설치 방법은 이전 포스트 "텐서플로우(Tensorflow)와 tensorflow-gpu 설치방법"과 매우 유사하며, 이번에는 리눅스 버전으로 다운을 받아보도록 하자.
자신이 원하는 버전에 해당하는 CUDA를 다운로드하기 위해선 아래 홈페이지로 이동하면 된다.
https://developer.nvidia.com/cuda-toolkit-archive

CUDA Toolkit Archive

Previous releases of the CUDA Toolkit, GPU Computing SDK, documentation and developer drivers can be found using the links below. Please select the release you want from the list below, and be sure to check www.nvidia.com/drivers for more recent production

developer.nvidia.com

해당 웹사이트에서 CUDA Toolkit 11.0을 클릭하도록 하자.

이번에 Tensorflow를 세팅하고자 하는 서버는 오프라인 우분투 18.04이므로, 다음과 같은 버튼을 클릭하여 설치 파일을 받도록 하자.

위와 같이 누르는 경우, 우리에게 익숙한 파일 다운로드 버튼이 아닌 리눅스 환경에서 파일을 다운로드할 수 있는 명령어가 출력된다.

위 명령어에서 첫 줄인 "wget ~"은 CUDA 설치 파일을 다운로드하는 것이며, 두 번째 줄은 해당 파일을 실행하는 것이다.
인터넷이 되는 우분투 환경으로 이동하여, 이전에 만들어놨던 Download 디렉터리로 이동해서 해당 파일을 다운로드하도록 하자.

wget http://developer.download.nvidia.com/compute/cuda/11.0.2/local_installers/cuda_11.0.2_450.51.05_linux.run

다운 완료 후, 파일이 Download 디렉터리에 설치 파일이 존재하는 것을 확인하도록 하자.

ll

성공적으로 CUDA 11.0 설치 파일이 다운된 것을 볼 수 있다.

4. cuDNN 다운로드하기

cuDNN은 다음 홈페이지에서 받을 수 있다.
https://developer.nvidia.com/rdp/cudnn-archive

cuDNN Archive

NVIDIA cuDNN is a GPU-accelerated library of primitives for deep neural networks.

developer.nvidia.com

cuDNN을 보면, CUDA 버전에 맞는 것이 무엇인지 볼 수 있다.
cuDNN은 CUDA Deep Neural Network의 약자로, 딥러닝 관련 연산을 빠르게 해주는 라이브러리들이 모여있는 패치 파일이라고 생각하면 된다.
cuDNN 파일은 windows와 마찬가지로 CUDA 설치 후, 압축을 푼 cuDNN 파일을 설치된 CUDA 파일에 덮어 씌워주면 된다.
설치하고자 하는 운영체제에 맞는 cuDNN을 다운로드하도록 하자. 우분투는 단순하게 Linux로 다운로드하여도 상관없다.
cuDNN은 CUDA와 달리 NVIDIA 홈페이지 로그인이 필요하므로, 해당 작업 진행 후, cuDNN을 받도록 하자.

로그인 후, 해당 버튼을 누르면 "cudnn-11.0-linux-x64-v8.0.5.39.tar" 또는 뒤에 ".solitairetheme8" 라고 붙은 파일이 다운로드하여진다. 이 경우 윈도우 다운로드 파일에 받아지기 때문에 리눅스로 이동시키는 과정이 필요하다.
CUDA를 설치하고자 하는 리눅스 서버와 로컬 PC가 FTP가 뚫려 있는 경우 파일질라(FILEZILLA)와 같은 무료 FTP 클라이언트를 이용하는 것이 가장 직관적인 방법이며, USB를 이용하여 파일을 이동시킬 수도 있다.
해당 포스트는 wsl2를 이용하여 해당 과정을 진행하므로, c드라이브에 "Linux_mv"라는 이름의 임의의 디렉터리를 생성하고, cuDNN 파일을 이동시켰다.

cd /mnt/c/Linux_mv
mv cudnn-11.0-linux-x64-v8.0.5.39.tgz /home/gooopy123/Download
cd
cd Download
ll

이제 CUDA 설치를 위한 기본적인 준비가 되었다. 다음 포스트에서는 CUDA 설치를 진행해보도록 하겠다.

Python 리눅스 서버에 분석 환경 구축3 - 가상환경 활성화와 주피터 노트북

만년필잉크 — Tue, 6 Apr 2021 21:44:52 +0900

리눅스 서버에 가상 환경 활성화와 주피터 노트북 세팅

지금까지 파이썬 기반 오프라인 분석 서버 구축을 위한 밑 작업을 해보았다. 이번 포스트에서는 오프라인 우분투 환경에 에 이전에 만들었던 가상 환경을 활성화시키고, 주피터 노트북을 세팅해보도록 하겠다.

0. 오프라인 우분투 환경 준비

해당 포스트는 분석 환경 구축의 대상이 되는 서버가 오프라인, OS가 우분투이며, 우분투는 이미 설치되어 있다는 전제하에 진행하도록 하겠다.
이를 실습하고 싶으나, 오프라인 우분투 서버가 존재하지 않다면, 가상 머신을 이용해 이와 유사한 환경을 만들어보겠다.
가상 머신은 wsl2를 사용하며, 우분투 버전은 18.04이다.
wsl2 사용 방법은 이전 포스트인 "Python 리눅스 서버에 분석 환경 구축1 - 가상머신과 아나콘다 설치"를 참고하도록 하겠다.
지금까지의 포스팅을 따라온 사람이라면, 기존에 설치하였던 우분투를 제거하고, 재설치하여 아나콘다가 깔려있지 않은 환경을 만들어주자.
아래와 같이 아무것도 설치되지 않은 상태에서 진행하도록 하겠다.

1. 아나콘다 설치 및 가상 환경 활성화 준비

이전 포스트에서 외부로 옮겨놓았던, 리눅스 아나콘다 설치 파일과 가상 환경 압축 파일을 리눅스 서버로 옮기자.
옮기는 방법은 USB를 이용하거나, 파일질라(FileZilla) 등을 이용해서 이동시키도록 하자.
이동시키는 가장 쉬운 방법은, Local PC와 리눅스 서버가 sftp 포트(22)가 뚫려 있다는 상태에서, 파일질라를 사용하는 것이다.
해당 포스트는 위 과정이 해결되어 있다는 전제하에 진행하도록 하겠다.
추후 필요에 따라 위 과정을 다뤄보도록 하겠다.

# Download 디렉토리 생성
mkdir Download

Donwload 디렉토리를 만들고, 이전에 준비한 파일들을 모두 이동시키자.
이번 포스트는 wsl2 환경에서 진행하므로, 상황이 약간씩 다르지만, 전체적인 흐름은 동일하다.

# wsl2 환경에서 가상 환경 압축 파일과 아나콘다 설치 파일 이동
cd /mnt/c/Anal_Env_Set
mv ./Anaconda3-2020.11-Linux-x86_64.sh /home/gooopy123/Download
mv ./New_Env.tar /home/gooopy123/Download

# Download 디렉토리에 파일이 정상적으로 이동되었는지 확인
cd
cd Download
ll

1.1. 아나콘다 설치

아나콘다 설치 과정은 이전 포스트 "Python 리눅스 서버에 분석 환경 구축1 - 가상머신과 아나콘다 설치"를 참고하기 바란다.
이전 포스트와 달리 아나콘다 설치 파일을 이미 넣어놓은 상태이므로, 바로 설치를 진행하자.

1.2. 가상 환경 이동 및 압축 풀기

아나콘다가 설치 완료되었다는 전제하에, 이전 포스트에서 만들었던 가상 환경 압축 파일을 아나콘다 디렉토리로 이동시켜보자.

# 가상 환경 압축파일 이동
mv New_Env.tar /home/gooopy123/anaconda3/envs
cd /home/gooopy123/anaconda3/envs
ll

이동된 New_Env.tar 파일의 압축을 풀어보도록 하자.

# 가상 환경 압축 파일 압축 해제
tar -xvf New_Env.tar

tar -xvf 압축파일.tar: "압축파일.tar"의 압축을 푼다.
가상 환경 압축을 해제 후, 해당 압축 파일을 인식하는지 확인해보자.

# 가상 환경 목록 확인
conda env list

위와 같이 성공적으로 이전에 만들었던 가상 환경이 생성된 것을 확인할 수 있다.
가상 환경의 압축파일은 용량만 차지하므로, 이제 삭제하도록 하자.

# 가상 환경 압축 파일 제거
rm New_Env.tar

2. 주피터 노트북 설정

가상 환경을 활성화하기 전에 반드시 해줘야 하는 것이 Base 환경에서 주피터 노트북을 설치하고, 설정하는 것이다.
주피터 노트북 설치는 반드시 Base 환경에서 해주어야 한다.
Base 환경에서 주피터 노트북 설치는 pip install 사용 시, 오프라인에서도 진행 가능하다.

# 주피터 노트북 설치
pip install jupyter notebook

# 주피터 노트북 설정 파일 생성
jupyter-notebook --generate-config

주피터 노트북 설치 후, 주피터 노트북 설정 파일을 생성하도록 하자.

위 과정 진행 시, 위와 같이 .jupyter/ 디렉토리가 생성된 것을 확인할 수 있다.

2.1. 주피터 노트북 비밀번호 생성

주피터 노트북 설정을 손대기 전에 주피터 노트북에서 사용할, 암호화된 비밀번호를 생성하기 위해 ipython을 실행하자.

# ipython 실행
ipython

주피터 노트북 설치 시, ipython이 같이 설치되는데, ipython은 주피터 노트북의 셀과 동일한 기능을 수행한다.

# 암호화된 비밀 번호 생성
from notebook.auth import security
security.passwd()

위와 같이 비밀 번호를 생성하면, 암호화된 비밀번호를 출력하는데, 이를 반드시 어딘가에 복사해놓도록 하자.

# ipython 빠져나오기
exit()

exit()를 입력하여 ipython에서 터미널로 빠져나오자.

2.2. 주피터 노트북 워킹 디렉토리 생성

주피터 노트북을 설정하기 앞서, 주피터 노트북의 워킹 디렉토리를 미리 만들어놓자.

mkdir Analysis
cd Analysis

# 현 주소 확인
pwd

주피터 노트북의 워킹 디렉토리로 사용할 디렉토리의 주소도 복사해놓도록 하자.

2.3. 주피터 노트북 설정

아까 생성하였던, 주피터 노트북 설정 파일이 있는 경로로 이동하고, 설정 파일을 실행해보자.

# 경로 이동
cd ~/.jupyter

# 주피터 노트북 설정 파일 실행
vi jupyter_notebook_config.py

위 코드 실행 시, 위와 같은 파란색 글로 가득 찬 화면이 뜨게 된다.
여기서 특정 명령어를 입력하면, 주피터 노트북에 해당 기능이 반영된다.
설정할 수 있는 유용한 몇 가지 기능을 소개하면 다음과 같다.

# 필수
c = get_config()
c.JupyterApp.config_file_name = 'jupyter_notebook_config.py'

# 접속 허용 ip
c.NotebookApp.allow_origin = '*' # 접속 허용 ip로 *는 전체 허용을 의미한다.

# 서버 ip
c.NotebookApp.ip = 'xxx.xx.xxx.xxx'

# 주피터 노트북 실행 시, 브라우저로 열지(True), url을 출력할지 정한다(False).
c.NotebookApp.open_browser = False

# 주피터 노트북 비밀번호
c.NotebookApp.password = u'아까 복사해놓은 암호화된 비밀번호를 넣어주자'

# 주피터 노트북 포트 설정
c.NotebookApp.port = 8888

# 주피터 노트북 홈 디렉토리 설정
c.NotebookApp.notebook_dir = '아까 복사해놓은 홈 디렉토리 주소를 넣어주자'

위 코드 중 필요한 부분을 선택하여, 넣어주도록 하자.
위 코드를 보기 쉽도록 위 파란 화면 최상단에 넣어주도록 하자.
위 상태에서 i를 누르면 INSERT 모드로 바뀌며, 수정 가능해진다.

필요한 코드를 전부 입력한 후, esc를 누르고, shift + ; 키를 누르면, 위 화면에서 빠져나올 수 있는 키를 입력할 수 있게 된다.
q를 입력 후 enter를 치면 현 상태를 저장하지 않고 그냥 빠져나오며, wq를 입력 후 enter를 치면 현 상태를 저장하고 빠져나온다.

2.4. 주피터 노트북 실행

위 과정까지 마친 후, 터미널에 jupyter notebook을 입력하면, jupyter notebook으로 이동할 수 있는 url이 나온다.
위 방법을 통해, 특정 url과 port를 설정하면, 해당 주소를 즐겨찾기 설정하여, 쉽게 이동할 수 있다.

# 주피터 노트북 실행
jupyter notebook

해당 포스트는 서버가 아닌, Local PC에 분석 환경을 구축하였기 때문에, IP주소를 따로 입력하지 않아도 괜찮다.
(위 화면이 뜨지 않는다면, 무언가 오타를 내지 않았는지 꼭 확인해보자)
출력된 위 http:localhost:8892/를 복사하여, 크롬에 붙여 넣어 보자.
그러면, 우리에게 익숙한 주피터 노트북 화면이 출력된다.

아까 만들었던 비밀 번호를 입력하고 이동해보자

이제 우리에게 익숙한 주피터 노트북을 우분투 환경에서 사용할 수 있다.

3. 가상 환경 주피터 노트북에 연결하기

아까 실행했던 주피터 노트북을 종료해보자
주피터 노트북 종료는 브라우저의 우측 상단에서 Quit를 클릭하거나, 터미널에서 ctrl+z를 입력하여 중지시키면 된다.
ctrl+z는 리눅스에서 특정 기능이 수행 중일 때, 사용하면 그 기능을 중지시킬 수 있다.
윈도우에서는 가상 환경 생성 시, 해당하는 주피터 노트북 실행 파일과 커널이 따로 생성되므로, 실행하기 쉬웠으나, 우분투에서는 가상 환경 커널을 추가하여 가상 환경을 사용한다.
먼저 사용할 가상 머신을 활성화 하자.

# 가상 환경 활성화
conda activate New_Env

# 가상 환경 커널 추가
python -m ipykernel install --user --name=New_Env --display-name="New_E_Kernel"

# base로 환경 변경
conda activate base

# 주피터 노트북 실행
jupyter notebook

--user --name 뒤에는 연결하고자 하는 가상 환경의 이름을 넣으면 된다.
--display-name 뒤에는 주피터 노트북에서 출력하고 싶은 커널 이름을 넣어주면 된다.

다시 주피터 노트북을 실행하고, 방금 만들었던 New_E_Kernel 커널로 파이썬 쉘을 만들어보자.

주피터 노트북을 실행하여 New를 클릭해보면 New_E_Kernel라는 추가한 커널이 생긴 것을 볼 수 있다.
파이썬 파일을 만들어보자.

Kernel의 Change kernel에 New_E_Kernel이 추가된 것도 볼 수 있다.
이를 이용해서 커널도 얼마든지 바꿀 수 있다.
적용되어 있는 커널은 우측 상단에서 확인할 수 있다.

커널 변경 시, 아나콘다에서 기본적으로 제공하지 않는 패키지인 tensorflow가 성공적으로 가동되는 것을 볼 수 있다.

3.1. 가상 환경 커널 제거

추가로 생성된 가상 환경 커널을 삭제하고 싶다면 다음과 같이 하면 된다.

# 적용되어 있는 가상환경 커널 목록을 확인한다.
jupyter kernelspec list

# 적용되어 있는 가상환경 커널의 적용을 해제한다.
jupyter kernelspec uninstall 가상환경이름

# 가상환경 삭제
conda env remove -n 가상환경이름

가상 환경 커널 추가 시, 표시되는 커널의 이름과 가상 환경의 이름이 일치하지 않을 수 있으므로, kernelspec list를 확인하는 것이 좋다
커널을 제거하지 않더라도 가상 환경은 삭제 가능하다.

지금까지 우분투 환경에서 주피터 노트북을 사용하는 방법에 대해 알아보았다. 지금 상태에서도 데이터 분석을 진행할 수는 있으나, 현재 GPU 설정을 하지는 않은 상태기 때문에, CPU만 사용해서 분석을 진행할 수 있다.

다음 포스트에서는 우분투 환경에 CUDA를 세팅하는 방법에 대해 알아보도록 하자.

Python 리눅스 서버에 분석 환경 구축2 - 가상환경 만들고 내보내기

만년필잉크 — Mon, 5 Apr 2021 17:03:56 +0900

리눅스 서버에 가상 환경 만들기

이전 포스트에서 가상 머신을 통해 리눅스 서버를 만들고, 아나콘다를 설치해보았다. 이번 포스트에서는 아나콘다를 이용해 가상 환경을 만들고, 이를 압축하여, 외부로 내보내는 과정을 학습해보도록 하겠다.

1. 아나콘다 가상환경

지난 포스트까지 진행했다면, 아래와 같은 경로에 위치해 있을 것이다.
(지난 포스트와 PC의 이름이 다른 이유는, 다른 PC로 동일한 환경을 구축해서 진행한 것이기 때문으로, 신경 쓰지 않아도 된다)

1.1. 가상 환경을 생성해보자.

conda create -n New_Env python=3.8

conda create -n 가상 환경_이름 python=원하는_파이썬_버전: "원하는_파이썬_버전"으로 새로운 가상 환경을 만든다. 생성되는 가상환경 이름은 "가상환경_이름"이다.
가상 환경 생성은 온라인 환경에서만 가능하므로, 반드시 인터넷이 가능한 PC에서 실시하도록 하자.

1.2. 존재하는 가상 환경 리스트를 확인해보고, 방금 생성한 가상환경을 활성화시켜보자.

conda env list
conda activate New_Env

conda env list: 아나콘다에 존재하는 가상환경 리스트를 출력한다.
conda activate 가상환경이름: "가상환경이름"을 활성화한다.

1.3. 필요한 패키지를 설치한다.

"pip install 패키지==버전"이나 "conda install 패키지==버전"을 입력하여, 필요한 패키지를 설치하자.
(가상 환경에 설치하므로, 둘 중 아무거나 사용해도 된다.)
tensorflow 2.4.0 버전, tensorflow-gpu 2.4.0 버전, pytorch 1.8.1 버전, simplejson을 설치해보자.

pip install tensorflow==2.4.0
pip install tensorflow-gpu==2.4.0
pip install torch==1.8.1
pip install simplejson
pip install jupyter notebook

텐서플로우나 파이토치는 cuda, cudnn 버전이 맞아야 하기 때문에 자신이 사용할 텐서플로우 버전을 확실히 해야 한다.
밖으로 내보낼 가상환경에는 반드시 jupyter notebook을 설치해주자. 주피터 노트북을 다운받으면, ipython, ipykernel과 같은 주피터 노트북 사용에 관련된 주요 라이브러리가 자동으로 다운 받아진다.

1.4. 설치한 패키지가 정상적으로 설치되었는지, 패키지 리스트를 확인해보자.

conda list

위에서 출력된 결과를 보면, 방금 설치하였던 패키지들이 모두 정상적으로 설치된 것을 볼 수 있다.
혹시 필요한 패키지가 더 있다면, 위 과정을 추가로 진행하기 바란다.

2. 가상 환경 밖으로 내보내기

"conda env export > 가상환경이름.yaml"을 사용하면, 가상 환경의 형태를 내보낼 수 있으나, 이는 구조만 내보내는 것이기 때문에, 인터넷이 안 되는 서버에서는 사용할 수가 없다.
그러나, 생성한 가상 환경을 그대로 압축하여, 외부로 내보내면 오프라인 환경에서도 가상환경을 그대로 사용할 수 있다.

2.1. 생성한 가상환경 압축하기

생성된 가상 환경은 설치한 anaconda3 디렉터리의 envs 디렉터리에 위치해 있다.

cd ./anaconda3/envs/
ll

방금 생성하였던 New_Env를 압축해보자.

tar -cvf New_Env.tar New_Env

tar -cvf 압축후_폴더명.tar 압축할_폴더명: "압축할_폴더명" 디렉토리를 "압축후_폴더명.tar"로 압축한다.
압축된 경로를 확인해보자.

2.2. 압축된 가상환경 내보내기

압축된 가상 환경을 윈도우 환경의 c드라이브로 내보내자.
c드라이브에 Anal_Env_Set 디렉토리를 미리 생성하고, 이 곳으로 압축 파일을 이동시키자.
wsl2에서 c드라이브, d드라이브와 같은 윈도우 디렉토리로 이동하려면 /mnt 경로로 이동하면 된다.

mv New_Env.tar /mnt/c/Anal_Env_Set

확인해보니, 압축했던 파일이 사라진 것을 볼 수 있다.
파일을 이동시키기로 한 위치로 가서 파일이 이동한 것을 확인해보자.

cd /mnt/c/Anal_Env_Set
ll

이동시키려는 디렉토리로 압축 파일이 이동한 것을 볼 수 있다.

2.3. 아나콘다 설치 파일도 밖으로 이동시키자.

분석 서버는 가상 머신의 환경과 동일하므로, 이전 포스트에서 설치하였던, 아나콘다 설치 파일도 밖으로 내보내도록 하자.

cd
cd Download
ll

mv Anaconda3-2020.11-Linux-x86_64.sh /mnt/c/Anal_Env_Set

2.4. 이동된 파일들을 확인해보자.

윈도우에서 이동시킨 파일들이 이동된 것을 확인해보자.

지금까지 아나콘다를 이용하여, 가상 환경을 만들고 필요한 패키지들을 설치해보았다. 만약, 다른 라이브러리가 더 필요하다면, 필요한 라이브러리를 더 추가하여 다시 내보내면 된다.

다음 포스트에서는 새로운 오프라인 서버 환경을 대상으로 분석 환경 구축을 실시해보자.

Python 리눅스 서버에 분석 환경 구축1 - 가상머신과 아나콘다 설치

만년필잉크 — Sat, 3 Apr 2021 22:45:13 +0900

리눅스 서버에 분석 환경 구축

분석을 하기 위해선 분석을 할 수 있는 환경을 만드는 것이 가장 중요하다. 아무리 수많은 분석 기법들을 알고 있더라도, 스스로 분석 환경을 구축하지 못한다면 아무것도 진행할 수 없기 때문이다.

이전 포스트까지는 일반적으로 사용자가 사용하는 컴퓨터(Local)에 분석 환경을 구축하는 것에 대해 알아보았다. 그러나, 대용량 데이터를 다루는 현장에서는 Local PC로 데이터 분석을 진행하는 것엔 한계가 있기 때문에 분석용 서버에서 분석을 진행하게 된다.

그러나, 대부분의 서버는 보안을 위해 오프라인으로 구축되어 있으며, 우리에게 익숙한 OS인 Windows가 아닌 Ububtu, CentOS와 같은 Linux로 설치되어 있으며, 쓸모없는 자원 낭비를 막기 위해 CLI레벨로 구성되어 있어, 실행 시 그냥 검은 화면만 나온다(우리에게 익숙한 윈도우 화면은 GUI레벨이다).

일반적으로 서버의 환경 설정은 도커(Docker)를 이용하여 구축하지만, 단순히 파이썬(Python) 기반의 분석 환경을 구축하고자 한다면, 앞서 학습했던 아나콘다 가상 환경(Virtual Environment)만 사용해도 충분하다.

이번 포스트에서는 오프라인 우분투(Ubuntu) 서버에 딥러닝 분석 환경을 구축하는 과정을 학습해보도록 하겠다.

1. 준비물과 진행 과정

오프라인 서버 분석 환경 구축과 연습에는 인터넷이 되는 Local PC 하나만 있으면 충분하다. 분석 서버를 단순하게 설명해보면, "성능이 엄청나게 좋지만 인터넷이 안 되는 리눅스 OS가 설치된 컴퓨터"라고 할 수 있다.

앞으로 우리가 진행할 과정을 간단하게 요약해보면 다음과 같다.

인터넷이 되는 윈도우 컴퓨터에 분석 서버와 동일한 리눅스 배포 버전 가상 머신 설치
(이번 포스트에서는 Ubuntu 18.04를 대상으로 하겠다.)
가상 머신에 아나콘다를 설치
가상 환경 생성 후, 필요한 패키지 모두 설치 및 이를 압축하여 외부로 내보내기
사용하고자 하는 텐서플로우(파이토치) 버전에 맞는 Cuda, Cudnn 다운로드
압축된 가상환경, 아나콘다 설치 파일, Cuda, Cudnn을 인터넷이 안되는 리눅스 서버에 이동시키기
(가상 머신을 새로 만들고, 인터넷 선을 뽑은 후 진행하면, 오프라인 우분투 서버가 된다.)
이동된 파일 모두 설치

꽤 복잡해 보이지만, 익숙하지 않아서 그렇지, 앞서 다뤄봤던 윈도우 환경에서 분석 환경 설정하는 방법과 동일하다.

2. 가상 머신(우분투) 설치하기 - wsl2

가상 머신을 설치하는 방법을 두 가지 소개해보자면, 다음과 같다.

Virtual Machine 프로그램을 사용하여, 가상 머신 만들기
wsl2를 사용하여, 가상 머신 만들기

Virtual Machine 프로그램을 사용하면, 내 컴퓨터에 작은 컴퓨터를 만드는 것처럼 진행할 수 있지만, 과정이 꽤 복잡하고, 자원을 분리해서 사용하며, 가상 머신 종료 등의 과정이 꽤 번거롭기 때문에, 이번 포스트에서는 마이크로 소프트의 wsl2를 사용해서 가상 머신을 만들어보도록 하겠다.

2.1. wsl2(Windows Subsystem for Linux 2)

wsl2는 Linux용 Windows 하위 시스템의 약자로, Virtual Machine보다 쉽게 가상 머신을 만들 수 있다.
자원도 따로 나눌 필요가 없으며, 머신 종료 등의 번거로운 과정이 매우 간단한다.
윈도우에서 도커(Docker)나 리눅스 개발을 할 수 있다.

2.2. wsl2 설치 및 주의 사항

wsl2 설치는 마이크로 소프트 공식 홈페이지에서 아주 쉽게 설명해주고 있으므로, 기본적으로 해당 웹사이트를 참고하기 바란다.
wsl2는 다음과 같은 주의 사항을 반드시 따라야만 사용할 수 있다.

윈도우10 업데이트가 최신 버전일 것: 윈도우 업데이트 확인은 "시작 버튼의 설정 > 업데이트 및 보안"을 통해 확인할 수 있다. "업데이트 확인"을 해본 후, 윈도우 업데이트를 실시하고, 만약 wsl2가 정상적으로 설치되지 않는다면, 컴퓨터를 재부팅하여 업데이트를 마무리해주길 바란다.
CPU가 너무 구형이 아닐 것: Hyper-V를 구동시켜야만, wsl2와 같은 가상 머신을 사용할 수 있다. 2010년대 이전 CPU는 Hyper-V를 지원하지 않는 경우가 꽤 많으므로, 주의하길 바란다.
가상화 설정: "작업 관리자 > 성능"으로 들어가서 CPU의 가상화가 "사용"으로 되어 있는지 확인한다. 만약 사용이 안되어 있는 경우, BIOS에 들어가서 가상화를 설정해주어야 한다(메인보드 제조사마다 방식이 다르므로, 자신의 메인보드에 맞는 방법을 찾도록 하자).

설명에서 헷갈릴 수 있는 부분은 "PowerShell의 관리자 권한 실행"이라 생각되는데, 시작 옆의 검색 기능을 이용하면 쉽게 할 수 있다.

이번 학습에서 Linux는 Ubuntu 18.04를 사용할 것이지만, 자신이 다루고자 하는 서버의 리눅스 환경이 다른 경우, 자신에게 맞는 것을 설치하면 된다(명령어는 크게 다르지 않으며, 명령어가 다르더라도 과정은 동일하다)
윈도우 터미널(Windows Terminal)을 마이크로소프트 스토어(Microsoft store)에서 설치하면, 보다 쉽게 wsl2의 기능을 사용할 수 있지만, 이번 포스트에서는 서버 환경과 동일한 상황에서 보기 위해 설치한 Ubuntu에서 진행해보겠다.

2.3. wsl2 설치 완료 후, 우분투 구동

우분투 설치 후, 설치된 파일을 실행해주자
실행 후, ID와 Password는 자신이 원하는 것으로 아무거나 입력해주면 된다.
그 후, 아래와 같은 화면으로 이동해주자.

3. 아나콘다 설치하기

설치된 가상 환경에 어떤 파일이 있는지 확인해보자.

ll

ll: 현 디렉토리에 있는 파일들을 모두 보여주며, 해당 파일의 권한 등을 색으로 표현해준다.
(만약, 위와 같은 화면이 나오지 않는다면, cd를 입력하고 enter를 쳐서, 기본 디렉토리로 이동해주자)

3.1. Download 디렉토리 생성

Download 디렉토리를 생성하여, 앞으로 다운로드할 파일들이 저장될 공간을 분리해주자.
(필수는 아니지만 디렉토리 정리가 잘될수록 관리가 쉬워지므로, 가능하면 꼭 해주도록 하자.)

mkdir Download
ll

mkdir 디렉토리_이름: "디렉토리_이름"을 현 디렉토리에 생성한다.

3.2. 아나콘다 설치 파일을 Download 디렉토리에 설치하자

아나콘다를 설치하는 방법은 이전에 다뤘던 "python 파이썬과 아나콘다" 포스트와 거의 유사하다.
해당 포스트를 참고하여 아래 화면으로 이동해보자.
(아나콘다 버전에 따라 UI가 조금씩 달라질 수 있지만, 기본적인 방법은 같다)

Ubuntu는 Linux의 버전 중 하나이므로, Linux installer를 누르면 된다.
Tensorflow를 사용할 것이므로 64Bit를 다운로드 받아야한다.
"마우스 오른쪽 클릭 > 위 빨간 박스를 클릭"하여, 다운로드 받을 파일의 링크 주소를 복사하자.

cd Download
wget https://repo.anaconda.com/archive/Anaconda3-2020.11-Linux-x86_64.sh
ll

리눅스 화면에서 복사는, 복사하고 싶은 구간 드래그이며, 붙여 넣기는 커서에 마우스 오른쪽 클릭을 하면 된다.

wget 링크_주소: 인터넷에서 "링크_주소"에 해당하는 파일을 다운로드한다.

3.3. 아나콘다 설치 파일 권한 부여 및 실행

설치된 아나콘다 설치 파일의 색을 보면, 흰색으로 되어 있는 것을 볼 수 있다.
해당 파일을 실행하기 위해 권한을 부여해보도록 하자.

chmod 755 Anaconda3-2020.11-Linux-x86_64.sh
ll

권한이 부여되어 파일의 색이 녹색으로 바뀐 것을 볼 수 있다.
해당 파일을 실행해보자.

./Anaconda3-2020.11-Linux-x86_64.sh

Enter를 눌러, 쭉 진행해보자.

뭔가 엄청나게 많은 글이 뜨는데, 아나콘다 설치에 대한 약관이므로, 계속 엔터를 눌러 약관을 끝까지 내려주자.

yes를 입력하여 설치를 진행해주자.

Enter를 눌러서 아래 경로에 아나콘다를 설치해주자

yes를 입력해서, conda init 명령어로 Anaconda를 초기화 해주자.

3.4. 아나콘다 PATH 설정

위 과정까지 진행했다면, linux를 종료했다가 다시 키거나, bashrc를 실행하여 PATH를 설정해줘야 한다.

source ~/.bashrc

위 코드를 진행하면, 맨 왼쪽의 녹색 이름 옆에 (base)라는 글이 붙은 것을 볼 수 있다.
이는, 아나콘다 쉘이 실행된 것으로, 성공적으로 아나콘다가 설치 및 실행된 것을 볼 수 있다.
초기 화면으로 빠져나와, 설치된 아나콘다를 확인해보자.

cd
ll

위 사진을 보면, 성공적으로 anaconda3가 설치된 것을 볼 수 있다.

지금까지 윈도우에 리눅스 기반 가상머신을 설치하고, 해당 가상머신에 아나콘다를 설치해보았다. 위 과정은 아나콘다 설치 파일을 다운로드하는 과정까지만 인터넷이 필요하며, 이후의 과정에서는 오프라인으로 진행해도 된다.

즉, 위 과정은 이후 분석 서버에 환경을 구축할 때도 다시 한번 진행되는 내용이다.

다음 포스트에서는 아나콘다 가상 환경을 만들고, 이를 압축하여, 외부로 내보내는 방법에 대해 알아보도록 하겠다.

ML알고리즘-1.2. 선형 회귀 - 경사 하강법(BGD)

만년필잉크 — Sun, 21 Mar 2021 17:44:36 +0900

선형 회귀 모델 - 경사 하강법(Gradient descent, GD)

지난 포스트까지 정규방정식(Normal Equation)과 최소제곱법(Least Squares method)을 이용하여 선형 회귀(Linear Regression)의 모델 파라미터를 계산해보았다.

정규방정식이나 최소제곱법을 이용하여 모델 파라미터를 계산하는 경우, 공식이 꽤나 단순하고 단 한 번만 연산을 해도 된다는 장점이 있지만, 칼럼의 양이 2배 늘어나는 경우 정규방정식은 계산 시간이 최대 약 8배까지 증가하며, 최소제곱법은 계산 시간이 최대 4배까지 증가한다는 단점이 있다고 하였다.

때문에, 데이터의 피처(컬럼의 수)가 매우 많거나 데이터 자체가 큰 경우, 정규방정식이나 최소제곱법을 사용하여 선형 회귀의 모델 파라미터를 계산하는 것보다. 경사 하강법(Gradient descent)을 사용하여 계산하는 것이 보다 유리하다.

이번 포스트에서는 경사 하강법에 대해 알아보고, 경사하강법을 사용하여 선형 회귀 모형으로 학습을 해보도록 하겠다.

1. 경사 하강법이란?

앞서 우리는 선형 회귀 모델의 손실 함수인 MSE에 대해 알아보았다.

$$ MSE = \frac{1}{n}\sum_{i=1}^{n}(\hat{y_i} - y_i)^2 $$

MSE에서 $\hat{y_i} = \theta x + b$이므로($\theta$: 계수, $x$: 실제 값, $b$: 절편), 학습을 통해 알고자 하는 미지수인 모델 파라미터 $\theta$는 1개의 최적해를 갖는 이차 함수 형태인 것을 알 수 있다.
때문에 손실 함수의 개형은 아래와 같다.

선형 회귀 모델을 비롯한 머신러닝 알고리즘에서 최고의 모델 파라미터를 찾는 방법은 손실 함수(Loss function)을 최소로 만드는 점 $\alpha$를 찾는 것이다.
정규방정식이나 최소제곱법은 우리가 찾고자 하는 $\alpha$를 한 번에 찾는 방법이고, 경사 하강법은 손실 함수의 랜덤 한 위치에서 기울기를 계산하고, 기울기가 0이 되는 방향으로 학습률(Learning rate)만큼 점진적으로 이동하여, 최적해 $alpha$를 찾는 방법이다.
위 과정은 전역 최적해(Global minimub)를 찾기 위해 반복 수행되며, 반복 수행된다는 의미는 다양한 랜덤한 위치에서 경사 하강법이 실시된다는 의미다.
보다 자세히 경사 하강법의 원리를 알고자 하는 경우, 이전 포스트인 "딥러닝-6.0. 최적화(1)-손실함수와 경사하강법"을 참고하기 바란다.

1.1 경사 하강법의 한계점

경사 하강법의 태생적 문제로 인해 다음과 같은 한계점이 존재한다.

데이터가 많아질수록 계산량 증가: 학습 데이터의 양이 늘어나는 경우, 계산량이 매우 커져 학습 속도가 느려진다.
지역 최소해(Local minimum) 문제: 실제 손실 함수의 형태는 위 그래프처럼 매끈하지 않고, 울퉁불퉁하기 때문에 실제로 찾아야 하는 전역 최적해(Global minimum)가 아닌 지역 최소해(Local minimum)를 찾을 수 있다.
Plateau 문제: 평평한 지역(Plateau)에 들어가서, 학습이 더 이상 진행되지 못하는 문제
Zigzag 문제: 찾아야 하는 해가 많아질수록 차원이 복잡해져, 제대로 해를 찾지 못하는 문제

위 내용에 대해 보다 자세히 알고자 하는 경우, 이전 포스트인 "딥러닝-6.1. 최적화(2)-경사하강법의 한계점"을 참고하기 바란다.

2. 경사 하강법의 공식 - 배치 경사 하강법(Batch Gradient Descent)

앞서 봤던 MSE 공식을 이번에는 벡터 형태로 가지고 와보자.

$$ MSE(X, h_{\theta}) = MSE(\theta) = \frac{1}{n}\sum_{i=1}^{n}(\theta^Tx^{(i)} - y^{(i)})^2 $$

위 식을 모델 파라미터 $\theta$에 대해 편미분 해보자.

$$\frac{\partial}{\partial \theta_j}MSE(\theta) = \frac{2}{n}\sum_{i=1}^{n}(\theta^T x^{(i)} - y^{(i)})x_{j}^{i}$$

위 편미분 결과에 대하여, 모든 모델 파라미터 $\theta_j$의 성분에 대한 편미분으로 구성된 열벡터로 만들어보고, 이를 행렬식으로 바꿔보자.

$$\bigtriangledown_{\theta} MSE(\theta) =
\begin{pmatrix} \frac{\partial}{\partial \theta_0}MSE(\theta)
\\ \frac{\partial}{\partial \theta_1}MSE(\theta)
\\ \vdots
\\ \frac{\partial}{\partial \theta_0}MSE(\theta)
\end{pmatrix} = \frac{2}{m}X^T(X\theta - y)$$

경사 하강법 공식은 다음과 같다.

$$x_{i+1} = x_i - \eta \bigtriangledown f(x_i)$$

위 경사 하강법 공식에서 손실함수 $\bigtriangledown f(x_i)$의 위치에, 위에서 구한 $MSE$의 편미분 행렬식인 $\bigtriangledown_{\theta} MSE(\theta)$을 넣어주고, 미지수$x$도 선형 회귀의 모델 파라미터인 $\theta$로 바꿔 선형 회귀 모델에 대한 경사 하강법 공식으로 만들어주자.

$$\theta_{i+1} = \theta_i - \eta \bigtriangledown MSE(\theta) = \theta_i - \frac{2}{m} \eta X^T(X\theta - y)$$

위 공식은 매 경사 하강법 스텝에서 전체 훈련 세트 $X$에 대해 계산한다. 이를 배치 경사 하강법(Batch gradient descent)라 하며, 매 스텝에서 훈련 데이터 전체를 대상으로 최적해를 찾기 때문에 계산 시간도 길고, 소모되는 컴퓨터 자원의 양도 많다.
때문에 매우 큰 데이터를 대상으로 할 때는 위 공식인 배치 경사 하강법을 사용하지 않는 것이 좋으며, 무작위 샘플 데이터 셋을 추출해, 그 샘플에 대해서만 경사 하강법을 실시하는 확률적 경사 하강법(Stochastic Gradient Descent, SGD)을 실시하는 것이 좋다.
그러나, 경사 하강법은 특성 수에 민감하지 않기 때문에, 특성 수가 매우 많은 경우, 정규방정식이나 특잇값 분해(SVD)를 이용한 최소제곱법보다 경사 하강법을 사용하여 학습하는 것이 좋다.
경사 하강법 공식의 $\eta$는 학습률(Learning rate)라 하며, 에타라고 발음한다. 경사 하강법은 현재(n)의 파라미터 $\theta$에서 MSE의 편미분 벡터에 학습률을 곱한 수치만큼 아래 방향으로 이동한다.

3. 넘파이 코드를 이용해서 배치 경사 하강법을 구현해보자.

위에서 행렬식으로 만든 경사 하강법 함수는 다음과 같다.

$$\theta_{i+1} = \theta_i - \frac{2}{m} \eta X^T(X\theta - y)$$

경사 하강법은 최적의 모델 파라미터를 찾기 위해 전체 데이터에 대하여 m번 반복하여 계산된다.
이 반복되는 것을 학습 단위라고 하며, Epoch(에포크), Batch size(배치 사이즈), Iteration(이터레이션)에 대한 기본 개념을 알아야 한다.

Epochs: 전체 데이터를 학습 시키는 횟수
Batch size: 연산 한 번에 들어가는 데이터의 크기
Iteration: 1 epoch를 마치는데 필요한 모델 파라미터 업데이터의 횟수

보다 자세한 내용은 다음 포스트 "딥러닝-6.2. 최적화(3)-학습 단위(Epoch, Batch size, Iteration)"을 참고하기 바란다.
이번에는 1 epoch에서 모델 파라미터를 m번 갱신(Iteration)해보도록 하겠다.

3.1. 사용할 데이터

데이터는 이전 포스트에서 사용했던 컬럼이 1개인 데이터를 사용해보겠다.

import numpy as np
import matplotlib.pyplot as plt

np.random.seed(1234)

def f(x):
    return 3 * x + 4

X = 2 * np.random.rand(100, 1)
Y = f(X) + np.random.randn(100, 1)

# 상수항을 위해 모든 원소가 1인 컬럼을 추가함
X_b = np.c_[X, np.ones((100, 1))]

생성한 데이터를 sklearn 라이브러리의 LinearRegression 모델을 사용하여, 학습시켜보겠다.
sklearn의 LinearRegression에 학습시킬 때는 상수항을 위해 모든 원소가 1인 컬럼을 추가하지 않아도 된다.

# sklearn 라이브러리의 선형 회귀 모형
from sklearn.linear_model import LinearRegression

LR_model = LinearRegression()
LR_model.fit(X, Y)

>>> LR_model.coef_, LR_model.intercept_
(array([[2.94132381]]), array([4.07630632]))

숨겨진 패턴인 함수 $f(x) = 3x + 4$의 계수 3과 상수 4에 근사한 결과가 나왔다.

3.2. 배치 경사 하강법 코드

def Batch_GD(x, y, eta=0.01, iteration_N=1000):
    
    # 초기 무작위 파라미터
    theta = np.random.randn(x.shape[1], 1)

    for iteration in range(iteration_N):

        # MSE의 편미분 벡터
        gradients = (2/x.shape[0])* x.T.dot(x.dot(theta) - y)
        theta = theta - eta * gradients
        
    return theta

>>> Batch_GD(X_b, Y, 0.01, 1000)
array([[3.02789289],
       [3.97237607]])

학습률 eta나 파라미터 갱신 횟수 iteration_N과 같은 분석가가 직접 설정하는 파라미터를 머신러닝에서는 하이퍼 파라미터라고 한다.
학습률이 크면 클수록 빠르게 최적해에 수렴하나, 너무 크게 이동하므로 전역 최적해에 수렴하지 못할 수 있다.
학습률을 보다 크게 학습시켜보자.

>>> Batch_GD(X_b, Y, 0.1, 1000)
array([[2.94132381],
       [4.07630632]])

학습률이 0.1로 10배나 커지자, 보다 빠르게 수렴하여 최소제곱법(LSM)을 사용하여 회귀 모델의 최적의 파라미터를 계산하는 sklearn의 LinearRegression과 같은 결과가 나왔다.

4. 학습률과 Iteration에 따른 수렴 속도의 차이 시각화

위에서 만든 Batch_GD 함수를 약간 수정하여, 갱신된 파라미터에 대한 예측값을 plot으로 시각화하는 함수를 만들어보자.

# 전체 시각화
def draw_eta(x, y, eta_, iteration_N_):
    
    plt.scatter(x, y)
    
    # 상수항을 위한 모든 원소가 1인 컬럼 추가
    x_b = np.c_[x, np.ones((X.shape[0], 1))]
    Batch_GD_Visual(x_b, y, eta=eta_, iteration_N=iteration_N_)
    
    # 제목
    plt.xlabel("X", fontsize = 15)
    plt.ylabel("Y", fontsize = 15, rotation = 0)
    plt.title(f"$\eta$={eta_}", fontsize = 20, pad=15)
    
    plt.xlim(0, 2)
    plt.ylim(0, 15)
    
    plt.show()



# 갱신되는 theta에 따른 경사 하강법 시각화
def Batch_GD_Visual(x, y, eta=0.01, iteration_N=1000):

    # 초기 무작위 파라미터
    theta = np.random.randn(x.shape[1], 1)

    for iteration in range(iteration_N):

        # MSE의 편미분 벡터
        gradients = (2/x.shape[0])* x.T.dot(x.dot(theta) - y)
        theta = theta - eta * gradients
        
        # 경사 하강법을 통해 바뀐 theta로 예측한 값
        new_Y = np.array([[0,1],[2,1]]).dot(theta)
        plt.plot([0,2], new_Y, c = "r", alpha = 0.2)
        
    return theta

draw_eta는 시각화 코드를 정리해놓은 함수다.
Batch_GD_Visual은 갱신되는 $\theta$에 따른 경사 하강법을 시각화하는 함수로, 옅은 빨간색 선을 그린다.

4.1. iteration은 50이고, 학습률이 변하는 경우

iteration 1000은 꽤 큰 값이므로, 작은 50으로 설정해놓고 학습률만 바꿔보자.
학습률이 0.01인 경우

eta_ = 0.01
iteration_N_ = 50
draw_eta(X, Y, eta_, iteration_N_)

학습률이 0.1인 경우

eta_ = 0.1
iteration_N_ = 50
draw_eta(X, Y, eta_, iteration_N_)

학습률이 0.5인 경우

eta_ = 0.5
iteration_N_ = 50
draw_eta(X, Y, eta_, iteration_N_)

위 결과를 보면, 학습률이 커지면 커질수록 빠르게 최적해를 찾아가는 것을 볼 수 있지만, $\eta=0.5$ 같이 지나치게 큰 경우, 모델 파라미터가 큰 폭으로 요동치는 것을 볼 수 있다.
위에서 볼 수 있듯, 데이터에 맞는 적절한 학습률을 찾는 것은 매우 중요하다.

4.2. 학습률은 0.01이고, iteration이 변하는 경우

학습률을 최적해에 비교적 늦게 수렴하는 0.01로 잡고, 파라미터 갱신 횟수인 iteration만 바꿔보자.
(꽤 많은 머신러닝 알고리즘에서 Learning rate의 기본값을 0.01로 잡아놓는다.)
iteration이 10인 경우

eta_ = 0.01
iteration_N_ = 10
draw_eta(X, Y, eta_, iteration_N_)

iteration이 30인 경우

eta_ = 0.01
iteration_N_ = 30
draw_eta(X, Y, eta_, iteration_N_)

iteration이 100인 경우

eta_ = 0.01
iteration_N_ = 100
draw_eta(X, Y, eta_, iteration_N_)

위 결과를 보면, 파라미터 갱신량도 필요치보다 작은 경우, 최적해를 찾기 전에 경사 하강이 끝나버리고, 필요치 보다 큰 경우, 최적해를 찾고 파라미터가 더 이상 변하지 않는 시간 낭비가 발생하는 것을 볼 수 있다.
이에 대한 해결책으로는, iteration을 애초에 크게 잡은 후, 경사 하강법 알고리즘에 규제를 추가하여, 모델 파라미터의 변화량이 허용오차(tolerance) $\varepsilon$보다 작아지면 최적해에 도달한 것으로 판단하고 모델 파라미터 갱신을 중지시키는 것이다.

[참고 서적]

이번 포스트에서는 배치 경사 하강법을 이용하여 선형 회귀 모형을 만들어보았다. 배치 경사 하강법은 데이터가 지나치게 큰 경우 계산 시간이 지나치게 오래 걸리는 정규방정식이나 최소제곱법보다 빠르게 최적해를 찾을 수 있다.

그러나, 학습률, 파라미터 갱신 횟수(iteration)과 같은 하이퍼 파라미터를 제대로 잡지 않는다면, 학습 시간이 필요보다 길어지거나, 최적해에 수렴하지 못할 수 있으므로, 최적의 하이퍼 파라미터를 찾을 수 있어야 한다.

배치 경사 하강법은 모든 데이터에 대한 편미분 벡터를 계산하게 되므로, 데이터의 크기가 이보다 더 커지는 경우, 학습 시간이 더 길어질 수 있다. 다음 포스트에서는 이 문제를 해결한 확률적 경사 하강법에 대해 알아보도록 하겠다.

ML알고리즘-1.1. 선형 회귀의 구현 - 정규방정식과 최소제곱법

만년필잉크 — Sun, 21 Mar 2021 00:54:24 +0900

선형 회귀의 구현 - 정규방정식과 최소제곱법

지난 포스트에서 머신러닝에서 선형 회귀 모델의 기본적인 원리에 대해 알아보았다. 이번 포스트는 정규방정식을 넘파이 함수로 구현해보고, 정규방정식으로 찾아낸 최적의 모델 파라미터를 이용해서 새로운 데이터에 대해 예측을 해보자.

1. 선형성을 갖는 무작위 데이터를 만들어보자.

임의의 선형 데이터를 만들어 정규방정식에 넣어보도록 하자.

import numpy as np
import matplotlib.pyplot as plt

np.random.seed(1234)

def f(x):
    return 3 * x + 4

X = 2 * np.random.rand(100, 1)
Y = f(X) + np.random.randn(100, 1)

np.random.rand(shape): 0~1 사이의 표준 정규 분포 난수를 shape의 형태대로 생성
np.random.randn(shape): 평균 0, 표준편차 1의 가우시안 표준 정규 분포 난수를 shape의 형태대로 생성
0에서 1 사이의 난수 X에 2를 곱하여, 값의 범위를 더 넓게 하였다.
숨겨진 패턴은 함수 $f(x) = 3x + 4$이며, $f(x)$에 $N(0,1)$인 가우시안 표준 정규 분포를 더해 노이즈를 주었다.

plt.scatter(X, Y)

plt.xlabel("X", fontsize=15)
plt.ylabel("Y", rotation=0, fontsize=15)
plt.show()

2. 넘파이 코드를 사용해서 정규방정식을 구현해보자.

정규방정식 함수는 다음과 같다.

$$\hat{\theta} = (X^TX)^{-1}X^Ty$$

위 정규방정식 함수를 넘파이 라이브러리의 함수를 사용해서 함수로 만들어보자.

# 정규방정식
def NormalEquation(X, Y):
    
    return np.linalg.inv(np.dot(X.T, X)).dot(X.T).dot(Y)

np.linalg.inv(): 역행렬
np.dot(mat1, mat2): 행렬 mat1과 mat2의 행렬 곱 연산을 한다.
mat1.dot(mat2): 행렬 mat1과 mat2의 행렬 곱 연산을 한다.

2.1. 배열 X와 Y를 넣어보자

>>> NormalEquation(X, Y)
array([[6.00122666]])

위 데이터에서 숨겨진 패턴인 함수 $f(x)$는 $f(x) = 3x + 4$이므로, 3과 4가 출력되어야 하지만, 원소가 단 하나만 출력되었다.
이는 함수 $f(x)$에 들어가는 배열 X에 절편에 대한 칼럼이 반영되지 않았기 때문이다.
절편 4는 4*1이므로, 배열 X에 모든 원소가 1인 칼럼을 하나 추가해주고, 정규방정식을 수행해보도록 하자.

2.2. 절편에 대한 칼럼이 반영된 배열 X와 Y를 넣어보자.

# 절편에 대한 1로 구성된 벡터를 추가함.
>>> X_b = np.c_[X, np.ones((100, 1))]

# 정규방정식을 통해 최적의 계수를 찾아냄
>>> NormalEquation(X_b, Y)
array([[2.94132381],
       [4.07630632]])

np.c_[array1, array2]: array1과 array2를 컬럼 방향으로 붙인다(오른쪽에 붙인다)
위 결과를 보면, 숨겨진 패턴인 함수 $f(x) = 3x + 4$의 계수인 3과 4와 아주 가까운 값이 도출된 것을 볼 수 있다.
숨겨진 패턴의 계수 3과 4가 나오지 않은 이유는, 의도적으로 노이즈를 주었기 때문이며, 그 노이즈를 반영하였을 때, 숨겨진 패턴에 가장 가까운 모델 파라미터가 출력된 것이다.

2.3. 변수 $x$가 2개인 데이터에 대하여 정규방정식을 이용해 최적해를 구해보자.

이번에는 숨겨진 패턴이 $h(x) = 3x_1 + 4x_2 + 5$인 함수에 대하여 구해보자.
변수 $x$가 2개이므로, 컬럼의 수는 2개가 되어야 한다.

X1 = 2 * np.random.rand(100, 2)

def h(x):
    x1 = x[:,0]
    x2 = x[:,1]
    
    result = 3 * x1 + 4 * x2 + 5
    
    return result.reshape(100, 1)

Y1 = h(X1) + np.random.randn(100, 1)

# 절편을 위해 모든 원소가 1인 컬럼 추가
X1_b = np.c_[X1, np.ones((100, 1))]

>>> NormalEquation(X1_b, Y1)
array([[2.93017703],
       [4.19897028],
       [4.90893137]])

각 계수의 값이 3, 4, 5에 근사하게 나왔으나, 실제 값과 어느 정도 거리가 있다.
데이터의 양이 늘어날수록 실제 계수에 더 가까워진다.

X2 = 2 * np.random.rand(10000, 2)

def h(x):
    x1 = x[:,0]
    x2 = x[:,1]
    
    result = 3 * x1 + 4 * x2 + 5
    
    return result.reshape(10000, 1)

Y2 = h(X2) + np.random.randn(10000, 1)
X2_b = np.c_[X2, np.ones((10000, 1))]

>>> NormalEquation(X2_b, Y2)
array([[2.98528199],
       [4.01290386],
       [5.00091078]])

3. 찾아낸 모델 파라미터를 이용해서 예측을 해보자.

정규방정식을 통해 계산해 낸 선형 회귀 모델의 파라미터 $\hat{\theta}$를 사용해서 새로운 데이터가 들어갔을 때, 그 결과를 예측해보자.

def predict_linear_R(X, theta):
    
    R_n = X.shape[0]
    
    try:
        C_n = X.shape[1]
    except:
        C_n = 1
    
    X_Reshape = X.reshape(R_n, C_n)
    X_concat_1 = np.c_[X_Reshape, np.ones((R_n,1))]
    
    return X_concat_1.dot(theta)

3.1. 독립변수가 1개인 경우

처음 만들었던 칼럼이 1개 있는 데이터의 최적 모델 파라미터에 대하여, 새로운 데이터를 넣어 새로운 데이터에 대한 예측 값을 뽑아보자.
새로운 데이터는 [0, 1, 2]로 구성된 벡터이다.

def f(x):
    return 3 * x + 4

X = 2 * np.random.rand(100, 1)
Y = f(X) + np.random.randn(100, 1)

X_b = np.c_[X, np.ones((100, 1))]
best_theta = NormalEquation(X_b, Y)

>>> best_theta
array([[2.94132381],
       [4.07630632]])

# 새로운 데이터
>>> new_X = np.array([0, 1, 2]).reshape((3,1))

# 새로운 데이터를 학습된 선형 회귀 모형에 넣어 예측된 결과
>>> pred_LR = predict_linear_R(new_X, best_theta)
>>> pred_LR
array([[4.07630632],
       [7.01763013],
       [9.95895394]])

기존에 그린 산점도 위에 예측된 결과를 그려보자.

plt.scatter(X, Y, label="real")
plt.plot(new_X, pred_LR.reshape(new_X.shape), color = "red", label="predict")

plt.xlabel("X", fontsize=15)
plt.ylabel("Y", rotation=0, fontsize=15)
plt.legend(loc="lower right")
plt.show()

3.2. 독립변수가 2개인 경우

X1 = 2 * np.random.rand(100, 2)

def h(x):
    x1 = x[:,0]
    x2 = x[:,1]
    
    result = 3 * x1 + 4 * x2 + 5
    
    return result.reshape(100, 1)

Y1 = h(X1) + np.random.randn(100, 1)
X1_b = np.c_[X1, np.ones((100, 1))]
best_theta1 = NormalEquation(X1_b, Y1)

>>> best_theta1
array([[2.93017703],
       [4.19897028],
       [4.90893137]])

>>> new_X1 = np.array([[0, 1],[0.5, 1.5],[1, 2]])

>>> predict_linear_R(new_X1, best_theta1)
array([[ 9.10790166],
       [12.67247531],
       [16.23704897]])

독립변수가 2개 이상인 경우, 독립 변수의 축 2개 + 종속변수의 축 1개로 3개 이상의 축이 생겨, 시각화가 어려워진다. 그러므로, 시각화는 생략하도록 하겠다.
최적의 모델 파라미터만 찾아내면, 쉽게 회귀 모델을 사용해서, 예측값을 찾아낼 수 있다.

4. 사이킷런을 사용해서 선형 회귀를 실시해보자.

사이킷런을 사용하면, 더 쉽게 위 과정을 진행할 수 있다.

from sklearn.linear_model import LinearRegression

lin_R = LinearRegression()

사용하고자 하는 모델인 선형 회귀 모형을 객체로 만들었다.
앞서 만든 데이터 X와 Y를 사용하여, 최적의 모델 파라미터를 찾아보자.

# 선형 회귀 모형 학습
>>> lin_R.fit(X, Y)

# 계수와 절편 출력
>>> lin_R.coef_, lin_R.intercept_
(array([[2.94132381]]), array([4.07630632]))

# Numpy로 만든 정규방정식의 결과
>>> best_theta
array([[2.94132381],
       [4.07630632]])

모델.fit(array1, array2): 원하는 모델을 학습시킨다. array1은 훈련 데이터(Test data), array2는 레이블 데이터(Label data)다.
선형회귀모델.intercept_, 선형회귀모델.coef_: sklearn을 사용하여, 선형 회귀 모형을 학습시키면, 계수와 절편의 값이 따로 출력된다. coef_는 계수이며, intercept_는 절편이다.
sklearn을 사용하여 계산된 결과와 numpy를 사용하여 만든 정규방정식의 결과가 동일한 것을 볼 수 있다.
이번에는 학습된 모델 파라미터를 사용하여, 새로운 데이터가 들어갔을 때의 결과를 예측해보자.

# sklearn을 이용하여 예측한 결과
>>> lin_R.predict(new_X)
array([[4.07630632],
       [7.01763013],
       [9.95895394]])
       
# numpy 라이브러리를 사용하여 예측한 결과
>>> predict_linear_R(new_X, best_theta)
array([[4.07630632],
       [7.01763013],
       [9.95895394]])

모델.predict(array): array에 모델 파라미터를 계산하여, 예측된 결과를 출력한다.

5. 정규방정식의 한계점

5.1. 의사역행렬(Pseudoinvese matrix)과 최소제곱법(LSM)

앞서 우리가 학습하였던 정규방정식에는 큰 한계점이 존재한다.
정규방정식 공식 $\hat{\theta} = (X^TX)^{-1}X^Ty$에는 역행렬이 포함되어 있는데, 역행렬은 항상 존재하는 것이 아니기 때문에 역행렬이 존재하지 않는다면, 정규방정식 공식은 작동하지 않을 수 있다.
때문에 등장하는 것이 무어-펜로즈 역행렬(Moore-Penrose pseudoinverse matrix)이라고도 불리는 의사역행렬(Pseudoinverse matrix)을 사용하여 다음과 같은 공식으로 최적의 모델 파라미터를 찾아내게 된다.

$$ \hat{\theta} = X^{+}y$$

의사역행렬은 특잇값 분해(Singular value decomposition, SVD)라는 표준 행렬 분해 기법을 통해 계산되며, 의사역행렬은 역행렬이 없는 행렬에 대해서도 계산을 할 수 있기 때문에 정규방정식의 한계점을 해결할 수 있으며, 계산 속도 또한 빠르다.
선형 회귀 모델의 회귀 계수(모델 파라미터)를 추정할 때, 가장 많이 사용되는 기법인 최소제곱법(Least squares method, LSM)은 의사역행렬을 사용하여 해를 구하므로, sklearn의 선형 회귀 모델은 정규방정식이 아닌 최소제곱법을 기반으로 계산한다.

>>> np.linalg.lstsq(X_b, Y, rcond=1e-6)
(array([[2.94132381],
        [4.07630632]]),
 array([92.72583695]),
 2,
 array([14.98211623,  3.69398772]))

np.linalg.lstsq(array1, array2): array1, array2의 최소제곱해를 선형 행렬 방정식으로 반환한다.
위 함수를 사용하면 총 4개의 결과가 반환되는데, 여기서 맨 처음에 반환된 결과인 최소제곱해만 신경 쓰면 된다.

# 최소제곱해
>>> np.linalg.lstsq(X_b, Y, rcond=1e-6)[0]
array([[2.94132381],
       [4.07630632]])
       
       
# Numpy로 만든 정규방정식의 결과
>>> best_theta
array([[2.94132381],
       [4.07630632]])

보시다시피 최소제곱법을 사용해서 구하는 최소제곱해와 정규방정식의 결과는 동일한 것을 알 수 있다.
그러나, 최소제곱법은 의사역행렬을 통해 계산되기 때문에 역행렬이 존재하지 않는 대상에 대해서도 계산이 가능하다.

5.2. 정규방정식의 계산복잡도

정규방정식은 역행렬 계산, 행렬 곱 등 다양한 행렬 연산이 들어가기 때문에 계산 복잡도(Computation complexity)가 매우 크다.
정규방정식을 사용할 때, 특성의 수가 2배 늘어나면, 계산 시간이 약 5.3배에서 8배로 증가하며, 특잇값 분해(SVD)를 통해 의사역행렬을 구한다 할지라도 특성의 수가 2배 늘어나는 경우, 계산 시간이 약 4배 증가하게 된다.
즉, 칼럼의 수가 늘어나면 늘어날수록 계산 시간이 기하급수적으로 늘어나기 때문에, 칼럼이 많은 데이터를 정규방정식이나 최소제곱법으로 구하는 경우, 시간이 매우 오래 걸리게 된다.
(행의 수가 늘어나는 경우, 늘어난 샘플 수만큼 선형적으로 소모 시간이 증가하기 때문에 행의 수는 큰 영향을 안 준다.)
만약, 칼럼의 양이나 데이터 자체가 매우 많은 경우, 계산량이 지나치게 많아, 메모리를 넘어설 수 있기 때문에, 정규방정식이나 최소제곱법을 사용하지 못할 수도 있다.

[참고]

numpy.org/doc/stable/reference/generated/numpy.linalg.lstsq.html

numpy.linalg.lstsq — NumPy v1.20 Manual

Cut-off ratio for small singular values of a. For the purposes of rank determination, singular values are treated as zero if they are smaller than rcond times the largest singular value of a. Changed in version 1.14.0: If not set, a FutureWarning is given.

numpy.org

blog.daum.net/jungjin1980/77

특이값 분해

출처 : http://darkpgmr.tistory.com/106 활용도 측면에서 선형대수학의 꽃이라 할 수 있는 특이값 분해(Singular Value Decomposition, SVD)에 대한 내용입니다. 보통은 복소수 공간을 포함하여 정의하는 것이..

blog.daum.net

지금까지 정규방정식과 정규방정식의 한계점을 보완한 최소제곱법에 대해 간략히 알아보고, 코드화해 보았다. 최소제곱법은 선형 회귀 모형을 다룰 때, 굉장히 심도 있게 공부해야 하는 부분이므로, 기초 통계학 부분에서 보다 자세히 다루도록 하겠다.

다음 포스트에서는 선형 회귀 모형을 정규방정식이나 최소제곱법이 아닌, 경사하강법을 사용해서 구하는 방법에 대해 알아보도록 하겠다.

ML알고리즘-1.0. 선형 회귀(Linear Regression)와 정규방정식

만년필잉크 — Sat, 20 Mar 2021 21:06:37 +0900

선형 회귀(Linear Regression)

통계학의 꽃이라고도 불리는 선형 회귀(Linear Regression)는 수많은 머신러닝 알고리즘의 기반이 되기도 하기 때문에, 반드시 그 원리를 이해해야하는 알고리즘 중 하나다.

선형 회귀의 원리를 단순하게 말하자면, 관찰값으로부터 가장 거리가 짧은 데이터를 대표할 수 있는 선을 긋는 것이며, 그 선을 회귀식이라고 한다. 관찰값으로부터 가장 짧은 거리인지를 평가하는 방법은 최소제곱법(Least Square Method)이 주로 사용된다.

1. 회귀식

$$\hat{y} = \theta_0 + \theta_1x_1 + \theta_2x_2 + \cdots + \theta_nx_n \ \ \ \cdots①$$

$$\hat{y} = h_\theta(x) = \theta \cdot x \ \ \ \cdots②$$

회귀식은 기본적으로 해가 $n$개인 일차 연립방정식의 형태이며, 계수와 특성의 값의 곱의 합에 편향(Bias, 절편 - Intercept)을 더한 것이다.
$\theta_n$는 해당 관찰값의 계수로, 관찰값 $x_n$가 예측값에 미치는 영향을 보여준다.
계수 $\theta$는 음과 양의 부호를 가질 수 있으며, 이를 통해 해당 특성(변수, 필드)가 종속변수(예측값)에 어떠한 영향을 주는지 볼 수 있다.

1.1. 식 ①의 설명

$\hat{y}$: 예측값으로, 종속변수(Dependent variable)이라 한다.
$n$: 특성의 수, 독립변수(Independent variable)의 수이다.
$x_i$: $i$번째 특성값으로, $i$번째 독립변수를 의미한다.
$\theta_j$: $j$번째 모델 파라미터로, 머신러닝 알고리즘 스스로가 학습을 통해 찾아내는 값이다.

1.2. 식 ②의 설명

식 ①을 벡터 형태로 바꾼 것으로, $\theta$와 $x$가 열 벡터(Column vector) 라면, 예측은 $\hat{y} = \theta^Tx$가 된다.
열 벡터란 하나의 열(Column)을 가진 2D 배열이며, $\theta^T$는 열벡터 $\theta$의 전치(Transpose)이다.
두 열 벡터 $\theta$와 $x$의 길이는 서로 동일하므로, 전치 벡터와 길이가 동일한 벡터를 곱하면, 동일한 위치의 원소끼리 곱하고, 더하는 효과가 발생한다.
$\theta$: 편향 $\theta_0$와 계수 $\theta_1, \theta_2, \cdots, \theta_n$에 대한 모델 파라미터 벡터다.
$x$: $x_0, x_1, \cdots, x_n$까지의 데이터의 특성 벡터다. $x_0$는 편향과 곱해지는 값이므로 무조건 1이다.
$\theta \cdot x$: 벡터 $\theta$와 $x$의 점곱으로, $\theta_0x_0 + \theta_1x_1 + \theta_2x_2 + \cdots + \theta_nx_n$과 같다.
$h_\theta$: 모델 파라미터 $\theta$를 사용한 가설(Hypothesis) 함수다.

2. 손실함수 RMSE & MSE

선형 회귀 모델의 학습은 훈련 데이터 셋(Train dataset)에 가장 잘 맞는 모델 파라미터($\theta$)를 찾아내는 것이다.
이를 위해 모델이 훈련 데이터에 얼마나 잘 맞는지 측정해야한다.
선형 회귀 모형은 평균 제곱근 오차(Root Mean Square Error, RMSE)를 사용하여, 모델의 성능을 평가하며, RMSE를 최소화하는 $\theta$를 찾아내는 것이 선형 회귀 모델의 학습 과정이다.
RMSE 공식은 다음과 같다.

$$RMSE = \sqrt{\frac{1}{n}\sum_{i=1}^{n}(\hat{y_i} - y_i)^2}$$

$$ RMSE(X, h_{\theta}) = RMSE(\theta) = \sqrt{\frac{1}{n}\sum_{i=1}^{n}(\theta^Tx^{(i)} - y^{(i)})^2} $$

평균 제곱근 오차(RMSE)의 원리는 표준편차와 동일하다. 예측값과 실제 관측값의 편차 제곱의 합의 평균에 제곱근을 씌워 제곱의 합을 보정해주는 것이다.
평균 제곱근 오차(RMSE)에 대하여 더 자세히 알고자하는 경우, 다음 포스트 "딥러닝-5.2. 손실함수(3)-평균제곱근오차(RMSE)"를 참고하길 바란다.
예측값과 실제값의 편차의 평균에 가장 근사한 지표는 RMSE지만, 실제 선형 회귀 모델을 만들 때는 평균 제곱 오차(Mean Square Error, MSE)가 더 많이 사용된다.
MSE 공식은 다음과 같다.

$$ MSE = \frac{1}{n}\sum_{i=1}^{n}(\hat{y_i} - y_i)^2 $$

$$ MSE(X, h_{\theta}) = MSE(\theta) = \frac{1}{n}\sum_{i=1}^{n}(\theta^Tx^{(i)} - y^{(i)})^2 $$

RMSE보다 MSE를 사용하는 이유는 제곱근을 사용하지 않았기 때문에 실제 값보다 증폭된 결과가 도출되긴 하지만, 공식이 더 간단하며, 미분하기도 쉽다.
어차피 MSE로 도출된 결과들을 비교하기 때문에 다른 모델과 비교할 때, 보다 엄격한 결과가 나오는 RMSE를 굳이 사용할 필요가 없다.
MSE에 대해 보다 자세히 알고자 하는 경우, 다음 포스트 "딥러닝-5.1. 손실함수(2)-평균제곱오차(MSE)"를 참고하기 바란다.
선형 회귀 모델에서의 학습은 비용 함수(Cost function, 손실 함수 - Loss function)인 RMSE나 MSE를 최소로 만드는 $\theta$를 찾는 것이다.

3. 정규방정식(Normal equation)

$$\hat{\theta} = (X^TX)^{-1}X^Ty$$

$\hat{\theta}$: 비용 함수를 최소화하는 $\theta$값이다.
$y$: $y^(1)$부터 $y^{(m)}$까지 포함하는 타깃 벡터다.
정규방정식(Normal equation, Ordinary least squares, linear least squrares)는 선형 회귀에서 모델 파라미터인 $\theta$를 예측하기 위해 사용하는 최적화 알고리즘이다.
위 정규방정식은 MSE를 통해 유도 된다.

3.1. 정규방정식의 유도

MSE 공식은 다음과 같다. $MSE(\theta) = \frac{1}{n}\sum_{i=1}^{n}(\theta^Tx^{(i)} - y^{(i)})^2$
위 공식을 보면, MSE 공식은 $\theta^T$에 대하여 이차함수의 개형을 갖는 것을 알 수 있다.
그러므로, MSE을 $theta^T$에 대하여 편미분의 결과가 0이 나오게 하는 $\theta^T$의 값이 MSE를 최소로 만드는 값임을 알 수 있다.
위 내용을 이용하여, 정규방정식을 유도해보자.

3.2. 정규방정식과 경사하강법의 차이점

대표적인 최적화 알고리즘인 경사하강법(참고: "딥러닝-6.0. 최적화(1)-손실함수와 경사하강법")은 학습률(Learning rate)를 기반으로 점진적으로 최적해를 찾아간다.
MSE를 유도하여 만들어진 정규방정식은 행렬 연산을 통해 한 번에 최적해를 구한다.
정규방정식은 행렬 연산을 통해 결과를 구하기 때문에 피처의 크기(Column * Row의 양)가 커지면 커질수록 계산 시간이 오래 걸린다.
경사하강법은 계산이 일어나 기본적으로 소모되는 시간이 크긴 하지만, 아무리 피처의 크기가 크더라도 일정 시간 안에 최적해를 찾아낼 수 있다.
즉, 피처의 크기가 지나치게 크다면 선형 회귀에서도 경사하강법을 사용하는 것이 좋으며, 피처의 크기가 적당한 수준이라면, 정규방정식을 사용하도록 하자.

[참고]

다음 포스트에서는 파이썬 넘파이(Numpy) 함수만을 사용해서 선형 회귀 모델을 구현해보고, 사이킷런을 사용해서 선형 회귀 모델을 사용해보도록 하자.

머신러닝-1.5. 테스트와 검증, 공짜 점심 없음(NFL)

만년필잉크 — Sat, 20 Mar 2021 00:28:57 +0900

테스트와 검증

이전 포스트에서는 머신 러닝 사용 시 주의해야 할 사항에 대해 알아보았다. 이번 포스트에서는 학습이 끝난 모델을 어떻게 평가하는지에 대해 알아보도록 하겠다.

1. 데이터 셋 나누기

학습이 완료된 모델이 새로운 데이터에 대해 얼마나 잘 일반화되는지 알아보기 위해선, 학습에 사용하지 않은 새로운 데이터를 실제로 넣어보고, 잘 작동하는지 확인해봐야 한다.
그러나, 현장에서 새로운 데이터를 구하는 것은 굉장히 어려운 일이기 때문에, 학습에 사용할 훈련 데이터를 훈련 데이터 셋(Train dataset)과 테스트 데이터 셋(Test dataset)으로 나누는 것이 가장 현실적이다.
훈련 데이터셋으로 학습을 진행하고, 테스트 데이터 셋을 이용해서 모델을 평가하면, 테스트 데이터 셋에 대한 모델의 오차 비율을 얻을 수 있으며, 이를 일반화 오차(Generalization error) 또는 외부 샘플 오차(Out-of-sample error)라고 한다.
훈련 데이터에 대한 오차는 낮으나, 테스트 데이터에 대한 오차인 일반화 오차가 높다면, 이는 모델이 훈련 데이터에 과적합(Overfitting) 되었다는 것을 의미한다.
위 경우, 훈련 데이터에 과적합되는 것을 피하기 위해, 일반화 오차를 줄이는 방향으로, 하이퍼 파라미터 튜닝 등 다양한 작업을 수행할 수 있는데, 이 경우 단순히 결과 지표를 뽑기 위해 사용해야 하는 테스트 데이터 셋에 모델이 과적합되는 문제가 발생할 수 있다.

1.1. 검증 데이터 셋(Validation dataset)

검증 데이터 셋은 모델이 시험 셋(Test dataset)에 과대적합되는 것을 막기 위해, 훈련 데이터 셋에서 일부분을 추가로 추출하여, 모델 적합도의 기준으로 사용하는 데이터 셋이다.
전체 데이터 셋의 규모가 적거나, 검증 데이터 셋이 훈련 데이터 셋을 대표하지 못한다면, 데이터가 편향되는 결과가 발생할 수 있으므로, 교차 검증(Cross-Validation)과 같은 다양한 방법으로, 이를 해결한다.
물론, 데이터 셋의 양이 굉장히 많다면, 교차 검증은 현실적으로 사용이 불가능하며, 훈련 셋의 각 클래스별 비율에 맞는 데이터 셋을 추출하여, 대표성이 높은 검증 셋을 뽑을 수 있다.
이외 데이터 셋에 대한 보다 자세한 정보를 알고자 하면, 이전 포스트인 "Tensorflow-1.0. 기초(1)-데이터 셋 만들기"와 "Tensorflow-3.2. 이미지 분류 모델(2)-검증 셋(Validation set)"을 참고하기 바란다.

2. 하이퍼 파라미터 튜닝

하이퍼 파라미터 튜닝은 위에서 만든 학습 셋(Train set), 검증 셋(Validation set), 시험 셋(Test set)을 사용하여, 모델을 평가하며, 모델의 일반화 오차가 최소화되는 하이퍼 파라미터를 탐색하는 과정이다.
앞서 이야기 한, 학습 셋으로 만들어진 모델의 하이퍼 파라미터를 시험 셋에 과대적합 시키는 현상을 막기 위해, 검증 셋을 사용하는 것을 홀드 아웃 검증(Holdout validation)이라고 한다.
하이퍼 파라미터를 탐색하는 과정은 그리드 서치(Greed search), 랜덤 서치(RandomizedSearch), 베이지안 옵티마이저(Baysian optimizer) 등의 방법을 통해 가장 적합한 하이퍼 파라미터를 찾아낸다.

3. 공짜 점심 없음(No free lunch, NFL) 이론

1996년 David Wolpert가 발표한 "The Lack of A Priori Distinctions Between Learning Algorithms."에서 나온 공짜 점심 없음 이론은, 경험해보기 전까진 해당 데이터에 더 잘 맞을 것이라고 보장할 수 있는 모델은 존재하지 않는다는 내용이다.
머신러닝 알고리즘에서 사용되는 모델들은 관측된 데이터들을 간소한 것으로, 새로 들어온 데이터에서 일반적이지 않을 것으로 보이는 불필요한 세부 사항을 제거하는 것이다.
이러한 불필요한 세부 사항은 각 머신러닝 알고리즘이 만들어진 원리에 따라 다르게 정해진다.
때문에, 가장 핫한 머신러닝 모델 중 하나인 딥러닝 모델의 성능이 아무리 좋다고 할지라도, 경우에 따라서는 훨씬 단순한 선형 회귀 모델이 해당 데이터에는 더 적합할 수도 있다는 의미이다.
때문에 해당 데이터에 관련된 다양한 모델들을 평가해보고, 이를 비교하여, 적절한 모델을 선택하도록 해야 한다.
이는, 모든 머신러닝 모델을 각 데이터에 적용하라는 것이 아니라, 데이터의 복잡도, 데이터의 크기, 해당 데이터 성격에 관련된 모델 등 다양한 요소를 감안하여, 적합한 머신러닝 모델을 일부 선택한 후, 이들을 비교해보라는 의미이다.

[참고 서적]

머신러닝-1.4. 머신러닝 사용 시 주의해야 할 사항들

만년필잉크 — Fri, 19 Mar 2021 23:34:01 +0900

머신러닝 사용 시 주의해야 할 사항들

머신러닝은 데이터를 기반으로 머신러닝 알고리즘을 학습시키기 때문에 데이터나 알고리즘에 다음과 같은 문제가 있다면, 머신러닝을 사용했을 때, 제대로 된 결과를 기대하기 어렵다.

1. 충분하지 않은 양의 훈련 데이터

머신러닝은 말 그대로, 데이터를 이용해서 그 안에 숨어 있는 패턴을 찾아내는 것이다.
예를 들어, 고양이 사진을 이용해서, 고양이를 찾을 수 있는 모델을 만든다고 가정해보자.
고양이 사진이 매우 적다면, 시스템은 단순하게 꼬리, 다리 4개를 가진 모든 대상을 고양이라고 판단할 수도 있다.
고양이의 종류는 매우 다양하고, 다른 동물과 달리 고양이만 가진 특징을 컴퓨터가 찾아내기 위해서는 매우 많은 양의 데이터가 필요하다.

2. 대표성이 없는 훈련 데이터

머신러닝은 훈련 데이터를 이용해서 시스템을 학습시키고, 그 학습된 시스템에 새로운 데이터가 들어왔을 때, 학습된 내용을 바탕으로 새로운 데이터를 분류하게 된다.
만약, 훈련에 사용한 데이터가 대표성이 없다면, 새로운 데이터를 처음 보는 종류의 데이터로 보고, 잘못된 분류를 할 가능성이 높다.
예를 들어, 우리가 길거리에서 흔히 볼 수 있는 길고양이 즉, 코리안 숏헤어만 고양이로 학습시킨다면, 고양이는 털이 짧고, 얼굴이 동그랗고, 귀가 뾰족하며, 주황색, 흰색, 회색, 검은색 털을 갖는다라고 패턴을 익혀버릴 수 있다. 이러한 경우, 털이 길거나, 귀가 둥글거나, 접혀있는 다른 종류의 고양이들을 다른 동물로 인식할 수 있다.

2.1. 데이터의 양과 대표성

샘플링 잡음(Sampling noise): 데이터의 양이 매우 적다면, 대표성이 매우 적은 데이터만 뽑힐 확률이 높아진다. 고양이 사진 10,000장보다 고양이 사진 100장에 털이 짧은 고양이 사진만 뽑힐 확률이 매우 높기 때문이다.
샘플링 편향(Sampling bias): 데이터의 양이 많다고해서, 반드시 대표성이 높은 것은 아니다. 10,000장의 고양이 사진에 털이 짧은 고양이 사진이 9,500장, 500장에만 털이 긴 고양이 사진이 들어갈 가능성도 있기 때문이다.
물론, 추출한 데이터의 양이 매우 많고, 데이터를 생성하는 방법에도 이상이 없는 경우, 위와 같은 문제가 발생할 가능성은 크게 낮아진다.
예를 들어, 어떤 TV 프로를 즐겨보는지 설문 조사를 할 때, 유치원생들만을 대상으로 한다면, 한국인들은 뽀로로와 핑크퐁을 굉장히 좋아하는 특이한 사람들이라고 판단할 위험이 있으며, 면접을 보는 사람들을 대상으로 학업 성적에 대해 설문 조사를 하면, 자신에게 불이익이 갈까 봐 응답을 하지 않거나, 거짓 대답을 할 가능성이 있다.

3. 품질이 낮은 훈련 데이터

훈련 데이터에 결측값(Missing value)이나 이상 값(Outlier) 등이 굉장히 많이 존재한다면, 머신러닝을 통해 제대로 된 패턴을 찾아내지 못할 수 있다.
예를 들어, 수질 검사기의 센서에 수중 식물이나 오염 물질이 붙어 있어, 실제 수치와 전혀 다른 결과가 생성될 수 있다.
혹은, 키를 적는 문항에 몸무게를 적거나, 손으로 쓴 설문 문항을 전산화하는 과정에서 180을 1800이라고 잘못 입력할 수도 있다.
때문에 데이터 분석가는 분석을 하기 전에, 결측값이나 이상 값들이 발생한 이유를 파악하고, 측정 도구의 신뢰도 검사를 통해, 제대로 된 데이터가 수집되고 있는지 파악하고, 그 성격에 맞는 조치를 취해야 한다.
예를 들어, 결측값이 발생한 이유가 어떤 의도에 의해 발생하여, 결측 값에 숨겨진 패턴이 존재할 가능성이 높다면, 설문조사를 재실시해 누락된 부분을 채워 넣거나, 그 양이 매우 적으며 단순 실수에 의해 발생한 결측 값이라면, 일괄 제거 혹은 다중 대체법(Multiple Imputation) 등으로, 누락된 결측 값을 추론하여 계산할 수도 있다.

4. 관련 없는 특성이 들어가 있는 경우

Garbarge in, garbage out - "쓰레기가 들어가면 쓰레기가 나온다."

정보통신분야에서 유명한 위 문구는 머신러닝 분야에서도 그대로 통용된다.
고양이 사진을 이용해서 고양이를 학습시키려고 하는데, 쓸 데 없이 모든 고양이 사진에 화분이 들어가 있다면, 화분을 중요한 패턴으로 인식할 수 있다.
때문에 훈련 데이터에는 관련 없는 특성을 최소화시키고, 관련 있는 특성을 최대화할 필요가 있다.

4.1. 특성 공학(Feature engineering)

머신러닝을 포함한 모든 데이터 분석에서 가장 중요한 부분은 전처리로, 훈련에 사용할 좋은 특성을 찾는 과정을 특성 공학이라고 한다.
특성 선택(Feature selection): 전체 특성 중 훈련에 가장 유용한 특성을 선택한다.
특성 추출(Feature extraction): 특성을 결합하여 더 유용한 특성을 만들어낸다. 특성 간 성격을 이용하여, 특성의 정보를 축소시킬 수도 있고, 차원축소(PCA) 알고리즘을 사용하여 특성을 추출할 수도 있다.

5. 훈련 데이터 과대적합(Overfitting)

과대적합(Overfitting)은 훈련 데이터에 대해 지나치게 최적화되어, 훈련 데이터는 잘 분류하지만, 새로운 데이터는 제대로 분류하지 못하는 현상을 말한다.
과대적합은 데이터의 양이 적거나, 편향되어 있는 경우, 필요 이상으로 학습을 시키는 경우(Epochs가 필요치 보다 큰 경우), 주로 발생한다.
예를 들어, 훈련 데이터의 모든 고양이 사진의 고양이 목에 리본이 달려 있다면, 목에 리본이 없는 고양이들을 고양이가 아니라고 분류할 가능성이 올라간다.

5.1. 과대적합을 피하는 방법

과대적합은 훈련 데이터에 있는 잡음의 양에 비해 모델이 너무 복잡할 때 발생한다. 이를 해결하는 방법은 다음과 같다.
규제(Regularization)를 사용하여 모델을 단순화시키거나, 모델 파라미터의 수가 적은 보다 단순한 모델을 사용한다.
훈련 데이터에 있는 특성의 수를 차원축소(PCA)와 같은 방법으로 줄인다.
훈련 데이터의 잡음을 줄인다(오류 데이터 수정 및 이상치 제거).
훈련 데이터를 더 많이 모은다.

6. 훈련 데이터 과소적합(Underfitting)

과소적합은 과대적합의 반대로 모델이 너무 단순해서 학습 데이터에 숨겨진 패턴을 제대로 찾아내진 못한 경우이다.

6.1. 과소적합을 피하는 방법

모델 파라미터의 수가 더 많은 강력한 모델을 사용한다.
보다 더 좋은 특성을 제공한다.
규제의 양을 줄인다.

[참고 서적]

지금까지 머신러닝 시 주의 사항에 대해 알아보았다. 머신러닝은 기본적으로 데이터를 이용해서, 데이터 속에 숨어 있는 패턴을 찾아내는 것이므로, 데이터의 품질이 떨어지거나, 데이터의 양이 지나치게 적은 경우, 그 역할을 제대로 해낼 수 없다.

데이터 분석에서 제일 중요한 것은 데이터의 품질 관리이므로, 데이터에 대한 파악과 사용하고자 하는 머신러닝 알고리즘에 대한 지식이 선행되어야만, 머신러닝을 사용한 데이터 분석을 제대로 수행할 수 있다.

머신러닝-1.3. 사례 기반 학습과 모델 기반 학습

만년필잉크 — Fri, 19 Mar 2021 12:18:23 +0900

사례 기반 학습과 모델 기반 학습

지난 포스트에서는 데이터의 양, 분석 환경 등에 따라 학습 방법을 달리하는 배치 학습과 온라인 학습에 대해 알아보았다.

이번 포스트에서는 머신러닝 모델이 새로운 데이터가 들어왔을 때, 학습된 내용을 기반으로 어떤 방식으로 일반화(Generalize)하는지에 따라 분류되는 "사례 기반 학습"과 "모델 기반 학습"에 대해 알아보도록 하겠다.

1. 사례 기반 학습(Instance-based learning)

사례 기반 학습은 말 그대로 학습된 사례들을 기억하는 것으로, 시스템이 훈련 데이터를 기억함으로써 학습한다.
새로운 데이터가 들어오는 경우, 학습된 데이터(일부 또는 전체)와 새로운 데이터의 유사도를 측정하여, 입력된 새로운 데이터를 가장 유사도가 높은 기존 학습 데이터의 클래스로 분류한다.
유사도 측정(Similarty measurement)은 데이터에 따라 약간 다르게 진행되며, 텍스트 데이터가 대상인 경우, 공통으로 포함된 단어의 수를 기반으로 분류한다.
예를 들어, 스팸 메일과 공통으로 포함된 단어가 많은 경우, 스팸 메일로 분류한다.

2. 모델 기반 학습(Model-based learning)

모델 기반 학습은 데이터 셋에 적합한 모델을 사용하여 모델을 만들고, 모델을 이용하여 새로운 데이터를 어떻게 분류할지 예측(Prediction)한다.
모델 기반 학습은 데이터 셋에 따라 사용되는 모델이 다르므로, 데이터 셋에 적합한 모델을 찾는 모델 선택(Model selection) 과정이 필요하다.
모델에는 다양한 모델 파라미터(Model parameter)가 존재하며, 데이터에 최적화되는 모델 파라미터를 찾아내는 것이 모델 훈련(Training)이다.
학습 데이터 셋을 훈련시키는 과정에서 선택된 모델의 성능이 얼마나 좋은지를 "적합도 함수(Fitness function, 효용 함수 - Utility function)"로 평가할 수 있으며, 얼마나 나쁜지에 대해서는 "비용 함수(Cost function, 손실 함수 - loss function)"로 평가할 수 있다.
모델 파라미터는 일반적으로 손실 함수를 최소화시키는 방향으로 진행되며, 손실 함수를 최소화시키는 파라미터를 찾는 과정을 훈련(Training)이라 한다.
모델 파라미터는 머신러닝 모델이 학습 과정에서 찾아가는 파라미터이며, 사용자가 직접 설정해주는 학습률(Learning rate) 같은 파라미터는 모델 파라미터와 구분하기 위해, 하이퍼 파라미터(Hyper parameter)라고 한다.
모델 기반 학습은 다음과 같이 진행된다.

데이터 분석
데이터에 적합한 모델 선택
훈련 데이터(Training data)로 모델 훈련 - 비용 함수를 최소화하는 모델 파라미터 탐색
학습이 끝난 모델에 새로운 데이터를 적용해 예측(Predict) - 학습 데이터로 학습된 모델을 이용해서 학습 데이터와 분리된 시험 데이터(Test data)가 얼마나 잘 예측되는지를 본다.

모델 학습 기반은 모델에 종속되어 새로운 데이터를 추론하므로, 모델이 적합하지 않거나, 데이터가 부족한 경우 더 좋은 모델을 탐색해야 하고, 그 모델에 맞는 데이터를 더 수집해야 한다.
모델의 코드 작성 난이도는 낮지만, 그 모델이 구동되는 정확한 원리를 이해하지 못한다면, 제대로 된 결과를 도출하지 못할 가능성이 높다.

[참고 서적]

지금까지 사례 기반 학습과 모델 기반 학습에 대해 알아보았다. 사례 기반 학습과 모델 기반 학습 모두 데이터를 기반으로 하지만, 사례 기반 학습은 데이터에서 찾아낸 특정 패턴이 얼마나 유사한지(동일 패턴이 얼마나 많이 등장하는지)에 따라 분류를 하고, 모델 기반 학습은 수많은 머신러닝 모델의 모델 파라미터를 데이터에 맞게 만들어 예측을 한다.

추후 학습하게 될 머신러닝 모델들은 모두 모델 기반 학습이므로, 사례 기반 학습보다는 모델 기반 학습을 눈여겨보도록 하자.

머신러닝-1.2. 배치 학습과 온라인 학습

만년필잉크 — Mon, 15 Mar 2021 19:37:52 +0900

배치 학습과 온라인 학습

지난 포스트에서는 학습 데이터를 어떻게 입력하는지에 따라 분류되는 지도 학습, 비지도 학습, 준지도 학습, 강화 학습에 대해 알아보았다.

이번 포스트에서는 실시간으로 학습이 가능한지 여부에 따라 나뉘는 배치 학습과 온라인 학습에 대해 알아보도록 하겠다.

1. 배치 학습(Batch learning)

배치 학습은 한번에 모든 훈련 데이터를 학습시키는 방법으로, 시간과 자원을 많이 소모하므로, 일반적으로 오프라인 환경에서 수행되므로, 오프라인 학습(Offline learning)이라고도 한다.
학습은 런칭 전에 일어나고, 제품에 학습된 내용을 적용하면, 더 이상의 학습 없이 사용만 된다.
새로운 데이터가 등장하여, 머신을 재학습 하고자 하는 경우, 이전 데이터에 새로운 데이터를 포함한 전체 데이터를 학습시키고, 학습된 새로운 모델을 사용해야 한다.

이전 포스트("머신러닝-1.0. 전통적인 기법과 머신러닝의 차이")에서 말한 것처럼 새로운 패턴에 대하여 자동화 하는 경우, 주기적으로 자동적으로 재학습을 할 수 있다.
그러나, 빅데이터에 대하여, 머신러닝 알고리즘을 사용하는 경우, 그 데이터의 양이 지나치게 많기 때문에 학습 시간이 작게는 몇 시간에서 길게는 몇 주, 한 달 이상의 시간이 소모될 수도 있기 때문에 쉬운 작업은 아니다.
데이터의 양이 매우 많아 학습 시간이 지나치게 길거나, 탐사 로봇 같이 자원이 지나치게 한정된 상황, 주식 가격표 같은 실시간 반영이 필요한 상황에서는 배치학습이 아닌 능동적인 학습이 필요하다.

2. 온라인 학습(Online learning)

온라인 학습은 일반적으로, 학습이 끝나 제품화가 된 모델에 대하여, 미니배치(Mini-batch)라 부르는 작은 묶음 단위의 데이터를 주입하여 모델을 학습시키는 방법이다.
미니 배치의 크기가 작기 때문에 학습 단계가 빠르고 비용이 적게 들기 때문에 모델은 데이터가 도착하는 대로 즉시 학습을 할 수 있다.
점진적으로 학습이 일어나기 때문에 점진적 학습(Incremental learning)이라고도 하며, 온라인 학습은 오프라인으로도 시행되기도 하므로(외부 메모리 학습), 온라인 학습이라는 용어보다 점진적 학습이 정확한 명칭이라 할 수 있다.
온라인 학습은 연속적으로 데이터를 받고 빠른 변화에 스스로 적응해야 하거나, 자원이 매우 한정된 환경에 적합하다.
온라인 학습 모델은 새로운 데이터 샘플을 학습하면, 학습이 끝난 데이터는 더 이상 필요하지 않기 떄문에 보관하지 않아도 되므로, 저장 공간을 많이 아낄 수 있다.

2.1. 외부 메모리 학습(Out-of-core learning)

빅 데이터 분석 시, 데이터의 양이 지나치게 커서, 컴퓨터의 메모리로 감당되지 않는 경우가 종종 있으며, 이때에도 온라인 학습 알고리즘이 사용된다.
데이터 일부를 읽어 들여 머신러닝 알고리즘이 학습하며, 전체 데이터가 모두 적용될 때까지 일부를 학습하는 과정을 반복한다.
온라인 학습 모델에서는 학습률(Learning Rate)이 가장 중요한 하이퍼 파라미터로 작동하며, 이는 모델이 변화하는 데이터에 얼마나 빠르게 적응할지를 이야기한다.
학습률이 높은 경우, 시스템이 데이터에 빠르게 적응하나, 과거의 데이터를 금방 잊는다.
학습률이 낮은 경우, 시스템의 관성이 커져 더 느리게 학습되지만, 노이즈나 대표성이 없는 데이터 포인트에 덜 민감해진다.

2.2. 온라인 학습의 문제점

나쁜 데이터가 주입되었을 때, 시스템의 성능이 점진적으로 감소하게 된다.
예를 들어, 실시간 추천 알고리즘에서 누군가가 자신이 만든 콘텐츠나 제품을 상위에 노출시키고자, 자신의 의도를 담은 데이터를 다량 생성할 수 있다. 이 경우, 모델은 이 데이터를 학습하여, 실제 알고리즘에서 노출시키고자 대상이 아닌, 누군가가 의도적으로 생성한 데이터를 노출시킬 수 있다.
때문에, 온라인 학습에서는 시스템을 지속적으로 모니터링하고, 성능 감소가 감지되면, 즉시 학습을 중지시키고, 성능 감소가 이루어지기 전 상태로 되돌려야 한다.
또는 이상 감지 머신러닝 알고리즘을 데이터 수집 앞에 넣어, 비정상 데이터가 온라인 학습 모델에 들어가지 않게 막을 수도 있다.

[참고 서적]

지금까지 배치 학습과 온라인 학습에 대해 알아보았다. 배치 학습은 일반적인 머신러닝 알고리즘 학습 방법이나, 수많은 환경(특히 빅데이터를 사용하는 환경)에서 배치 학습을 사용하지 못하는 경우가 많다. 이런 경우에는 온라인 학습 방법을 사용하지 않는다면, 제대로 된 학습을 하지 못할 수 있다.

머신러닝-1.1. 지도 학습 & 비지도 학습 & 준지도 학습 & 강화 학습

만년필잉크 — Mon, 15 Mar 2021 17:58:20 +0900

지도 학습 & 비지도 학습 & 준지도 학습 & 강화 학습

지난 포스트에서는 전통적인 프로그래밍 기법과 머신러닝 기법을 직접 비교해보았다. 이번 포스트에서는 머신러닝 시스템에서 사람이 감독을 하는지 하지 않는지에 따라 나뉘는 지도 학습, 비지도 학습, 준지도 학습, 강화 학습이 무엇인지 알아보도록 하겠다.

지도, 비지도, 준지도, 강화 학습은 사람의 감독 형태가 어떠한지와 정보량에 따라 구분된다.

1. 지도 학습(Supervised Learning)

지도 학습에는 답지인 레이블(Label) 데이터가 필요하다.
지도 학습의 대표적인 예는 분류(Classification)로, 숫자 손글씨 인식 모델을 만드는 경우, 손으로 쓴 숫자에 해당하는 클래스(Class) 0, 1, 2, 3,..., 9를 레이블로 붙이고, 머신은 각 레이블에 대한 패턴을 학습한다. 새로 들어온 데이터가 특정 클래스에 속하는 패턴을 가지고 있는 경우, 각 클래스에 속할 확률을 계산한다.
또는, 사진을 바탕으로, 고양이를 인식하는 모델을 만들기 위해, 고양이 사진에는 고양이라는 의미로 0으로 범주화(Class) 하고, 나머지는 고양이가 아니다는 의미로 1로 범주화한다.
통계분석의 꽃인 회귀분석(Regression Analysis)은 대표적인 지도 학습 방법 중 하나이다. 독립변수(Independent variable)인 성별, 하루 평균 운동 시간, 식사량, 간식 섭취량, 음료수 섭취량 등이 종속변수(Dependent variable)인 체질량지수(BMI)에 영향을 주는 정도를 학습하여, 체질량지수 모델을 만들어낼 수도 있다.
대표적인 지도 학습 알고리즘은 다음과 같다.

K-최근접 이웃(K-nearest neighbors)
선형 회귀(Linear ragression)
로지스틱 회귀(Logistic regression)
서포트 벡터 머신(Support vector machine, SVM)
의사 결정 나무(Decision tree)와 랜덤 포레스트(Random forest)
신경망(Neural networks)

2. 비지도 학습(Unsupervised learning)

훈련 데이터에 레이블 데이터가 없이 학습을 진행하므로, 머신은 어떤 도움 없이 학습을 해야 한다.
비지도 학습은 크게 3개 알고리즘에 특화되어 있다.

군집화(Clustering)
시각화와 차원 축소(Visualization & Dimensionality reduction)
연관 규칙 학습(Association rule learning)

2.1. 군집화(Clustering)

군집화는 데이터에 있는 패턴을 찾고, 그 패턴을 기반으로 n개의 집단으로 데이터를 나눈다.
예를 들어, 특정 온라인 쇼핑몰에 방문하는 사람의 메타 데이터를 이용하여, 군집화를 실시한다면, 해당 온라인 쇼핑몰의 시간대별 방문자의 특징을 이용해, 각 집단이 선호하는 것에 대해 마케팅을 할 수 있다.
대표적인 알고리즘은 다음과 같다.

k-평균(k-means)
DBSCAN
계층 군집 분석(Hierarchical cluster analysis, HCA)
원-클래스 서포트 벡터 머신(One-class SVM)
아이솔레이션 포레스트(Isolation forest)

2.1.1 이상치 탐지와 특이값 탐지(Outlier detection & Novelty detection)

이상치 탐지(Outlier detection): 학습 시, 대부분의 데이터를 정상 데이터로 입력하여(모든 데이터를 정상 데이터로 사용하는 것보다. 소량의 이상치 데이터를 섞어 넣는 것이 보다 좋은 결과를 낸다는 이슈가 있다), 새로 입력된 데이터가 정상 데이터로부터 벗어나는 경우, 이상치로 탐지한다.
특이값 탐지(Novelty detection): 모든 데이터를 특이값이 아닌 데이터로 학습시켜, 새로운 데이터가 들어갔을 때, 학습되지 않은 데이터가 들어간다면, 이를 특이값으로 탐지한다. 예를 들어, 시내에서 돌아다니는 사람들에 대해 학습을 하는 경우, 인형탈을 쓰고 돌아다니는 사람을 제외하고 학습을 시킨다면, 인형탈을 쓰고 돌아다니는 사람을 인식했을 때, 다른 사람들과 크게 다른 특이값으로 탐지하게 된다.
이상치 탐지와 특이값 탐지는 학습 데이터에서 벗어나는 대상을 탐지하는 것이므로, 이 역시 전체 군집과 그 밖의 군집으로 나누는 군집화라고 할 수 있다.

2.2. 시각화와 차원 축소(Visualization & Dimensionality reduction)

시각화(Visualization): 레이블이 존재하지 않는 대규모의 고차원 데이터를 입력하면, 도식화가 가능한 2D나 3D 표현을 만들어내며, 해당 알고리즘은 가능한 구조를 그대로 유지(입력 공간에서 떨어져 있던 클러스터는 시각화된 그래프에서 겹쳐지지 않게 유지된다.)하려고 하기 때문에 데이터가 어떻게 조직되어 있고, 예상하지 못했던 패턴의 존재 등을 탐색할 수 있다.
차원 축소(Dimensionality reduction): 정보의 손실을 최소화시키면서, 데이터를 간소화시키는 것으로, 관련이 깊은 특성을 하나로 합치는 작업이다.
주어진 특성을 조합해 새로운 특성을 생성하므로 특성 추출(Feature extraction)이라고도 한다.
시각화와 차원 축소 모두, 전체 데이터에서 정보 손실을 최소화하면서, 데이터를 간소화시키는 과정이 존재하기 때문에 상당히 유사하다.
대표적인 알고리즘은 다음과 같다.

주성분 분석(Principal component analysis, PCA)
커널 주성분 분석(Kernel PCA)
지역적 선형 임베딩(Locally-Linear embedding, LLE)
t-SNE(t-distributed stochastic neighnor embedding)

2.3. 연관 규칙 학습(Assiciation rule learning)

대량의 학습 데이터에서 특성(Feature) 간 관계를 찾아내는 것이다.
예를 들어, 마트에서 치킨이나 감자튀김 같은 기름진 음식을 구매한 사람은 맥주를 구매하는 경향이 있으므로, 고객의 동선에 맥주와 맥주 안주거리를 순차적으로 배치할 수 있다.
대표적인 알고리즘은 다음과 같다.

어프라이어리(Apriori)
이클렛(Eclat)

3. 준지도 학습(Semisuplervised learning)

데이터에 레이블을 다는 것은 시간과 비용이 매우 많이 드는 작업이기 때문에 레이블이 있는 샘플을 찾는 것은 쉽지 않다. 준지도 학습은 지도 학습과 비지도 학습의 사이에 있는 학습 방법으로, 레이블이 존재하는 데이터와 존재하지 않는 데이터 모두를 훈련에 사용하는 것이다.
레이블이 없는 다량의 데이터에 적은 양의 레이블이 존재하는 데이터를 포함시키는 경우, 학습 정확도가 개선되는 경향이 있다고 한다.
사용자가 올린 사진을 자동으로 정리해주는 구글 포토(Google Photo)가 대표적인 예로, 사람들이 다량의 사진을 올리는 경우, 학습된 패턴을 이용해 사진들을 군집화하고, 사진에 등장한 사람들에 대해 Labeling을 해주면, 특정 인물이 있는 사진들만 찾을 수도 있다.
대부분의 준지도 학습 알고리즘은 지도 학습과 비지도 학습 알고리즘의 조합으로 이루어져 있으며, 대표적인 준지도 학습인 심층 신뢰 신경망(Deep belief networks, DBN)은 제한된 볼츠만 머신(Restricted Boltzmann machine, RBM)을 기반으로 순차적으로 학습한 후, 지도 학습 방식으로 세밀하게 조정된다.

4. 강화 학습(Reinforcement learning)

강화 학습은 지도 학습, 비지도 학습과 상당히 다른 알고리즘으로, 학습하는 머신을 에이전트(Agent)라 부르고, 환경(Environment)을 관찰해 행동(Action)을 실행하고, 그 결과로 보상(Reward)이나 벌점(Penalty)을 받는다.
강화 학습은 시간이 지나면서 가장 큰 보상을 얻기 위해, 정책(Policy)이라 부르는 최상의 전략을 스스로 학습한다.
정책은 주어진 상황에서 에이전트가 어떤 행동을 선택해야 할지 정의한다.
강화 학습은 딥러닝이라는 단어를 전 세계에 알린 딥마인드(DeepMind)의 알파고(AlphaGo)에서 사용되었다.

[참고 서적]

지금까지 머신러닝의 학습 방식에 따른 차이인 지도 학습, 비지도 학습, 준지도 학습, 강화 학습에 대해 가볍게 알아보았다. 다음 포스트에서는 모델이 점진적으로 학습을 할 수 있는지 여부에 대하여, 머신러닝을 분류하는 배치 학습과 온라인 학습에 대해 알아보도록 하겠다.

머신러닝-1.0. 전통적인 기법과 머신러닝의 차이

만년필잉크 — Sun, 14 Mar 2021 18:13:17 +0900

머신러닝이란?

앞서 인공지능, 머신러닝, 딥러닝에 대해 간략하게 언급해보았다. 해당 내용만으로는 앞으로 우리가 학습해나갈 머신러닝에 대해 구체적으로 알기 어려우므로, 이번에는 전통적인 알고리즘과 머신러닝 알고리즘을 직접 비교해보도록 하겠다.

명시적인 프로그래밍 없이 컴퓨터가 학습하는 능력을 갖추게 하는 연구 분야
- 아서 새뮤얼(Arthur Samuel), 1959 -

어떤 작업 T에 대한 컴퓨터 프로그램의 성능을 P로 측정하였을 때, 경험 E로 인해 성능이 향상됐다면, 이 컴퓨터 프로그램은 작업 T와 성능 측정 P에 대해 경험 E로 학습한 것이다.
- 톰 미첼(Tom Mitchell) 1998 -

머신러닝(Machine Learning)이라는 용어를 만든 아서 새뮤얼은 머신러닝에 대해 컴퓨터가 학습하는 능력을 갖추게 하는 연구 분야라고 하였다. AI 분야의 권위자인 톰 미첼은 경험 E에 의해 어떤 작업 T의 성능을 측정한 P가 향상되게 하는 것이 머신러닝이라 했다.

머신러닝은 전통적인 프로그래밍 기법과 달리 데이터만을 가지고 그 안에서 패턴을 찾아낸다는 학습이라는 개념을 사용하여, 사용자가 원하는 목적을 이루어내는 것으로, 이번 포스트에서는 전통적인 프로그래밍 기법과 머신러닝 기법을 두고, 어째서 머신러닝 기법이 그토록 강조되고 있는지에 대해 알아보도록 하겠다.

0. 예시 및 용어 정리

예시 1. 우편에 쓰인 손글씨 인식 모델
예시 2. 이메일 이용자가 스팸 처리한 스팸 메일과 정상 메일 분류 모델

0.1. 용어 정리

훈련 데이터(Training data): 시스템을 학습시키는 데 사용하는 데이터
훈련 사례(Training instance): 각각의 훈련 데이터셋
정확도(Accuracy): 모델의 성능을 측정하는 도구

0.2. 톰 미첼의 정의와 연결

어떤 작업 T: 어떤 목적을 위해 만들어진 알고리즘
경험 E: 훈련 데이터
성능 측정 P: 알고리즘 작성자가 정의한 모델 성능 평가 도구 - 정확도(Accuracy)

1. 전통적인 프로그래밍 기법

A. 문제 연구

훈련 데이터(training data)에 대하여 통계 분석 방법, 특정 집단에서 공통적으로 발생하는 패턴을 파악한다.
"예시 1. 손글씨"의 경우, 손 글씨를 텐서화하고, 그 텐서에서 각 글자마다 각 Row에서 수치들이 어디서 등장하는지. 수치가 흩어진 정도를 이용하여, 각 글자의 경향성을 찾아냈다.
"예시 2. 스팸 메일"의 경우, 사용자가 스팸 메일 처리한 메일들에서 "무료", "기회", "굉장한", "대단한"과 같은 특정 단어가 메일의 제목이나 본문에서 자주 등장하는 경향이 있다.

B. 규칙 작성

문제 연구에서 찾아낸 패턴을 바탕으로, 알고리즘을 만들어낸다.
"예시 1. 손글씨"의 경우, 앞에서 찾아낸 각 글자의 경향성을 기반으로, 그 패턴에 속하는 경우 해당 단어로, 속하지 않는 경우, 가장 가까운 패턴에 해당하는 단어를 찾아낸다.
"예시 2. 스팸 메일" 스팸 메일에서 주로 발생하는 단어들이 제목이나, 본문에서 등장하는 경우, 이를 스팸 메일로 분류한다.

C. 평가

훈련 데이터를 기반으로 만든 알고리즘에 시험 데이터(Test data)를 넣었을 때, 실제 분류와 어느정도 일치하는 분류가 나오는지 확인한다.

1.1. 전통적인 프로그래밍 기법의 한계점

연구자가 찾아낸 패턴은 표면적인 패턴일 가능성이 매우 높으므로, 반례가 존재할 가능성이 매우 높으며, 그 반례의 양도 많아, 이들을 하나하나 해결하다 보면 코드도 길어지고, 복잡해진다.
새로운 패턴을 갖는 데이터 셋이 추가 되면, 기존에 해결했던 반례가 되려 문제를 일으키거나, 새로운 반례가 생기는 등 알고리즘에 단순하게 반영하기가 매우 어렵다.
즉, 유지보수 난이도가 매우 높다(산출물 관리를 아주 아주 잘해야 한다.)

2. 머신러닝 접근 방법

머신러닝은 데이터를 기반으로 하여, 머신러닝 알고리즘 스스로 패턴을 찾아낸다.
물론, 알고리즘이 그 패턴을 제대로 찾아내게 하기 위해서는 연구자가 패턴이 잘 드러나는 방향으로 전처리를 해줘야 한다.
(아무리 머신러닝 알고리즘의 성능이 뛰어나다 할지라도, 연구자가 그 알고리즘에 맞게 데이터를 세팅해주지 않는다면, 머신러닝 알고리즘의 성능을 전부 이끌어낼 수 없다.)
머신러닝 알고리즘 자체가 패턴을 찾아내기 때문에 사용자가 패턴을 찾아내는 과정이 따로 필요하지 않으며, 머신러닝 알고리즘은 데이터에서 연구자가 인식하지 못하는 패턴마저도 뽑아내므로, 정확도가 상당히 높다.
그러나, 머신러닝 알고리즘이 분류한 것에 대하여 연구자가 인식하는 것은 불가능에 가깝기 때문에 분류 과정에 대해 설명할 수 없다.

2.1. 새로운 패턴이 등장하는 경우

"예시 2. 스팸 메일"의 경우, "무료", "기회", "굉장한", "대단한"과 같은 특정 단어가 들어간 메일이 자동 스펨 처리되는 것을 눈치챈 발송자가 해당 단어를 사용하지 않고 "Free", "흔치않은", "오늘만"과 같은 기존 사전에 없던 단어를 이용할 수 있다.
또는, "F.R.E.E", "!기!회!", "!@!기!@! 오.늘!! !@!무.료!@! !@!회!@!" 같이 정규표현식이나, 비교적 단순한 알고리즘으로 잡기 어렵게 패턴에 노이즈를 주어 스펨 메일을 보낼 수도 있다.
머신러닝 알고리즘 기반으로 이를 해결하는 경우엔, 머신러닝 알고리즘 스스로 스펨 메일에 자주 등장하는 패턴을 찾아내 해당 패턴이 등장하는 경우를 스펨 처리하므로, 새로운 규칙을 추가하지 않고 동일한 모델로 패턴을 찾아낼 수 있다.
(물론, 머신이 노이즈를 잘 인지할 수 있도록, 전처리를 해줘야 한다.)

2.2. 전통적인 방식에는 없는 알고리즘이 필요한 경우

"예시 1. 손글씨 인식"의 경우, 텐서의 Row 별로 수치가 변하는 위치와 편차를 이용해서 구해보겠다고 하였다. 그러나 해당 방법은 사람마다 손글씨의 차이가 매우 크기 때문에 제대로 작동하기 힘들 가능성이 높다.
머신러닝, 그중에서도 딥러닝의 CNN을 이용한다면, 이미지 데이터의 특징 자체를 찾아낼 수 있다.
즉, 전통적인 알고리즘은 특정 상황에 맞는 특정 알고리즘을 써야 하지만, 머신러닝을 사용하는 경우, 데이터 성격에 맞는 머신러닝 알고리즘을 사용하면, 수치로 표현하기 힘든 특징도 찾아낼 수 있다.

2.3. 데이터 마이닝(Data Mining)

연구자는 머신러닝을 통해 그동안 알지 못했던 새로운 사실을 알 수도 있다.
빅데이터를 사용하여 머신러닝 알고리즘을 훈련하는 경우, 기존에 노이즈인지 알고 제거했던 데이터에서 패턴이 존재한다는 것을 알 수 있다.
또는, 어떤 패턴이 분류에서 가장 결정적인 역할을 했는지 찾아낼 수도 있다.

2.4. 머신러닝의 장점 정리

전통적인 프로그래밍 기법보다 머신러닝 모델의 코드가 간단하며, 유지보수가 쉽다.
전통적인 알고리즘의 반례로 인한 알고리즘 복잡도 증가가 없다.
전통적인 방식으로 해결할 수 없는 문제도 해결할 수 있다.
데이터의 변화에 쉽게 적응할 수 있다.
복잡한 문제와 대량의 데이터를 통해 그간 알지 못했던 아이디어를 얻을 수 있다.

[참고 서적]

지금까지 전통적인 프로그래밍 기법과 머신러닝의 차이점에 대해 알아보았다. 다음 포스트에서는 지도 학습과 비지도 학습, 준지도 학습, 강화 학습에 대해 알아보도록 하겠다.

대푯값과 비대칭도, 왜도(Skewness), 첨도(Kutosis)

만년필잉크 — Thu, 11 Mar 2021 01:56:49 +0900

대푯값(Representative value)과 비대칭도(Skewness)

앞서 학습였던, 중앙값(Median), 최빈값(Mode), 평균(Mean) 등과 같은 대푯값과 표준편차(Standard Deviation)를 사용하면, 데이터가 대략 어떻게 생겼는지를 파악할 수 있다.

이번 포스트에서는 대푯값이 무엇인지, 대푯값을 사용하여 어떻게 데이터의 형태를 파악할 수 있는지에 대해 알아보도록 하자.

1. 대푯값(Representative value)

대푯값은 말 그대로 어떠한 데이터를 단 하나의 값으로 표현할 수 있는 값을 말한다.
데이터 어디에 모여있는지(중심경향치): 평균(Mean), 중앙값(Median), 최빈값(Mode), 절사 평균(Trimmed mean)
데이터를 정렬하고 일정 크기로 나눴을 때의 간격 점: 사분위수(Quartile), 백분위수(Percentile)
정상 범위에서 벗어난 값: 이상값(Outlier)
확률상 기대되는 대푯값: 기댓값(Expected value)

1.1. 대푯값을 이용하여, 데이터의 대략적인 분포를 알 수 있다.

산포도는 대푯값이 아니지만, 대푯값을 이용해서 산포도를 알 수도 있다.
사분위수를 이용하면, 사분위 범위를 알 수 있고, 사분위 범위를 알면, 상자 수염 그림(Box-and-Whisker plot)을 그릴 수 있다.
평균과 중앙값, 최빈값을 이용하여, 데이터의 대략적인 개형을 알 수 있다.

2. 대푯값을 이용한 데이터의 대략적인 개형 알아보기

집중화 경향치인 평균, 중앙값, 최빈값은 데이터 분포에 따라 아래와 같은 경향을 갖는다.

위 그림은 조금 과장을 한 것이긴 하지만, 데이터는 위와 같은 경향을 띄며, 그 이유는 다음과 같다.

최빈값: 가장 많이 등장한 관찰 값이 최빈값이 된다.
중앙값: 관찰 값의 빈도에 상관없이 무조건 가운데에 위치한다.
평균: 이상치의 영향을 크게 받는다.

간단한 도수분포표를 만들어서, 실제로는 어떻게 돌아가는지 확인해보자.

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

# 부드러운 그래프를 그린다.
from scipy.interpolate import make_interp_spline

plt.rc('font', family='NanumGothic')

# 최빈값, 중앙값, 평균 계산
def Rep_V(data, column):

    raw_list = []

    for i in range(len(data)):

        X_list = [data.loc[i, "X"]] * data.loc[i, column]
        raw_list = raw_list + X_list

    median = np.median(raw_list)
    mean = np.mean(raw_list)
    std = np.std(raw_list)
    mode = np.bincount(raw_list).argmax()

    return mode, median, mean, std



# 그래프 그리기
def draw_Ske(data, column, title):
    """
    도수분포다각형을 부드럽게 그리고, 최빈값, 중앙값, 평균을 점으로 찍고, 선을 그린다.
    """
    x = data["X"].to_numpy()
    y = data[column].to_numpy()

    fig = plt.figure(figsize=(10, 6))

    # 부드러운 그래프를 그린다.
    model=make_interp_spline(x,y)
    xs=np.linspace(np.min(index_list),np.max(index_list),100)
    ys=model(xs)

    plt.plot(xs, ys)

    # 최빈값, 중앙값, 평균 그리기
    mode, median, mean, std = Rep_V(data, column)
    plt.scatter(mode, 1, c = "r", s = 100)
    plt.axvline(x=mode, c = "r", linewidth = 1, alpha = 0.5)
    plt.annotate('최빈값', xy=(mode+1, 1), xytext=(mode + 10, 0.5), fontsize = 15,
                 arrowprops=dict(facecolor='black', width=1, headwidth=8))

    plt.scatter(median, 3, c = "g", s = 100)
    plt.axvline(x=median, c = "g", linewidth = 1, alpha = 0.5)
    plt.annotate('중앙값', xy=(median+1, 3), xytext=(median + 10, 3.2), fontsize = 15,
                 arrowprops=dict(facecolor='black', width=1, headwidth=8))

    plt.scatter(mean, 5, c = "y", s = 100)
    plt.axvline(x=mean, c = "y", linewidth = 1, alpha = 0.5)
    plt.annotate('평균', xy=(mean+1, 5), xytext=(mean + 10, 6), fontsize = 15,
                 arrowprops=dict(facecolor='black', width=1, headwidth=8))



    plt.title(title, fontsize = 20, pad = 15)
    plt.xlabel("$X$", fontsize = 15, labelpad = 10)
    plt.ylabel("$f$", rotation = 0, fontsize = 15, labelpad = 10)
    plt.show()

함수 Rep_V(data, column)는 도수분포표를 본래 데이터 셋으로 되돌리고, 최빈값, 중앙값, 평균과 같은 대푯값을 계산하는 함수다.
데이터의 양이 지나치게 많아, 컴퓨터가 이를 감당하지 못하는 경우에는 의도적으로 도수분포표를 만들어 대푯값을 계산할 수도 있으나, 위와 같이 데이터의 양이 적은 경우, 도수분포표를 본래 데이터 셋으로 되돌리는 것이 더 쉽다.

index_list = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
freq1_list = [1, 3, 6, 11, 17, 24, 17, 11, 6, 3, 1]
freq2_list = [1, 2, 3, 6, 10, 14, 20, 25, 15, 3, 1]
freq3_list = [1, 3, 15, 25, 20, 14, 10, 6, 3, 2, 1]

DF = pd.DataFrame({"X":index_list, "f1":freq1_list, "f2":freq2_list, "f3":freq3_list})

DF

2.1. 대칭 분포

draw_Ske(DF, "f1", "1. 대칭분포")

대칭 분포인 경우, "평균 = 중앙값 = 최빈값"인 것을 볼 수 있다.

2.2. 왼쪽 꼬리 분포

draw_Ske(DF, "f2", "2. 왼쪽꼬리분포")

왼쪽 꼬리 분포인 경우, "평균 < 중앙값 < 최빈값"이 되는 것을 볼 수 있다.

2.3. 오른쪽 꼬리 분포

오른 꼬리 분포인 경우, "평균 > 중앙값 > 최빈값"이 되는 것을 볼 수 있다.

3. 피어슨의 비대칭 계수(Pearson's skewness coefficients)

칼 피어슨(Karl Pearson)이 만든, 피어슨의 비대칭 계수는, 위에서 본 분포가 좌, 우로 치우치는 경우 평균, 중앙값, 최빈값이 일정한 크기로 순서를 갖는 성질을 이용해서 만든 것이다.

피어슨의 비대칭 계수는 평균에 대하여, 최빈값이나 중앙값을 뺀 값을 표준 편차로 나눠서 구한다.
피어슨의 비대칭 계수를 구하는 방법은 크게 3가지가 있다.

◎ 피어슨의 제1 비대칭도 계수: $SK_1 = \frac{\bar{X} - mode}{S}$

◎ 피어슨의 제2 비대칭도 계수: $SK_2 = \frac{3(\bar{X} - mode)}{S}$

◎ 피어슨의 제3 비대칭도 계수: $SK_3 = \frac{3(\bar{X} - median)}{S}$

위 비대칭도 계수들은 평균과 다른 대푯값의 거리를 얼마나 민감하게 볼 것인가에 대하여 다르게 만들어진 것임을 볼 수 있다.
일반적으로 사용하는 것은 피어슨의 제3 비대칭도 계수다.
단순한 해석 방법은 3가지 모두 동일하다.

3.1. 피어슨의 비대칭 계수 보는 방법

비대칭도 계수가 0이 나오는 경우, 평균과 중앙값(최빈값)이 같으므로, 분포가 치우쳐지지 않음을 알 수 있다.
비대칭도 계수가 양수인 경우, 평균보다 중앙값이 작으므로, 오른쪽 꼬리 분포이다.
비대칭도 계수가 음수인 경우, 평균보다 중앙값이 크므로, 왼쪽 꼬리 분포이다.
비대칭도 계수가 클수록, 한쪽으로 치우친 정도가 크다는 소리다.
비대칭도 계수가 0~1 사이인 경우, 1 표준편차보다 분자(평균과 대푯값의 거리에 3을 곱한 값)가 작다는 의미이므로, 치우친 정도가 작다는 소리다.
이를 이용하여, 서로 다른 분포에 대하여, 치우친 정도를 비교할 수도 있다(표준편차로 나누었으므로, 단위도 사라진다.).

3.2. 파이썬으로 피어슨의 비대칭 계수를 구현해보자.

기존 도수분포표에 보다 치우친 새로운 도수를 추가하여 비교해보자.

index_list = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
freq1_list = [1, 3, 6, 11, 17, 24, 17, 11, 6, 3, 1]
freq2_list = [1, 2, 3, 6, 10, 14, 20, 25, 15, 3, 1]
freq3_list = [1, 3, 15, 25, 20, 14, 10, 6, 3, 2, 1]
freq4_list = [1, 1, 2, 3, 5, 7, 10, 16, 23, 26, 6]

DF = pd.DataFrame({"X":index_list, "f1":freq1_list, "f2":freq2_list, "f3":freq3_list, "f4":freq4_list})
DF

피어슨의 비대칭도 계수를 구하는 함수를 만들고, 각 변수의 도수들을 비교해보자.
각 칼럼의 최빈값, 중앙값, 평균, 표준편차를 출력해보자.

>>> for column in ["f1", "f2", "f3", "f4"]:

>>>     mode, median, mean, std = Rep_V(DF, column)
>>>     print(f"column: {column} \n 최빈값:{mode}, 중앙값: {median}, 평균: {mean}, 표준편차: {np.round(std,2)}")
>>>     print("----"*20)
    
    
column: f1 
 최빈값:50, 중앙값: 50.0, 평균: 50.0, 표준편차: 19.39
--------------------------------------------------------------------------------
column: f2 
 최빈값:70, 중앙값: 60.0, 평균: 58.8, 표준편차: 19.2
--------------------------------------------------------------------------------
column: f3 
 최빈값:30, 중앙값: 40.0, 평균: 41.2, 표준편차: 19.2
--------------------------------------------------------------------------------
column: f4 
 최빈값:90, 중앙값: 80.0, 평균: 71.9, 표준편차: 21.06
--------------------------------------------------------------------------------

1번부터 3번까지 피어슨의 비대칭 계수를 계산하는 함수를 만들고, 계수를 계산해보자.

def P_SK(data, column, key):
    
    mode, median, mean, std = Rep_V(DF, column)
    
    if key == 1:
        result = (mean - mode)/std
        
    elif key == 2:
        result = 3*(mean - mode)/std
        
    elif key == 3:
        result = 3*(mean - median)/std
        
    return result

>>> for column in ["f1", "f2", "f3", "f4"]:
    
>>>     print(f"column: {column}")
>>>     for key in range(1,4):
        
>>>         P_SK_value = P_SK(DF, column, key)
>>>         print(f"피어슨의 제 {key} 비대칭도 계수 = {np.round(P_SK_value, 4)}")
        
>>>     print("----"*20)


column: f1
피어슨의 제 1 비대칭도 계수 = 0.0
피어슨의 제 2 비대칭도 계수 = 0.0
피어슨의 제 3 비대칭도 계수 = 0.0
--------------------------------------------------------------------------------
column: f2
피어슨의 제 1 비대칭도 계수 = -0.5834
피어슨의 제 2 비대칭도 계수 = -1.7502
피어슨의 제 3 비대칭도 계수 = -0.1875
--------------------------------------------------------------------------------
column: f3
피어슨의 제 1 비대칭도 계수 = 0.5834
피어슨의 제 2 비대칭도 계수 = 1.7502
피어슨의 제 3 비대칭도 계수 = 0.1875
--------------------------------------------------------------------------------
column: f4
피어슨의 제 1 비대칭도 계수 = -0.8596
피어슨의 제 2 비대칭도 계수 = -2.5787
피어슨의 제 3 비대칭도 계수 = -1.154
--------------------------------------------------------------------------------

대칭 분포인 f1은 비대칭도 계수가 0이 나왔다.
왼쪽 꼬리 분포인 f2는 비대칭도 계수가 모두 음수가 나왔다.
오른쪽 꼬리 분포인 f3는 비대칭도 계수가 모두 양수가 나왔다.
새로 만든 f2의 비대칭도 계수는 모두 음수가 나왔다.
수치가 제법 다르므로, f2와 f4를 시각화하여, 직접 비교해보자.

3.3. 시각화하여 비대칭도 비교

위에서 만든 도수분포와 최빈값, 중앙값, 평균을 그려주는 함수인 draw_Ske를 약간 변형하여, 4개 칼럼에 대해 subplot으로 그려보도록 하자.

data = DF
x = data["X"].to_numpy()
fig, axes = plt.subplots(nrows=2, ncols=2, figsize=(16,12))
ax = axes.ravel()
column_list = ["f1", "f2", "f3", "f4"]

for i, column in enumerate(column_list):
    

    y = data[column].to_numpy()
    
    # 부드러운 그래프를 그린다.
    model=make_interp_spline(x,y)
    xs=np.linspace(np.min(index_list),np.max(index_list),100)
    ys=model(xs)
    
    ax[i].plot(xs, ys)
    title = column_list[i] + "의 분포"
    ax[i].set_title(title, fontsize=20, fontweight="bold")
    
    
    # 최빈값, 중앙값, 평균 그리기
    mode, median, mean, std = Rep_V(data, column)
    ax[i].scatter(mode, 1, c = "r", s = 100)
    ax[i].axvline(x=mode, c = "r", linewidth = 1, alpha = 0.5)
    ax[i].annotate('최빈값', xy=(mode+1, 1), xytext=(mode + 10, 0.5), fontsize = 15,
                 arrowprops=dict(facecolor='black', width=1, headwidth=8))

    ax[i].scatter(median, 3, c = "g", s = 100)
    ax[i].axvline(x=median, c = "g", linewidth = 1, alpha = 0.5)
    ax[i].annotate('중앙값', xy=(median+1, 3), xytext=(median + 10, 3.2), fontsize = 15,
                 arrowprops=dict(facecolor='black', width=1, headwidth=8))

    ax[i].scatter(mean, 5, c = "y", s = 100)
    ax[i].axvline(x=mean, c = "y", linewidth = 1, alpha = 0.5)
    ax[i].annotate('평균', xy=(mean+1, 5), xytext=(mean + 10, 6), fontsize = 15,
                 arrowprops=dict(facecolor='black', width=1, headwidth=8))
    
plt.tight_layout()

위에서 만들었던, 피어슨의 3 비대칭도 계수로 f2와 f4를 비교해보자.

# 치우침이 비교적 작은 f2의 피어슨 비대칭도 계수
>>> P_SK(DF, "f2", 3)
-0.18752034836405185

# 치우침이 비교적 큰 f4의 피어슨 비대칭도 계수
>>> P_SK(DF, "f4", 3)
-1.154019976254971

f2와 f4의 피어슨 비대칭도 계수를 절댓값으로 비교해보면, f4가 더 큰 것을 알 수 있다.
위 결과는 평균과 중앙값의 거리가 f2보다 f4가 더 멀다는 것을 의미하며, 이는 f4가 f2보다 한쪽에 더 치우쳐져 있음을 보여준다.
위 그래프를 보면 알 수 있듯, f2의 분포보다 f4의 분포가 오른쪽으로 더 데이터가 몰려있음을 알 수 있다.

4. 왜도(Skewness)

왜도는 위에서 본 피어슨의 비대칭 계수(Pearson's skewness coefficients)와 같은 분포가 어디에 치우쳐져 있는 지를 보는 보다 더 대표적인 방법이다.
사실 왜도를 보다 간략화시킨 것이 피어슨의 비대칭 계수로, 왜도를 보는 방법은 피어슨의 비대칭 계수와 동일하다.
음의 왜도(Negative skewness): 왜도에서는 왼쪽에 긴 꼬리를 갖는 왼쪽 꼬리 분포를, 음의 왜도나 좌비대칭형(Skewed left)이라 부른다.
양의 왜도(positive skewness): 왜도에서는 오른쪽에 긴 꼬리를 갖는 오른쪽 꼬리 분포를, 양의 왜도나 우비대칭형(Skewed right)이라 부른다.
왜도는 각 관찰 값의 편차에 표준편차를 나눈 값에 3 제곱을 하여 합친 값이다.
왜도는 모집단의 왜도와 표본 왜도를 구하는 공식이 약간 다르다.

◎ 표본 왜도

$$b_1 = \frac{m_3}{S^3} = \frac{\frac{1}{n}\sum_{i=1}^{n}(x_i - \bar{x})^3}{[\frac{1}{n-1}\sum_{i=1}^{n}(x_i - \bar{x})^2]^{\frac{3}{2}}} = \frac{\sum_{i=1}^{n}(x_i - \bar{x})^3}{nS^3}$$

◎ 모집단의 왜도

$$G_1 = \frac{n^2}{(n-1)(n-2)}b_1 = \frac{n}{(n-1)(n-2)}\sum_{i=1}^{n}(\frac{x_i - \bar{x}}{S})^3$$

모집단의 평균, 표준편차 등을 알 수 없기 때문에 표본집단을 이용하여, 모집단의 왜도를 추정한다.

4.1. 파이썬을 사용하여 왜도를 구해보자.

위에서 만든 DF에 대하여 왜도를 구해보도록 하자.
모집단의 왜도를 구하도록 해보자.

# 도수분포표의 도수를 list로 변환한다.
def freqT2list(data, column):
    
    result = []

    for i in range(len(data)):

        X_list = [data.loc[i, "X"]] * data.loc[i, column]
        result = result + X_list
        
    return result
    
    
# 왜도 계산
def skewness(data, column):
    
    target = np.array(freqT2list(data, column))

    n = len(target)
    mean = np.mean(target)
    std = np.std(target, ddof=1)

    return n/((n-1)*(n-2))*np.sum(((target - mean)/std)**3)

>>> for column in ["f1", "f2", "f3", "f4"]:
    
>>>     skew = skewness(DF, column)
>>>     print(f"column:{column}, 왜도: {skew}")


column:f1, 왜도: 1.0985509210885902e-16
column:f2, 왜도: -0.704757133477093
column:f3, 왜도: 0.7047571334770931
column:f4, 왜도: -1.1553356711140326

대칭 분포인 f1의 왜도는 1.0985509210885902e-16로 나왔다.
이는 0.0000000000000001098으로, 소수점 아래 16번째 자리에서 처음으로 e 앞에있는 숫자가 나온다는 의미로, 매우 작은 수로, 파이썬의 계산 방식 등으로 인해 이런 문제가 발생할 수 있으니, 깔끔하게 소숫점 아래 6자리에서 반올림을 해서 다시 보자.

>>> for column in ["f1", "f2", "f3", "f4"]:
    
>>>     skew = np.round(skewness(DF, column), 6)
>>>     print(f"column:{column}, 왜도: {skew}")


column:f1, 왜도: 0.0
column:f2, 왜도: -0.704757
column:f3, 왜도: 0.704757
column:f4, 왜도: -1.155336

왜도 역시, 피어슨의 비대칭 계수처럼 음과 양으로 데이터가 어디에 모여있는지 알 수 있다. 간단하게 음수면 긴 꼬리가 음수의 방향, 양수면 긴 꼬리가 양수의 방향에 있다고 생각하자.
왜도가 커질수록 분포가 크게 치우친 것이다.

4.2. Scipy로 왜도를 구해보자

scipy의 stats 모듈에 있는 skew 함수를 사용해서 더 쉽게 왜도를 구할 수 있다.

from scipy import stats

>>> for column in ["f1", "f2", "f3", "f4"]:
    
>>>     target = np.array(freqT2list(DF, column))
>>>     skew = stats.skew(target)
>>>     print(f"column:{column}, 왜도: {skew}")

column:f1, 왜도: 0.0
column:f2, 왜도: -0.6941414183237987
column:f3, 왜도: 0.694141418323799
column:f4, 왜도: -1.137932918011734

scipy.stats.skew(array): 왜도를 구한다.
scipy로 구한 왜도와 직접 만든 공식과 그 값이 꽤 다른 것을 알 수 있다.
이는, scipy의 왜도는 표본 왜도를 구하며, 사용하는 공식이 약간 다르므로, 표준편차를 모 표준편차로 구했기 때문이다.
이에 맞게 공식을 고쳐서 출력해보자.

# 왜도 계산
def skewness(data, column):
    
    target = np.array(freqT2list(data, column))

    n = len(target)
    mean = np.mean(target)
    std = np.std(target, ddof=0)

    return 1/n*np.sum(((target - mean)/std)**3)

>>> for column in ["f1", "f2", "f3", "f4"]:
    
>>>     skew = np.round(skewness(DF, column), 6)
>>>     print(f"column:{column}, 왜도: {skew}")


column:f1, 왜도: 0.0
column:f2, 왜도: -0.694141
column:f3, 왜도: 0.694141
column:f4, 왜도: -1.137933

왜도가 돌아가는 방식에 대해 알 필요는 있으나, 개인적으로는 이 부분을 심화시키는 것은 시간낭비라고 판단된다.
왜도는 분포의 형태를 대략적으로 아는 도구이므로, 보다 정확한 도구를 사용하는 것보단, 동일한 도구를 이용해서 평가하는 것이 중요하다고 판단되므로, scipy.stats의 skew함수를 사용하도록 하자.

5. 첨도(Kurtosis)

왜도가 데이터가 어느 쪽에 쏠려 있는지를 보는 용도라면, 첨도는 데이터가 얼마나 모여있는지를 가리킨다.
첨도가 클수록 데이터는 한 곳에 매우 많이 모여 있고, 첨도가 작을수록 데이터가 흩어져 있다.
첨도 = 0: 표준 정규분포다.
첨도 > 0: 표준 정규분포보다 평균에 데이터가 더 많이 모여 있는 뾰족한 형태다.
첨도 < 0: 표준 정규분포보다 평균에서 데이터가 더 흩어진 완만한 형태다.
첨도가 크다할지라도, 분산이 더 큰 경우, 완만한 그래프가 나타날 수 있으므로, 분산이 동일한 분포끼리 비교해야 한다.
첨도는 각 관찰 값과 표본 평균의 편차에 표본 표준편차를 나눈 값에 4 제곱을 해서 구한다.
첨도의 기준은 정규분포가 되며, 정규분포의 첨도는 3이지만, 이를 보기 쉽도록, 3을 빼서, 0으로 보정해준다.

◎ 표본 첨도

$$g_2 = \frac{m_4}{m_{2}^2} - 3 = \frac{\frac{1}{n}\sum_{i=1}^{n}(x_i - \bar{x})^4}{[\frac{1}{n}\sum_{i=1}^{n}(x_i - \bar{x})^2]^2} - 3 = \frac{n}{(n-1)^2}\sum_{i=1}^{n}(\frac{x_i-\bar{x}}{S})^4 - 3$$

◎ 모집단의 첨도(불편추정량)

$$G_2 = \frac{n-1}{(n-2)(n-3)}[(n+1)g_2 + 6]) = \frac{n(n+1)}{(n-1)(n-2)(n-3)}\sum_{i=1}^{n}(\frac{x_i - \bar{x}}{S})^4 - 3\frac{(n-1)^2}{(n-2)(n-3)}$$

5.1. 파이썬으로 첨도를 구현해보자.

넘파이를 이용하여, 평균은 0이고, 표준편차 1인 표준 정규분포를 만들어보자.

np.random.seed(1234)
Normal_Dist = np.random.normal(loc = 0, scale = 1, size = 10000)

plt.rc('font', family='monospace')

위에서 한글을 사용하기 위해 폰트를 나눔 고딕으로 설정하는 경우 음수의 "-" 부호가 깨지게 되므로, 폰트를 바꿔주었다.

fig = plt.figure(figsize=(10, 6))

plt.hist(Normal_Dist, bins = 60, density=True)
plt.show()

5.2. 첨도 함수를 만들어보자.

5.2.1. Numpy 라이브러리의 함수를 사용해서 만들어보자.

# 첨도
def Kurt(array):
    
    mean = np.mean(array)
    std = np.std(array, ddof = 1)
    n = len(array)

    g2 = n/(n-1)**2*np.sum(((array - mean)/std)**4) - 3

    G2 = ((n-1)/((n-2)*(n-3)))*((n+1)*g2 + 6)
    
    return G2

>>> Kurt(Normal_Dist)
-0.06547331601746852

5.2.2. scipy.stats 모듈의 kurtosis() 함수를 사용해서 만들어보자.

from scipy import stats

>>> stats.kurtosis(Normal_Dist)
-0.06604052394826398

scipy와 numpy로 직접 만든 첨도의 결과가 약간 다른 것을 알 수 있다.
이는, scipy에서는 Kurt함수의 G2가 아닌 g2로 계산되기 때문으로, 즉 모집단의 첨도가 아닌 표본 첨도가 계산된다는 소리다.

def Kurt_g2(array):
    
    mean = np.mean(array)
    std = np.std(array, ddof = 1)
    n = len(array)

    g2 = n/(n-1)**2*np.sum(((array - mean)/std)**4) - 3
    
    return g2

>>> Kurt_g2(Normal_Dist)
-0.06604052394826398

>>> stats.kurtosis(Normal_Dist) == Kurt_g2(Normal_Dist)
True

5.3. 무작위로 생성한 표준정규분포의 난수를 더 표준정규분포에 가깝게 해 보자.

위에서 만든 표준정규분포의 난수는 크기가 10,000으로, 실제 표준정규분포와 거리가 있다.
이번에는 난수의 크기를 1,000,000으로 해서 실제 표준정규분포에 더 가깝게 만들어보자.
(데이터의 양이 엄청나기 때문에 컴퓨터에 부담이 가는 경우 수를 조금 줄이자)

np.random.seed(1234)
Normal_Dist = np.random.normal(loc = 0, scale = 1, size = 1000000)

fig = plt.figure(figsize=(10, 6))

plt.hist(Normal_Dist, bins = 60, density=True)
plt.show()

>>> Kurt_g2(Normal_Dist)
0.0006377812832605301

난수의 크기가 10,000일 때보다 표준정규분포에 근사하게 되니 첨도가 0에 더 가까워지는 것을 볼 수 있다.
그러나, 난수를 이용해서인지 크기를 늘린다고 해서 선형으로 0에 더 가깝게 가지는 않는다.

5.4. 표준 편차가 1로 동일하지만, 크기가 매우 작아 표준 정규분포와 거리가 먼 난수를 생성해보자.

np.random.seed(1234)
Normal_Dist = np.random.normal(loc = 0, scale = 1, size = 10)

fig = plt.figure(figsize=(10, 6))

plt.hist(Normal_Dist, density=True)
plt.show()

>>> Kurt_g2(Normal_Dist)
-0.6112182077094723

이번에 생성한 데이터는 평균이 1, 표준편차가 1로 이전의 난수와 동일하지만, 크기가 10으로 매우 작아, 분산만 동일하지 정규분포로 보기 힘든 데이터를 생성해보았다.
이 경우, 첨도는 -0.611로 기존에 생성한 분포보다 더 완만하다는 것을 알 수 있다.

5.5. 표준편차가 다른 분포들을 만들고, 첨도를 비교해보자.

np.random.seed(1234)
Normal_Dist0 = np.random.normal(loc = 0, scale = 0.4, size = 100000)
Normal_Dist1 = np.random.normal(loc = 0, scale = 1, size = 100000)
Normal_Dist2 = np.random.normal(loc = 0, scale = 2, size = 100000)

fig = plt.figure(figsize=(10, 6))

plt.hist(Normal_Dist0, density=True, bins=60, alpha=0.5, label="N(0, 0.5)")
plt.hist(Normal_Dist1, density=True, bins=60, alpha=0.5, label="N(0, 1)")
plt.hist(Normal_Dist2, density=True, bins=60, alpha=0.5, label="N(0, 2)")
plt.legend(loc="upper right")
plt.show()

>>> Ku0 = Kurt_g2(Normal_Dist0)
>>> Ku1 = Kurt_g2(Normal_Dist1)
>>> Ku2 = Kurt_g2(Normal_Dist2)

>>> print(f"표준편차가 0.5인 분포의 첨도:{Ku0}")
>>> print(f"표준편차가 1인 분포의 첨도:{Ku1}")
>>> print(f"표준편차가 2인 분포의 첨도:{Ku2}")

표준편차가 0.5인 분포의 첨도:-0.030292593794574607
표준편차가 1인 분포의 첨도:-0.00581814290437066
표준편차가 2인 분포의 첨도:0.01995196078021788

위 분포만 본다면, 표준 정규분포에 가장 가까운 노란색보다 더 뾰족하게 솟은 파란색 분포가 값이 더 커야 할 것으로 보이지만, 보다 음수에 가까운 것을 알 수 있다.
이는 첨도와 표준편차는 별개로 움직이기 때문으로, 위와 같이 표준편차가 다른 경우, 그래프의 개형이 보다 더 뾰족하거나 완만하다 할지라도, 첨도가 별개로 작동하여, 잘못된 판단을 할 위험이 있다.
즉, 첨도는 분산이 동일한 상태에서 사용해야, 데이터가 평균에 모인 정도에 대해 제대로 된 비교를 할 수 있다.

산포도 - 편차: 절대 편차 & 절대 편차를 사용하지 않는 이유 & 변동 계수

만년필잉크 — Mon, 8 Mar 2021 15:04:40 +0900

편차(Deviation)

이전 포스트에서는 관측값과 평균의 차이인 편차를 이용해서 구하는 대표적인 산포도 "분산(Varience)"와 "표준편차(Standard Deviation)에 대해 학습해보았다.

이번 포스트에서는 편차를 이용하는 다른 산포도인 절대 편차(Absolute deviation)와 변동 계수(Coefficient of variation)에 대해 알아보자.

1. 절대 편차(Absolute deviation)

절대 편차는 관측값에서 평균(Mean) 또는 중앙값(Median)을 빼고, 그 편차에 절댓값을 취하고, 평균을 구한 것으로, 분산에서 제곱 대신 절댓값을 취한 것이다.

$$ AAD = \frac{1}{N}\sum_{i=1}^{N}\left | x_i - \mu \right | = \frac{\left | x_1 - \mu \right | + \left | x_2 - \mu \right | + \cdots + \left | x_N - \mu \right |}{N} $$

평균 절대 편차(Average Absolute Deviation, AAD): 각 관측값에 평균을 빼고, 편차 절댓값의 평균을 구하는 경우로, 평균 편차(Mean Deviation), 절대 편차(Absolute Deviation)라고도 한다.
중앙값 절대 편차(Median Absolute Deviation, MAD): 각 관측값에 중앙값을 빼고, 편차 절댓값의 평균을 구하는 방식이다.
최소 절대 편차(Least Absolute Deviation, LAD): 회귀분석에서 최소제곱법(LSA)에 대응되는 기법으로, 절대 오차의 합이 최소가 되는 해를 찾는 기법이다.
분산은 이상치가 존재하는 경우, 편차를 제곱시키므로 편차가 증폭될 수 있다. 절대 편차를 하는 경우, 제곱을 하지 않으므로, 이상치 존재로 인한 편차 증폭 문제를 보완할 수 있다.
예) 평균 $100$, 이상치가 $10000$인 경우, $9,900^2 = 9,8010,000$이 되어 값이 매우 커지게 된다.

1.1. 파이썬과 절대 편차

Data_for_study.csv

3.39MB

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

해당 데이터를 사용하여, 절대 편차를 만들어보자.
해당 데이터 설명은 이전 포스트 "통계 분석을 위한 데이터 준비"를 참고 하기 바란다.

1.1.1. numpy를 사용하여 절대 편차(AD) 만들기

데이터 분석에 주로 사용되는 라이브러리인 numpy나 pandas는 따로 해당 함수를 제공하지 않는다.
그러나, numpy를 사용해서 만들면, 난이도도 쉽고, numpy 기본 함수의 속도가 매우 빨라, 성능도 나쁘지 않다.

def AD(data, column, way, dof = 1):
    
    target_array = data[column].to_numpy()
    
    if way == "mean":
        key_value = np.mean(target_array)
        
    elif way == "median":
        key_value = np.median(target_array)
        
    return np.sum(np.abs(target_array - key_value))/(len(target_array) - dof)

way로 "mean"이 들어오는지, "median"이 들어오는지에 따라 평균 절대 편차나 중앙값 절대 편차가 수행된다.
np.abs(array): array에 있는 모든 원소를 양수로 만든다.
표본 집단에 대한 분석을 가정하여, 자유도로 나눈다.

>>> AD(Rawdata, "키", "mean")
7.0767022252239355

>>> AD(Rawdata, "키", "median")
7.046750497784634

>>> AD(Rawdata, "몸무게", "mean")
10.159191145859118

>>> AD(Rawdata, "몸무게", "median")
10.00470697974779

2. 절대편차(AAD)가 아닌 표준편차(Standard Deviation)를 사용하는 이유

절대편차를 사용하지 않는 이유는 총 4가지가 있다.

편차란 유클리디안 거리(Euclidean distance)에서, 각 관측값이 특정값(평균)으로부터 떨어져 있는 거리를 의미하기 때문이다.
절대편차의 최솟값은 평균이 아닌 중앙값이다.
절대편차는 미분되지 않는다.
절댓값을 연산하기 위해선 공식이 복잡해진다.

2.1. 편차와 유클리디안 거리(Euclidian distance)

절대편차를 사용하지 않는 이유를 알기 위해선, 편차의 의미에 대해 알 필요가 있다.
"편차는, 관측값이 특정값(평균)으로부터 떨어진 거리"인데, 이를 구체적으로 보기 위해 고등학교 때 배웠던, 두점 사이의 거리 공식을 보도록 하자.

위 두 점 사이의 거리는 2차원에서의 거리다. 이번에는 n차원의 공간에서 두 점간의 거리를 알아내는 공식인 유클리디안 거리(Euclidan distance)에 대해 알아보자. 위 2차원에서의 거리 공식과 개념이 매우 유사하다.

위 유클리디안 거리에서 점 $B_i$를 평균인 $\mu$로 만든다면, 우리가 아는 분산(Variance) 공식이 나온다.
그러나, 위 유클리디안 거리는 n차원에서의 두 점 사이의 거리를 의미한다. 때문에 1차원에서라면, 절대 평균 편차 공식을 사용해도 되지 않는가 하는 의문이 들 수 있다.

2.2. 절대 편차의 최솟값은 평균이 아닌 중앙값이다.

"편차는 관측값들이 특정값으로부터 떨어진 정도(거리)"라고 하였다.
이 특정값을 우리는 대푯값(Representative value)라고 하며, 대푯값은 어떤 데이터를 대표하는 값이다.
이번에는 관측값의 집합$X = (1, 2, 5)$가 있다고 가정하고, 이것을 분산으로 구할 때와, 절대편차로 구할 때에 따라, 임의의 대푯값 $R$이 분산($\sigma^2$)과 절대편차에 대하여 어떠한 함수의 형태를 그리는지 보도록 하자.

# 분산인 경우
def f(x):
    
    return((1-x)**2 + (2-x)**2 + (5-x)**2)/3
    
 
 
# 절대 편차인 경우
def h(x):
    
    return(np.abs(1-x) + np.abs(2-x) + np.abs(5-x))/3

def draw_Function(f, key):

    # 대푯값에 대한 시각화를 해보자.
    R = np.arange(0, 10, 0.001)
    y = f(R)

    # 최솟값을 구한다.
    min_y = y.min()
    min_x = R[np.where(y == min_y)][0]
    
    # 그래프 그리기
    plt.rc('font', family='NanumGothic')
    fig = plt.figure(figsize=(8, 6))

    # 함수 f의 시각화
    plt.plot(R, y)

    # y 값에서의 최솟값
    plt.scatter(min_x, min_y, color="r",s = 100)

    # 그래프 꾸며주기
    plt.title(f"{key}에 대한 대푯값", fontsize = 20, pad = 30)
    plt.xlabel("대푯값", fontsize = 15, labelpad = 10)
    plt.ylabel(f"{key}", rotation = 0, fontsize = 15, labelpad = 20)


    plt.show()
    
    
    print(f"({np.round(min_x, 3)}, {np.round(min_y, 3)})에서 함수 f(x)는 최솟값을 갖는다.")

2.2.1. 분산에 대한 대푯값의 그래프

>>> draw_Function(f, "분산")
(2.667, 2.889)에서 함수 f(x)는 최솟값을 갖는다.

대푯값 R에 대한 분산($\sigma^2$)의 그래프를 그렸을 때, 이차 함수 형태를 그리는 것을 볼 수 있다.
분산의 최솟값은 2.889이며, 이는 대푯값(R) 2.667이다.
관측값 X = [1, 2, 5]의 평균은 다음과 같다.

>>> np.mean([1,2,5])
2.6666666666666665

관측값의 평균과 분산이 최솟값을 갖는 대푯값은 일치한다.
(약간의 차이가 있는 이유는, 그래프 생성 시, np.arange(start, end, by)에 대하여, by의 간격이 0.001로 이산된 부분이 생겼기 때문이다. by를 작게 할 수도록 평균과 근사해진다.)
즉, 분산에 있어 대푯값은 평균이다.

2.2.2. 절대편차에 대한 대푯값의 그래프

>>> draw_Function(h, "절대편차")
(2.0, 1.333)에서 함수 f(x)는 최솟값을 갖는다.

절대편차의 개형은 꺾은선 그래프와 같은 형태를 그린다.
절대편차에서의 최솟값은 대푯값 2.0에서 존재한다.
대푯값 2.0은 관측값의 집합 X=[1,2,5]에서 중앙값(Median)인 2이다.

2.2.3. 절대편차에 대한 대푯값의 그래프에서 집합의 원소가 짝수일 때

X = [1, 2, 5, 7]이 관측값의 집합이라 가정해보자.

def h1(x):
    
    return(np.abs(1-x) + np.abs(2-x) + np.abs(5-x) + np.abs(7-x))/4

>>> draw_Function(h1, "절대편차")
(2.0, 2.25)에서 함수 f(x)는 최솟값을 갖는다.

집합의 원소가 짝수인 경우, 그래프의 개형에서 아래쪽이 평평해진다.
대푯값 R이 한 점이 아닌 선이 되었으므로, 선에 대한 대푯값으로 중앙값을 구해보자.

>>> R = np.arange(0, 10, 0.001)
>>> y = h1(R)

>>> min_y = y.min()
>>> min_x = R[np.where(y == min_y)]

>>> print("절대편차에 대한 대푯값의 중앙값:", str(np.median(min_x)))
절대편차에 대한 대푯값의 중앙값: 3.5

>>> print("집합 X의 중앙값:", str(np.median([1,2,5,7])))
집합 X의 중앙값: 3.5

집합의 개수가 짝수일 때도, 대푯값이 중앙값인 것을 알 수 있다.

2.2.4. 정리

위 결과를 볼 때, 절대 편차는 관측값으로부터 중앙값까지의 거리의 평균인 것임을 알 수 있다.
즉, 차원이 1개라고 가정한다 할지라도, 절대 편차의 대푯값은 중앙값이므로, 분산처럼 평균에서 각 원소까지의 거리 제곱의 평균을 구할 수 있는 것이 아니라, 중앙값에서 각 원소까지의 거리의 절댓값의 평균이 되게 되어, 의미가 달라지게 된다.
또한, 절대 편차를 사용할 때, 중앙값 절대 편차(MAD)를 사용하게 되는 이유가 바로 위와 같다.

2.3. 절대편차는 미분되지 않는다.

위에서 만든 절대편차의 대푯값 그래프를 가지고 와보자.

미분을 위한 기본 조건은 좌 미분과 우 미분이 같아야 한다는 것인데, 보시다시피 절대편차는 매끈한 곡선이 아니므로, 좌 미분과 우 미분이 동일하지 않은 점이 반드시 존재한다.
미분이 되지 않는다는 것은 산포도의 관점에서는 그다지 중요한 이유가 아니지만, 손실함수의 미분을 통한 최적해를 찾아가는 과정인 딥러닝의 학습 부분에서는 상당히 중요한 이유가 된다.

2.4. 절댓값 연산을 위해선 연산이 복잡해진다.

절댓값 연산을 위해선, 각 편차의 부호를 확인하는 과정이 필요하다.
반면에 분산은 편차를 일괄적으로 제곱하여 모든 부호가 양으로 만들기 때문에 연산이 아주 간단해진다.

2.5. 정리

위 내용을 줄여보면, 산포도라는 대상을 위해 절대 편차를 사용하는 것에는 문제가 없으나, 그 기준을 평균이 아닌 중앙값(Median)으로 잡는 것이 좋으며, 중간값 절대 편차(MAD)를 사용한다 할지라도, 태생적인 한계점이 많으므로, 중간값 절대 편차보다는 분산을 사용하는 것이 좋다.

3. 변동 계수(Coefficient of Variation, CV)

변동 계수는 표준 편차를 표본 평균이나 모 평균과 같은 산술 평균으로 나눈 값이다.

$$ CV = \frac{S}{\bar{X}} $$

변동 계수는 상대 표준 편차(Relaative standard deviation, RSD)라고도 한다.
변동 계수는 측정 단위가 서로 다른 데이터의 산포도를 비교할 때 사용한다.
표준편차와 산술 평균 모두 단위가 있으나, 이 둘을 나눔으로써 단위가 사라지게 된다.
평균과 표준편차는 단위가 존재하며, 서로 다른 데이터끼리 그 흩어져있음을 비교하기 위해선 변동 계수를 만들어, 단위를 없애야만 서로 비교해볼 수 있다.
변동 계수가 클수록 상대적인 산포도가 크다고 할 수 있다.

3.1. 예시 및 파이썬 구현

A반의 키는 평균 164cm, 표준편차는 12cm가 나왔다.
A반의 몸무게는 평균 57 kg, 표준편차 10kg이 나왔다.
키와 몸무게는 서로 다른 변수이므로, 단위 역시 다르기 때문에 이들의 표준편차를 단순하게 비교해서는 안된다.

def CV(mean, std):
    
    return std/mean

# 키의 변동계수
>>> CV(164, 12)
0.07317073170731707

# 몸무게의 변동계수
>>> CV(57, 10)
0.17543859649122806

위 결과를 보면, 몸무게의 변동 계수는 0.1754, 키의 변동 계수는 0.731로 몸무게의 변동 계수가 더 크므로, 몸무게가 키보다 산포도가 크다는 것을 알 수 있다.
변동 계수는 그 공식이 매우 단순하므로, 위처럼 평균과 표준편차를 출력하여 바로 구할 수도 있다.

def CV(data, column):
    
    target_array = data[column].to_numpy()
    
    return np.std(target_array)/np.mean(target_array)

>>> CV(Rawdata, "키")
0.05189104256446505

>>> CV(Rawdata, "몸무게")
0.2196611158371381

또는 위 함수처럼 numpy로 평균과 표준편차를 직접 생성하여, 구할 수도 있다.

산포도 - 편차: 분산 & 표준 편차 & 표준편차에 (n-1)을 나누는 이유 & 자유도

만년필잉크 — Fri, 5 Mar 2021 15:55:52 +0900

편차(Deviation)

◎ 편차(Deviation): 관측값들이 특정값(평균)으로부터 떨어진 정도(거리)이다.

$$ Dev = x_i - \mu $$

이전 포스트에서 학습하였던, 범위, 사분위간 범위는 관측값 간의 간격을 사용해 산포도를 나타냈다. 이번에는 평균과 관측값의 차이인 편차(Deviation)를 이용해 산포도를 나타내는 방법에 대해 알아보겠다.
편차를 이용해 산포도를 나타내는 방법은 분산(Varience), 표준 편차(Stadard deviation), 절대 편차(Absolute deviation), 변동 계수(Coefficient of variation) 등이 있다.
편차는 양수, 음수 모두 가능하며, 평균보다 크면 양수, 작으면 음수가 된다.
편차의 크기는 관측값이 평균으로부터 떨어진 거리를 말한다.
모집단 평균에서의 편차는 오류(Error)라고 하며, 표본 집단 평균에서의 편차는 잔차(Observed value)라고 한다.

1. 분산(Varience)과 표준편차(Standard Deviation)

◎ 분산(Varience): 편차 제곱의 평균으로, 평균으로부터 관찰값들이 떨어진 거리의 제곱 평균이다.

◎ 표준편차(Standard Deviation): 분산의 양의 제곱근이다.

중심경향치에서 평균이 제일 많이 쓰이듯, 산포도에서 제일 많이 쓰이는 분산과 표준편차가 나오게 된 개념은 편차의 평균을 구하려는 시도에서 시작되었다.
편차는 각 관측값이 평균으로부터 떨어진 거리이므로, 그 평균을 알 수 있다면, 관측값들이 평균으로부터 떨어진 정도를 한 값으로 알 수 있다.
편차 평균의 공식은 다음과 같다.

$$\frac{1}{N}\sum (x_i - \mu)$$

그러나, 위 공식은 무조건 결괏값이 0이 나온다.

모든 편차의 합이 0이 되는 것을 막기 위해, 편차에 제곱을 해줘서 모든 편차를 양수로 만들고, 이의 평균을 구한 것이 바로 분산(Varience)이다.
본래 우리가 구하고자 했던 값은 편차의 평균이었다. 그러나, 편차의 합은 0이 나오기 때문에 제곱을 해주었고, 그로 인해 편차의 증폭과 단위의 제곱이 일어났다.
위 문제를 해결하고자, 분산에 양의 제곱근을 씌워, 제곱으로 인한 편차의 증폭과 단위를 원상 복귀하고자, 분산에 양의 제곱근을 씌운 것이 표준편차(Standard deviation)다.

2. 모집단과 표본집단의 분산과 표준편차

분산의 모수와 통계량은 계산 방법과 표기 방법이 달라진다.
모집단의 분산과 표준편차

모집단의 분산: $\sigma ^2 = \frac{\sum(X_i - \mu)^2}{N}$

모집단의 표준편차: $\sigma = \sqrt{\frac{\sum(X_i - \mu)^2}{N}}$

표본집단의 분산과 표준편차

표본집단의 분산: $S ^2 = \frac{\sum(X_i - \bar{X})^2}{n-1}$

표본집단의 표준편차: $S = \sqrt{\frac{\sum(X_i - \bar{X})^2}{n-1}}$

단순 기술통계량을 구할 땐, 모집단의 분산과 표준편차를 구하는 방식으로 하면 된다.
관찰 값들의 차이가 클수록 편차가 커지므로, 분산 $\sigma^2$은 커진다.
분산은 편차의 제곱이므로, 평균으로부터 멀어질수록 그 차이가 증폭되게 된다.
분산은 편차의 제곱이므로, 단위 역시 제곱된다.
위 문제를 해결하기 위해 양의 제곱근을 씌워서 표준편차를 만든다.

3. 표본 분산에 $(n-1)$을 나눠주는 이유.

표본 분산에 $(n-1)$을 나눠주는 이유는 꽤 복잡하기 때문에 기초통계학에서는 이를 다루지 않는다. 그러나, 이 부분을 그냥 넘어가게 된다면, 앞으로 이와 비슷한 경우가 등장할 때마다, 수식을 이해하는 것이 아닌, 수식을 암기만 하고 넘어갈 위험이 있다.

표본 분산에 $(n-1)$을 나눠준 이유를 알기 위해서는 먼저 "자유도(Degree of freedom)"라는 개념에 대해 알아야 한다. 자유도의 개념은 꽤나 모호하고, 국내에서는 이를 명확히 설명하는 글을 찾기 어렵다. 위키피디아 영문판에서는 자유도를 무엇인지 대략적인 개념을 이해해보자.

3.1. 자유도(Degree of freedom)

◎ 자유도(Degree of freedom):

In statistics, the number of degrees of freedom is the number of values in the final calculation of a statistic that are free to vary.
("Degrees of Freedom". Glossary of Statistical Terms. Animated Software. Retrieved 2008-08-21.)
Estimates of statistical parameters can be based upon different amounts of information or data. The number of independent pieces of information that go into the estimate of a parameter are called the degrees of freedom. In general, the degrees of freedom of an estimate of a parameter are equal to the number of independent scores that go into the estimate minus the number of parameters used as intermediate steps in the estimation of the parameter itself
(Lane, David M. "Degrees of Freedom". HyperStat Online. Statistics Solutions. Retrieved 2008-08-21.)
출처: en.wikipedia.org/wiki/Degrees_of_freedom_(statistics)

위 자유도의 정의를 해석해보면, 자유도는 다음과 같은 성질을 갖는다.

통계의 최종 계산에서 자유롭게 변경 가능한 값의 개수
"통계의 매개 변수의 추정치(Estimates of statistical parameters)"는 정보나 데이터에서 다른 값의 개수를 기반으로 하며, 매개 변수 추정치에 들어가는 독립적인 정보의 수를 자유도라 한다.
일반적으로, 모수 추정의 자유도는 추정에 들어가는 독립된 값의 개수에 모수 추정의 중간 단계로 사용되는 모수의 수를 뺀 값과 같다.

위 내용을 보다 쉽게 풀어써보면 다음과 같다.

자유도는 독립된 값의 개수와 이를 통해 모수를 추정할 때, 사용되는 결정된 정보의 수를 뺀 것으로, 더 쉽게 말하면, 독립적인 미지수의 개수에 그 독립적인 미지수에 의해 자동으로 결정되어 버리는 값의 수를 빼는 것이다.
표본집단의 각 원소는 완전 무작위 표본 추출 방법으로 복원 추출하여 실시한다면, 각 원소는 독립적이지만, 그 독립된 원소들이 결정되면, 평균, 표준편차 등의 통계량들은 자동으로 결정되므로, 이들 통계량은 독립적이지 않다고 할 수 있다.
그러므로, 자유도는 표본 집합의 원소의 수에 모수 추정 과정에서 표본 집합이 결정되면, 자동으로 결정되는 평균, 표준편차와 같은 파라미터의 개수를 빼서 구하게 된다.

3.2. 자유도를 사용해서 표본 분산을 계산하는 이유

표본집단은 모집단에 비해, 표본의 수가 매우 적으므로, 데이터가 편향(Bias)되어 있다.
편향되어 있기 때문에 표본집단의 크기는 모집단의 크기보다 작으며, 이를 보정하여, 통계량의 값을 크게 만들어줘서 불편추정량(Unbiased estimate)으로 만들어줘야 한다.
이때, 독립적인 정보의 수인 n이 아니라, 자유도로 나눠준다면, 표본 집단의 통계량의 기댓값이 모집단의 통계량의 기댓값과 같아져 불편추정량이 된다.
다른 값이 아니라 자유도를 사용하는 이유는, 자유도로 나눴을 때, 불편추정량이 만들어지기 때문이며, 이는 최소분산불편추정량(Uniformaly Minimum Variance Unbiased Estimator, UMVUE)를 통해 증명할 수 있다.
모 분산과 표본 분산의 기댓값에 대하여, 표본 분산을 자유도로 나눴을 때, 어떤 결과가 나오는지 보도록 하자.

위 결과를 보듯, 표본 분산의 기댓값은 $n$이 아니라, 자유도인 $n-1$로 나눴을 때, 모분산과 같게 된다.
그러므로, 표본 분산에는 $n$이 아닌 자유도 $n-1$로 나눠줘야 한다.

3.3. 자유도를 무시하는 경우

위 자유도의 개념을 알고 나니, 표본 집단을 이용하여, 모집단을 추정할 때는 불편추정량을 만들어주기 위해, 자유도의 개념이 필요하다는 것을 알 수 있다.
그러나, 위 개념을 모르는 상태에서 현장에서 데이터 분석을 해본 사람들은 지금까지 큰 문제가 없었을 것인데, 이는 앞서 말했던, 불편추정량이 생기는 원인 때문이다.
불편추정량은 표본 집단의 양이 작기 때문에 생기는 현상인데, 만약 표본 집단의 양이 매우 많다면 어떻겠는가
자 표본 분산을 구하는데, 표본 집단의 크기가 10개라고 생각해보자, 자유도 9와 원래 값인 10은 꽤 큰 차이가 있다. 그러나 표본 집단의 크기가 10,000개라고 해보자, 10,000개와 9,999개는 거의 차이가 없다.
즉, 표본의 크기가 매우 크다면, 자유도를 무시하고 n으로 계산해도 아무 문제가 없다.

4. 파이썬으로 표준편차를 구해보자.

위에서 봤던, 표준편차와 분산의 개념과 달리 파이썬으로 표준편차를 구하는 것은 매우 쉽다. 아래 데이터를 이용해서, 양적 데이터인 "키", "몸무게"의 표준편차를 뽑아보도록 하자.

Data_for_study.csv

3.39MB

import numpy as np
import pandas as pd

Rawdata = pd.read_csv("Data_for_study.csv")

4.1. 위 식대로 함수를 만들어보자

# 모 표준편차
def Pop_standard_deviation(data, column):
    
    target_array = data[column].to_numpy()
    result = np.sqrt(np.sum(((target_array - np.mean(target_array)) ** 2))/len(target_array))
    
    return result


# 표본 표준편차
def Sample_standard_deviation(data, column):
    
    target_array = data[column].to_numpy()
    result = np.sqrt(np.sum((target_array - np.mean(target_array)) ** 2)/(len(target_array)-1))
    
    return result

# 키의 모표준편차
>>> Pop_standard_deviation(Rawdata, "키")
8.589382382344954

# 키의 표본표준편차
>>> Sample_standard_deviation(Rawdata, "키")
8.589459420964639

# 데이터의 크기
>>> len(Rawdata)
55748

데이터의 크기가 55,784로 꽤 크다 보니, 모표준편차와 표본표준편차가 거의 유사하다는 것을 알 수 있다.

4.2 Pandas와 Numpy를 사용하여 표준편차를 구하자.

# pandas 함수로 구하기
>>> Rawdata.키.std()
8.589459420964502

>>> Rawdata.몸무게.std()
12.935373134509032


# numpy 함수로 구하기
>>> np.std(Rawdata.키.to_numpy())
8.589382382344954

>>> np.std(Rawdata.몸무게.to_numpy())
12.9352571175121

pd.Series.std(): 시리즈의 value를 대상으로 표준편차를 구한다. - 표본표준편차
np.std(array): 배열을 대상으로 표준편차를 구한다. - 모표준편차
몸무게의 표준편차가 키의 표준편차보다 크므로, 몸무게의 데이터가 키의 데이터보다 평균에서 멀리 떨어진 것을 알 수 있다.
위 결과를 보면, Pandas와 Numpy의 표준편차 결과가 약간이긴 하지만, 차이가 나는 것을 알 수 있다.
Pandas와 Numpy의 표준편차 계산 방식의 차이를 보기 위해, 표본을 아주 조금만 뽑아서 표본의 크기가 커져서, 자유도의 보정 영향력이 줄어드는 걸 줄여서 봐보자.

# 무작위로 데이터를 30개만 sampling 하자.
>>> sample_data = Rawdata.sample(30)


# 공식대로 만든 모표준편차
>>> Pop_standard_deviation(sample_data, "키")
7.172806672116262

# 공식대로 만든 표본표준편차
>>> Sample_standard_deviation(sample_data, "키")
7.295427634334816

# numpy의 std 함수
>>> np.std(sample_data.키.to_numpy())
7.172806672116262

# pandas의 std 함수
>>> sample_data.키.std()
7.295427634334816

위 결과를 보면, numpy의 표준편차는 기본적으로 모표준편차를 구하는 공식으로 돌아가는 것을 알 수 있다.
pandas의 표준편차는 기본적으로 표본표준편차를 구하는 공식으로 돌아간다.
기본적으로 numpy의 성능이 더 좋기 때문에, numpy를 사용하여 표본표준편차를 구하고자 하는 경우도 많을 텐데, numpy로 표본표준편차를 구하고자 한다면, 다음 파라미터를 추가해줘야 한다.

# numpy를 사용해서 표본표준편차 구하기
>>> np.std(sample_data.키.to_numpy(), ddof = 1)
7.295427634334816

ddof 파라미터는 자유도에서 빼 줄 독립적이지 않은 파라미터의 크기를 말한다.
표본 데이터를 대상으로 numpy를 연산한다면, 자유도의 존재를 잊지 말고 꼭 반영해주자.
물론, 데이터의 양이 굉장히 크다면, 굳이 불편추정량을 만들기 위해, 자유도로 나눠주지 않아도 괜찮다.

5. 도수분포표를 이용한 표준편차 계산

앞서 도수분포표를 사용해서 평균, 중앙값 등을 구했듯, 도수분포표를 사용해서 표준편차를 계산할 수도 있다.
앞서 말했듯, 원시자료를 가지고 있다면, 굳이 도수분포표로 표준편차를 구하지 않아도 되지만, 도수분포표밖에 없다면, 도수분포표를 사용해서 표준편차를 유추해야 한다.
이전에 만들었던, 연속형 데이터를 범주형 데이터로 만드는 함수를 사용해서 도수분포표를 만들고, 해당 도수분포표를 이용해서 표준편차를 추론해보자.

def make_freq_table(data, column):
    """
    -------------------------------------------------------------------------------
    지정된 변수의 관찰값이 20개보다 많은 경우, 10개의 등급을 가진 데이터를 반환한다.
    10개의 등급은 동일한 간격으로 자른 것이다.
    -------------------------------------------------------------------------------
    Input: DataFrame, str
    Output: DataFrame
    """
    # array 생성
    target_array = data[column].to_numpy()

    # class의 수가 20개보다 많은 경우 10개로 줄인다.
    class_array = np.unique(target_array)

    if len(class_array) > 20:

        min_key = class_array.min()
        max_key = class_array.max()
        split_key = np.linspace(min_key, max_key, 10)

        a0 = str(round(split_key[0], 2)) + " 이하"
        a1 = str(round(split_key[0], 2)) + " ~ " + str(round(split_key[1], 2))
        a2 = str(round(split_key[1], 2)) + " ~ " + str(round(split_key[2], 2))
        a3 = str(round(split_key[2], 2)) + " ~ " + str(round(split_key[3], 2))
        a4 = str(round(split_key[3], 2)) + " ~ " + str(round(split_key[4], 2))
        a5 = str(round(split_key[4], 2)) + " ~ " + str(round(split_key[5], 2))
        a6 = str(round(split_key[5], 2)) + " ~ " + str(round(split_key[6], 2))
        a7 = str(round(split_key[6], 2)) + " ~ " + str(round(split_key[7], 2))
        a8 = str(round(split_key[7], 2)) + " ~ " + str(round(split_key[8], 2))
        a9 = str(round(split_key[8], 2)) + " 이상"
        new_index = [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9]


        target_array= np.where(target_array <= split_key[0], 0,
                               np.where((target_array > split_key[0]) & (target_array <= split_key[1]), 1,
                                        np.where((target_array > split_key[1]) & (target_array <= split_key[2]), 2,
                                                 np.where((target_array > split_key[2]) & (target_array <= split_key[3]), 3,
                                                          np.where((target_array > split_key[3]) & (target_array <= split_key[4]), 4,
                                                                   np.where((target_array > split_key[4]) & (target_array <= split_key[5]), 5,
                                                                            np.where((target_array > split_key[5]) & (target_array <= split_key[6]), 6,
                                                                                     np.where((target_array > split_key[6]) & (target_array <= split_key[7]), 7,
                                                                                              np.where((target_array > split_key[7]) & (target_array <= split_key[8]), 8, 9)))))))))


    # 도수분포표 생성
    freq_table = pd.DataFrame(pd.Series(target_array).value_counts(), columns = ["freq"])
    freq_table.index.name = column

    freq_table.sort_index(inplace = True)
    freq_table["ratio"] = freq_table.freq / sum(freq_table.freq)
    freq_table["cum_freq"] = np.cumsum(freq_table.freq)
    freq_table["cum_ratio"] = np.round(np.cumsum(freq_table.ratio), 2)
    freq_table["ratio"] = np.round(freq_table["ratio"], 2)

    if "new_index" in locals():
        freq_table.index = new_index
        freq_table.index.name = column

    return freq_table

Rawdata = pd.read_csv("Data_for_study.csv")
make_freq_table(Rawdata, "키")

위 도수분포표에서 사용해야 할 것은 범주화된 $X_i$인 키의 중앙값과 freg다.
표준편차의 식을 다음과 같이 유도해보자.

$$\sqrt{\frac{\sum(X_i - \bar{X})^2}{n}} = \sqrt{\frac{\sum fX_i^2}{n} - \left ( \frac{\sum fX_i}{n} \right )^2}$$

# 중앙값 생성
키_도수분포표 = make_freq_table(Rawdata, "키")
키_도수분포표.reset_index(drop=False, inplace=True)

# 1 부터 8번 행까지 처리
키1_8_array = 키_도수분포표[1:9].키.str.split(" ~ ", expand=True).values.astype("float")
키1_8_array_mid = (키1_8_array[:,0] + 키1_8_array[:,1])/2

# 0, 9 행 처리
키0_9_array = 키_도수분포표.loc[[0,9]].키.str.partition(" ")[0].to_numpy().astype("float")

# 중앙값 생성
키1_8_array_mid = np.insert(키1_8_array_mid, 0, 키0_9_array[0])
키_도수분포표["중앙값"] = np.insert(키1_8_array_mid, len(키1_8_array_mid), 키0_9_array[1])

키_도수분포표

키_도수분포표["$fX$"] = 키_도수분포표["freq"] * 키_도수분포표["중앙값"]
키_도수분포표["$fX^2$"] = 키_도수분포표["freq"] * 키_도수분포표["중앙값"]**2
키_도수분포표

# 도수분포표로 추론한 표준편차
>>> 앞부분 = 키_도수분포표["$fX^2$"].sum()/키_도수분포표["freq"].sum()
>>> 뒷부분 = (키_도수분포표["$fX$"].sum()/키_도수분포표["freq"].sum())**2
>>> np.sqrt(앞부분 - 뒷부분)
8.771635569514544

# 실제 표준편차
>>> np.std(Rawdata.키)
8.589382382344816

자유도가 아닌 총 빈도 수인 $n$으로 나눠 모 표준편차를 구하였다.
표본 표준편차를 구하고자 하는 경우, 위 공식에서도 $n$이 아니라 $n-1$로 나눠주면 된다.
실제 표준편차는 8.5893이 나왔으며, 도수분포표로 추론한 표준편차는 8.7716이 나왔다.
앞서 말했듯, 이 방법은 도수분포표만 사용 가능한 경우에 쓸 수 있는 방법이다.

산포도(Dispersion) - 범위, 사분위간 범위, 사분위수와 상자 수염 그림

만년필잉크 — Thu, 4 Mar 2021 16:28:08 +0900

산포도(Dispersion)

◎ 산포도: 분산도(Degree of dispersion), 변산성(Variability)이라고도 하며, 관찰된 데이터가 흩어져 있는 정도를 말한다.

통계학은 기본적으로 데이터가 어디에 모여있고, 얼마나 흩어져 있는지를 통해 데이터를 파악한다고 하였다.
지금까지 데이터가 어디에 모이는지에 대한 중심경향치(Center Tendency)를 알아보았으므로, 이번에는 데이터가 얼마나 흩어져있는지를 알 수 있는 산포도(Dispersion)에 대해 알아보겠다.
산포도에는 범위(Range), 사분위간 범위(Interquartile range), 분산(Varience), 표준 편차(Standard deviation), 절대 편차(Absolute deviation), 변동 계수(Coefficient of variation) 등이 있다.
학습 데이터(참고 포스트: "통계 분석을 위한 데이터 준비")

Data_for_study.csv

3.39MB

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

Rawdata = pd.read_csv("Data_for_study.csv")

1. 범위(Range)

◎ 범위(Range): 관찰 값에서 최댓값과 최솟값의 차이다.

$$ range = max - min $$

데이터가 흩어진 정도를 보는 가장 간단한 방법으로, 관찰 값이 시작되는 최솟값에서 관찰값이 끝나는 최댓값의 차이다.
범위는 구하기 쉽고, 해석하기도 쉬우나, 간단한만큼 많은 단점을 가지고 있다.
범위는 이상치(다른 데이터에 비해 지나치게 크거나, 작은 값)의 영향을 너무 심하게 받는다.
최댓값에서 최솟값의 차이만 구하므로, 같은 범위를 갖는다고 할지라도 데이터의 분포가 완전히 다를 수 있다.
학습 데이터에서 "학업성적", "건강인지"의 범위를 구해보자.

def cal_range(data, column):
    
    target_series = data[column]
    
    return target_series.max() - target_series.min()

pd.Series.min(): 시리즈의 최솟값을 구한다.
pd.Series.max(): 시리즈의 최댓값을 구한다.

>>> cal_range(Rawdata, "학업성적")
4.0

>>> cal_range(Rawdata, "건강인지")
4.0

"학업성적", "건강인지"의 도수분포표를 이용해, 도수분포다각형(Frequency distribution polygon)을 그려보자.

def FDPolygon(data, column):
    
    freq_table = data[column].value_counts().sort_index()
    ratio_x = freq_table.values/sum(freq_table.values)

    # 도수분포다각형 그리기
    plt.plot(freq_table.index, ratio_x, label = column)

    plt.xticks(np.arange(1, len(freq_table.index) + 1))

plt.rc('font', family='NanumGothic')
fig = plt.figure(figsize=(8, 6))

FDPolygon(Rawdata, "건강인지")
FDPolygon(Rawdata, "학업성적")

# 그래프 꾸미기
plt.legend(loc = "upper right")
plt.title("건강인지 & 학업성적 도수분포다각형", fontsize = 20, pad = 30)
plt.xlabel("관측값", fontsize = 15, labelpad = 10)
plt.ylabel("비율", rotation = 0, fontsize = 15, labelpad = 20)
plt.show()

"건강인지", "학업성적" 변수의 범위는 동일하지만, 데이터의 분포는 상당히 다른 것을 알 수 있다.
즉, 범위는 한 변수 안의 데이터의 관측값의 시작 값(최솟값)에서 끝 값(최댓값)까지의 간격을 알 수 있지만, 데이터가 어떻게 분포해 있는지 알 수는 없다.

2. 사분위간 범위(Interquartile range, IQR)

◎ 사분위간 범위: 데이터를 25% 단위로 4개의 구간으로 나누는 관측값을 사분위수(Quartile)라 하며, 이 사분위수에서 제1사분위수(Q1)와 제3사분위수(Q3)의 범위가 사분위간 범위다.

$$ IQR = Q3 - Q1 $$

사분위수(Quartile):
전체 데이터를 25% 단위로 나눌 수 있는, Q1(1사분위수), Q2(2사분위수), Q3(3사분위수)를 말한다.
각 사분위수는 각 값의 하위 범위에 대하여, Q1은 25% 이하의 데이터가 존재하는 관측값, Q2는 50% 이하의 데이터가 존재하는 관측값(중위수), Q3는 75% 이하의 데이터가 존재하는 관측값을 말한다.
즉, Q1은 제 25 백분위수, Q2는 제 50 백분위수, Q3는 제 75 백분위수이다.
Q4는 제4사분위로 제 100 백분위수다.
사분위간 범위는 산포도이며, 사분위수는 대푯값에 해당한다.
중위수, 사분위간 범위는 빈도를 이용해 계산되며, 이상치(지나치게 크거나 작은 값)의 영향을 받는 양 극단의 값 역시, 단순히 빈도로 보므로 이상치의 영향을 받지 않는다.

2.1. 파이썬을 이용해서 사분위수 구하기

2.1.1. pandas 라이브러리 활용

키에 대하여 사분위수를 구해보자.

>>> Rawdata.키.quantile(0)
136.0

>>> Rawdata.키.quantile(0.25)
159.1

>>> Rawdata.키.quantile(0.5)
165.0

>>> Rawdata.키.quantile(0.75)
172.0

>>> Rawdata.키.quantile(1)
196.0

pd.Series.quantile(float): 0에서 1 사이의 비율에 대하여, 그 비율의 위치에 해당하는 관찰 값을 반환한다.
하위 빈도의 비율에 대해 구하므로, 사분위수가 아닌 하위 60, 80%와 같은 값도 쉽게 구할 수 있다.

>>> Rawdata.키.quantile(0.6)
167.8

>>> Rawdata.키.quantile(0.8)
173.2

2.1.2. Pandas의 기본적인 기술 통계량을 반환하는 함수로도 구할 수 있다.

>>> Rawdata.키.describe()

count    55748.000000
mean       165.527266
std          8.589459
min        136.000000
25%        159.100000
50%        165.000000
75%        172.000000
max        196.000000
Name: 키, dtype: float64

pd.DataFrame.describe(): 데이터 요약을 위한 메서드로, 빈도, 평균, 표준편차, 최솟값, 사분위수, 최댓값을 시리즈로 출력한다.

>>> 키_기술통계량 = Rawdata.키.describe()
>>> 키_기술통계량.loc["25%"]
159.1

>>> 키_기술통계량.loc["75%"]
172.0

>>> 키_기술통계량.loc["mean"]
165.5272655521264

>>> 키_기술통계량.loc["std"]
8.589459420964502

시리즈로 출력되므로, index를 이용해, 그 인데스에 해당하는 값을 반환하는 loc를 사용하면, 내가 원하는 값만 가지고 올 수 있다.

2.2.2. Numpy를 이용하여 사분위수 구하기

>>> target_array = Rawdata.키.to_numpy()
>>> np.percentile(target_array, 25)
159.1

>>> np.percentile(target_array, 50)
165.0

>>> np.percentile(target_array, 75)
172.0

np.percentile(array, q): q번째 백분위 수를 계산하여, 배열의 q번째 백분위 수를 반환한다.

2.3. 사분위간 범위 구하기

def cal_Interquartile_range(data, column):
    
    target_array = data[column].to_numpy()
    
    return np.percentile(target_array, 75) - np.percentile(target_array, 25)

>>> cal_Interquartile_range(Rawdata, "키")
12.900000000000006

3. 사분위수와 상자 수염 그림

◎ 상자 수염 그림(Box-and-whisker plot): 상자 그림(Box plot)이라고도 하며, 다섯 숫자 요약(최솟값, 제1사분위수, 중앙값, 제3사분위수, 최댓값)으로 데이터의 특성을 요약하는 그래프다.

다섯 숫자 요약(Five-number summary): 최솟값(min), 제1사분위수(Q1), 중앙값(median), 제3사분위수(Q3), 최댓값(max)으로 전체 데이터를 요약한 것이다.
사분위간 범위(IQR)로 몸통을 구성하고, 근접 값들로 꼬리를 구성한다.
단위 척도(Step): 1.5 * IQR
안 울타리(Inner fence)는 Q1에서 최솟값의 방향으로 1 step만큼 이동한 것이고, Q3에서 최댓값의 방향으로 1 step만큼 이동한 곳에 그린다.
바깥 울타리(Outer fence)는 Q1에서 최솟값의 방향으로 2 step만큼 이동한 것이고, Q3에서 최댓값의 방향으로 2 step만큼 이동한 곳에 그린다.

3.1. 상자 수염 그림과 이상값(Outlier)

◎ 이상값(Outlier): 정상 범주에서 벗어난 값으로, 정상 관측값에서 벗어난 값이거나, 지나치게 크거나 작아 정상범위에서 벗어난 값을 의미한다.

상자 수염 그림을 이용하면, 이상값을 찾아낼 수 있다.
근접값(Adjacent value): 안 울타리 안쪽 값 중 안 울타리에 가장 가까운 값
보통 이상값(Mild Outlier): 한쪽 방향에 대하여, 바깥 울타리, 안 울타리 사이의 값
극단 이상값(Extreme Outlier): 바깥 울타리 밖에 있는 값
근접값은 이상값에 가장 가까운 정상 범위 내 최대·최솟값이며, 이상값은 정상 범위(사분위간 범위)에서 크게 벗어난 값이므로, 연구자의 관점에 따라 데이터에서 제거, 혹은 집단의 재구성 등을 통한 이상값 처리를 해주는 것을 추천한다.

3.2. 상자 수염 그림 그리기

주어진 데이터 "키" 변수에 대하여, 상자 수염 그림을 그려보자.

fig = plt.figure(figsize=(10, 8))

plt.boxplot(Rawdata.키.to_numpy())

plt.title("키의 상자 수염 그림", fontsize = 20, pad = 30)
plt.ylabel("키", rotation = 0, fontsize = 15, labelpad = 20)
plt.show()

위 상자 수염 그림에서 상자(Box)는 사분위간 범위이다.
상자(Box) 안의 주황색 선은 중앙값이다.
상자 위아래에 달려 있는 'ㅜ', 'ㅗ' 모양의 선은 수염(Whisker)이다.
양쪽 수염의 끝은 정상 범위의 최대·최솟값이다.
수염 바깥의 동그란 점은 보통 이상값(mild outlier)이다.
위 데이터에는 극단 이상값(Extream outlier)이 존재하지 않으므로, 바깥 울타리는 보이지 않는다.

3.3. 상자 수염 그림에서의 정상범위의 최솟값과 최댓값 찾기

상자 수염 그림에서 정상범위의 최솟값과 최댓값을 뽑으면, 이상값을 구분할 수 있는 영역을 찾을 수 있다.
상자 수염 그림에서 정삼 범위 최솟값은 $Q1 - 1.5*IQR$이며, 최댓값은 $Q3 + 1.5*IQR$이다.

def Outlier_checker(data, column):
    
    target_array = data[column].to_numpy()
    Q1 = np.percentile(target_array, 25)
    Q3 = np.percentile(target_array, 75)
    IQR =  Q3 - Q1
    
    norm_min = Q1 - 1.5*IQR
    norm_max = Q3 + 1.5*IQR
    
    return norm_min, norm_max

>>> Outlier_checker(data, "키")
(139.75, 191.35000000000002)

위 결과를 볼 때, 키에서 139.75 cm 미만, 191.35cm 초과는 이상값임을 알 수 있다.

중심경향치(2) - 산술 평균, 기하 평균, 조화 평균, 모평균과 표본 평균이 같은 이유

만년필잉크 — Wed, 3 Mar 2021 17:30:45 +0900

중심경향치(Center Tendency)

이전 포스트에서는 최빈값, 중앙값을 구하는 방법에 대해 알아보았다. 이번 포스트에서는 가장 자주 사용되는 중심경향치인 산술 평균과 기하 평균, 조화 평균에 대해서 알아보도록 하자.

1. 산술 평균(Arithmetic mean)

주어진 수의 합을 수의 개수로 나눈 값인 산술 평균은, 통계학에서 가장 많이 사용되는 중심경향치로, 단순하게 평균(Mean)이라고 부르기도 한다.
중앙값처럼 산술 평균 역시, 양적 변수를 대상으로만 사용할 수 있다.

1.1. 산술평균의 정의

$N$ 개로 구성된 모집단의 관찰값 $X_1, X_2, X_3, ..., X_N$이 있다고 할 때, 모집단의 평균 $\mu$는 다음과 같이 구한다.

$$\mu = \frac{X_1 + X_2 + X_3 + \cdots X_N}{N} = \frac{1}{N}\sum_{i=1}^{N}X_i$$

통계학에서 같은 값을 구한다고 할지라도 모집단을 대상(모수)으로 하는지, 표본집단을 대상(통계량)으로 하는지에 따라, 공식이 약간 달라지게 된다.
평균은 모수와 통계량 모두 공식이 동일하지만, 사용하는 기호가 $\mu$에서 $\bar{x}$로 달라진다.

1.2 모평균과 표본평균이 동일한 이유.

앞서 산술평균에서 단순하게 모수와 통계량의 공식은 동일하지만, 모수는 $\mu$로 통계량은 $\bar{x}$로 사용하는 기호가 다르다고 했다. 이는, 모집단의 평균과 표본 집단의 평균값이 같다는 소리인데, 어떻게 이 것이 가능한 것일까?

먼저, 표본 집단을 완전 무작위로 추출한다고 가정해보자.
이 무작위 추출은 복원 추출(뽑은 값을 또 뽑을 수 있음)을 가정한다.
복원 추출을 가정한 완전 무작위 표본 추출이므로, 원소들이 뽑히는 사건은 서로 독립이다.

위 증명을 보면, 아주 쉽게 표본평균의 기댓값이 모평균과 같다는 것을 찾아내었다.
중간에 나온 원소가 1개인 표본 집합의 기댓값이 모평균과 같다는 이유는 무엇일까?

위와 같은 이유로, 원소가 1개인 표본평균의 분산이 모집단과 동일하다.
즉, 표본을 무수히 많이 뽑게 된다면, 표본 평균의 기댓값은 모평균과 동일하게 된다.

2. 파이썬으로 산술 평균 구하기.

2.1. 도수분포표로 평균 구하기

중앙값과 마찬가지로, 도수분포표로 평균을 추정할 수는 있으나, 실제 평균과 일치하지는 않는다.
원시 자료를 가지고 있는 상황이라면, 굳이 도수분포표를 구하고, 부정확한 평균을 추론할 필요는 없으나, 혹시나 구할 수 있는 데이터가 도수분포표밖에 없는 상황이 있을 수도 있으므로, 이를 가정하여, 도수분포표로 평균을 구하는 방법에 대해 알아보도록 하겠다.
사용할 데이터와 양적 변수의 범주화된 도수분포표 변환 함수는 다음과 같다.

Data_for_study.csv

3.39MB

import pandas as pd
import numpy as np

def make_freq_table(data, column):
    """
    -------------------------------------------------------------------------------
    지정된 변수의 관찰값이 20개보다 많은 경우, 10개의 등급을 가진 데이터를 반환한다.
    10개의 등급은 동일한 간격으로 자른 것이다.
    -------------------------------------------------------------------------------
    Input: DataFrame, str
    Output: DataFrame
    """
    # array 생성
    target_array = data[column].to_numpy()

    # class의 수가 20개보다 많은 경우 10개로 줄인다.
    class_array = np.unique(target_array)

    if len(class_array) > 20:

        min_key = class_array.min()
        max_key = class_array.max()
        split_key = np.linspace(min_key, max_key, 10)

        a0 = str(round(split_key[0], 2)) + " 이하"
        a1 = str(round(split_key[0], 2)) + " ~ " + str(round(split_key[1], 2))
        a2 = str(round(split_key[1], 2)) + " ~ " + str(round(split_key[2], 2))
        a3 = str(round(split_key[2], 2)) + " ~ " + str(round(split_key[3], 2))
        a4 = str(round(split_key[3], 2)) + " ~ " + str(round(split_key[4], 2))
        a5 = str(round(split_key[4], 2)) + " ~ " + str(round(split_key[5], 2))
        a6 = str(round(split_key[5], 2)) + " ~ " + str(round(split_key[6], 2))
        a7 = str(round(split_key[6], 2)) + " ~ " + str(round(split_key[7], 2))
        a8 = str(round(split_key[7], 2)) + " ~ " + str(round(split_key[8], 2))
        a9 = str(round(split_key[8], 2)) + " 이상"
        new_index = [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9]


        target_array= np.where(target_array <= split_key[0], 0,
                               np.where((target_array > split_key[0]) & (target_array <= split_key[1]), 1,
                                        np.where((target_array > split_key[1]) & (target_array <= split_key[2]), 2,
                                                 np.where((target_array > split_key[2]) & (target_array <= split_key[3]), 3,
                                                          np.where((target_array > split_key[3]) & (target_array <= split_key[4]), 4,
                                                                   np.where((target_array > split_key[4]) & (target_array <= split_key[5]), 5,
                                                                            np.where((target_array > split_key[5]) & (target_array <= split_key[6]), 6,
                                                                                     np.where((target_array > split_key[6]) & (target_array <= split_key[7]), 7,
                                                                                              np.where((target_array > split_key[7]) & (target_array <= split_key[8]), 8, 9)))))))))


    # 도수분포표 생성
    freq_table = pd.DataFrame(pd.Series(target_array).value_counts(), columns = ["freq"])
    freq_table.index.name = column

    freq_table.sort_index(inplace = True)
    freq_table["ratio"] = freq_table.freq / sum(freq_table.freq)
    freq_table["cum_freq"] = np.cumsum(freq_table.freq)
    freq_table["cum_ratio"] = np.round(np.cumsum(freq_table.ratio), 2)
    freq_table["ratio"] = np.round(freq_table["ratio"], 2)

    if "new_index" in locals():
        freq_table.index = new_index
        freq_table.index.name = column

    return freq_table

키에 대하여 범주화된 도수분포표를 뽑아보자.

Rawdata = pd.read_csv("Data_for_study.csv")
make_freq_table(Rawdata, "키")

범주화된 도수분포표를 이용한 평균 계산은 각 등급(Class)의 중앙값에 각 빈도를 곱해 평균을 계산한다.
위와 같이 136 이하, 189.33 이상이 존재하는 경우, 두 등급에 속하는 빈도가 전체에서 차지하는 비중이 매우 작으므로, 단순하게 우리가 알고 있는 136, 189.33에 대하여 빈도를 곱하거나, 이상치로 보고 제거해도 된다.
애초에 도수분포표를 이용해 중심경향치를 계산하는 것은 정확한 값을 얻기 위해서가 아닌, 대략적인 값을 얻기 위해서이므로, 이번에는 저 두 값에 그냥 빈도를 곱하도록 하겠다.

>>> ((136.0*1)+((142.67+136.0)/2*70)+((149.33+142.67)/2*869)+((156.0+149.33)/2*7079)+
    ((162.67+156.0)/2*14131)+((169.33+162.67)/2*14640)+((176.0+169.33)/2*12492)+
    ((182.67+176.0)/2*5118)+((189.33+182.67)/2*1241)+(189.33*107))/55748
    
165.47919010547466

위 코드처럼 값을 하나하나 쓰기 싫은 사람을 위해, pandas의 str 모듈을 사용해 계산하는 방법도 보도록 하겠다.

>>> 키_도수분포표 = make_freq_table(Rawdata, "키")
>>> 키_도수분포표.reset_index(drop=False, inplace=True)

# 1 부터 8번 행까지 처리
>>> 키1_8_array = 키_도수분포표[1:9].키.str.split(" ~ ", expand=True).values.astype("float")
>>> 키1_8_sum = np.sum(((키1_8_array[:,0] + 키1_8_array[:,1])/2) * 키_도수분포표[1:9].freq.to_numpy())

# 0, 9 행 처리
>>> 키0_9_array = 키_도수분포표.loc[[0,9]].키.str.partition(" ")[0].to_numpy().astype("float")
>>> 키0_9_sum = np.sum(키0_9_array * 키_도수분포표.loc[[0,9]].freq.to_numpy())

>>> 평균키 = (키1_8_sum + 키0_9_sum)/키_도수분포표.freq.sum()
>>> 평균키
165.4791901054746

0번행과 9번행은 1~8번행까지와 구간의 패턴이 다르므로, 이를 분리하여, 원하는 값만 추출하여 평균을 구했다.
위에서 숫자를 일일이 복사 붙여넣기한 것과 같은 결과가 나왔다.

2.2. 파이썬으로 산술 평균 구하기

원시자료를 가지고 있는 경우, 위 같이 번거로운 과정 없이 아주 편하게 평균을 구할 수 있다.

>>> Rawdata.키.mean()
165.5272655521264

>>> np.mean(Rawdata.키.to_numpy())
165.52726555212743

Series.mean()은 pandas 함수로 평균을 구하는 것이다.
np.mean(array)는 numpy 함수로 평균을 구하는 것이다.
실제 평균과 위에서 도수분포표를 이용해서 추론한 평균이 꽤 유사한 것을 알 수 있다.

3. 기타 산술 평균

3.1. 가중 평균(Weighted mean)

서로 다른 집단에 대하여, 다른 가중치를 부여하여 평균을 내는 방법
집단의 크기가 서로 다르거나, 다른 점수 배점을 가질 때, 사용하는 방법이다.
예를 들어, A반은 10명, B반은 40명일 때, A반과 B반의 평균을 동일하게 생각하고 $\bar{X_A}$와 $\bar{X_B}$를 더하고 평균을 내면 안 된다.
이 경우, A반은 전체에서 차지하는 비중인 $\frac{10}{50}$만큼 평균 $\bar{X_A}$ 곱해주고, B반은 전체에서 차지하는 비중인 $\frac{40}{50}$만큼 평균 $\bar{X_B}$에 곱해주고 이 둘을 더해줘야 한다.
즉, A반의 평균이 $\bar{X_A} = 60$이고, B반의 평균이 $\bar{X_B} = 70$이라면, 두 반의 평균은 $\frac{60+70}{2}=65$이 아닌, $0.2\bar{X_A} + 0.8\bar{X_B}= 0.2 * 60 + 0.8 * 70 = 68$점이 된다.

3.2. 절삭 평균(Trimmed mean)

이상치인 극단적으로 크거나 작은 값을 제거하고 평균을 내는 방법이다.
예를 들어, A라는 마을의 실제 평균 월급은 250만 원인데, 그 동네에 빌 게이츠가 살아서 평균 월급이 1,000만 원이 나와버린다면, 그 평균은 실제 데이터가 모여 있는 곳을 보여준다고 할 수 없다.
물론, 이상치를 제거한다면, 이상치가 제거된 것을 집단의 크기에도 반영해야 한다.

4. 기하 평균(Geometric mean)

기하 평균은 $n$개의 양수 값을 모두 곱하고, $n$ 제곱근을 해준 것이다.
기하 평균은 지금까지 우리가 다뤘던 변수들과 달리 곱셈으로 계산하는 값에서 사용된다.
변수가 비율로 구성된 경우, 기하 평균을 사용하면 된다.
$n$ 개로 구성된 모집단의 관찰 값 $a_1, a_2, a_3, ..., a_n$이 있다고 할 때, 기하 평균은 다음과 같이 구한다.

$$(\prod_{i=1}^{n}a_i)^{\frac{1}{n}} = (a_1\cdot a_2 \cdot a_3\cdots a_n)^{\frac{1}{n}}=\sqrt[n]{a_1\cdot a_2 \cdot a_3\cdots a_n}$$

앞서 보았던 산술평균은 합의 평균이고, 기하 평균은 곱의 평균이다.
기하평균의 대상인 변수의 모든 관찰 값은 양수여야 한다(제곱근을 사용하므로).
로그 항등식을 사용하여 기하평균 공식을 변환시키면, $f(n) = ln x$일 때의 일반화된 f-평균이 만들어진다.

$$ln(a_1\cdot a_2 \cdot a_3\cdots a_n)^{\frac{1}{n}} = \frac{lna_1 + lna_2 + lna3 + \cdots + lna_n}{n}$$

4.1 파이썬으로 기하평균 구하기

아래와 같은 데이터가 있다고 가정해보자.

salary = [0.85, 1.1, 1.5, 0.95, 2.0, 1.05]

해당 데이터는 월급 200만 원을 1로 놓고, 6명의 월급의 비율을 본 것이다.
즉, $a_1$은 $200*0.85=170$만원을 월급으로 받고, $a_2$는 $200*1.1=220$만원을 월급으로 받는다는 의미다.
위 데이터의 기하 평균은 다음과 같다.

>>> (0.85*1.1*1.5*0.95*2.0*1.05)**(1/6)
1.187064439031504

4.2. Numpy로 구하기

반복문을 사용하는 방법 말고 기하평균을 Numpy로 구하는 방법은 크게 2가지가 있다.

array의 모든 원소를 곱하고, 출력된 스칼라에 n 제곱근 씌우기
array를 모두 로그 치환하고, 그에 대한 산술 평균을 구한 후, 지수로 원 상태로 만들어주기

4.2.1. 방법 1.

# 방법 1.
>>> salary_A = np.array(salary)
>>> np.prod(salary_A)**(1/len(salary_A))
1.187064439031504

np.prod(array): 배열의 모든 인자들을 곱한다.

4.2.2. 방법 2.

자연로그의 평균을 구하고, 아래 로그의 성질을 사용하여, 기하 평균을 구하는 방법도 있다.

$$\log_xy = A \rightarrow x^A = y$$

# 방법 2
>>> np.exp(1) ** (np.mean(np.log(salary_A)))
1.1870644390315037

np.exp(1): 자연로그의 밑인 2.718281...이다.
np.log(array): array의 모든 원소를 자연로그로 변환시킨다.

4.3. statistics 라이브러리 사용하기

>>> import statistics as stat
>>> stat.geometric_mean(salary_A)
1.187064439031504

statistics 라이브러리는 굉장히 많은 수학적 통계 계산 함수를 제공한다.
개인적으로는 statistics 함수를 사용하기보다는 numpy가 성능이 더 좋으므로, numpy를 사용하길 추천한다.

5. 조화 평균(Harmonic mean)

조화 평균은 주어진 값들의 역수의 산술 평균의 역수다.
평균 변화율을 구할 때 주로 사용한다.
$n$ 개로 구성된 모집단의 관찰 값 $a_1, a_2, a_3, ..., a_n$이 있다고 할 때, 조화 평균은 다음과 같이 구한다.

$$H = \frac{n}{\frac{1}{a_1} + \frac{1}{a_2} + \frac{1}{a_3} + \cdots + \frac{1}{a_n}}$$

조화평균은 속도와 같은 변화율의 평균을 구할 때, 매우 유용하다.
예를 들어, 전체 거리의 절반은 40km/h로 이동하고, 나머지 절반을 60km/h로 이동하였다면, 평균 속력은 산술 평균인 50km/h가 아닌 조화 평균인 48km/h가 된다.
동일한 거리에 대하여 소모된 시간이 다르므로, 단순하게 산술 평균을 구한다면, 평균 속력을 구할 수 없다.
위와 같은 경우엔, 시간의 차원에서 평균을 구해야하므로, 시간에 대하여 값을 바꿔주고, 평균을 구한 후, 다시 속력으로 바꿔보자.
거리를 $S$라 가정하고, 속도를 $V$라고 가정 하자.

5.1. 변화율(Rate of change)

두 변수의 변화 정도를 비율로 나타낸 것이다.
미분에서 $\frac{dy}{dx}$라는 단어가 나오는데, 이는 변수 $x$에 대한 변수 $y$의 변화율을 의미한다.
평균변화율(Average rate of change):
어떤 함수 $f(x)$가 있다고 할 때, 두 점 $A(a, f(a)), B(b, f(b))$에 대하여(단, $a<b$이다.), 두 점을 이어 만든 직선의 기울기를 말한다.
함수 $y=f(x)$에서 $x$의 값이 $a$부터 $a + \bigtriangleup x $까지 변한다고 하면, 아래 식을 $[a, a+\bigtriangleup x]$에서의 $y$의 평균변화율이라 한다.

$$\frac{\bigtriangleup y}{\bigtriangleup x} = \frac{f(a+\bigtriangleup x) - f(a)}{\bigtriangleup x}$$

5.2. 파이썬으로 조화 평균을 구해보자

V_array = np.array([20, 30, 50, 30, 60, 40, 80])

다음과 같은 속도 데이터가 있다고 가정해보자.
조화 평균을 사용하여, 평균 속력을 구해보자.

5.2.1. Numpy로 구해보자.

조화 평균은 역수 평균의 역수이므로, numpy의 Broadcast를 사용하면 쉽게 구할 수 있다.

>>> 1/(np.mean(1/V_array))
36.68122270742358

5.2.2. statistics 라이브러리 사용하기

>>> stat.harmonic_mean(V_array)
36.68122270742358

6. 기하 평균과 조화 평균의 주의사항

0인 표본 값이 존재하는 경우, 사용할 수가 없다.
- 기하평균은 곱의 평균이므로, 원소에 0이 있는 경우 곱하여 0이 된다.
- 조화 평균은 역수의 평균의 역수인데, 0의 역수는 무한대로 발산한다.
표본 값이 모두 양수여야 한다.
- 기하평균은 비율, 배수에 대한 것인데, 음수가 나올 수가 없다.
- 조화수열의 대상인 변화율의 음수는 벡터로써 방향이 반대를 의미한다.
변수가 비율 혹은 배수이지만, 각 표본 값이 독립적일 때 사용할 수 있다.
- 표본 값끼리 곱했을 때, 어떠한 의미도 갖지 않아야 서로 독립적이라 할 수 있다.

중심경향치(1) - 최빈값, 중앙값

만년필잉크 — Wed, 3 Mar 2021 13:54:31 +0900

중심경향치(Center Tendency)

◎ 중심경향치: 관찰된 자료들이 어디에 집중되어 있는지를 나타낸다.

통계학은 기본적으로 데이터가 어디에 모이고, 얼마나 흩어지는지를 통해서 데이터의 성격을 파악한다. 중심경향치는 데이터가 어디에 모이는지를 보는 것으로, 최빈값, 중앙값, 평균 등의 다양한 지표를 이용하여, 데이터가 모인 곳을 찾아낸다.

그렇다면, 그 데이터가 모이고 흩어진다는 것이 대체 무슨 말일까? 이를 알기 위해, 이전 포스트에서 학습했던 내용을 바탕으로 이를 눈으로 확인해보자.

0. 데이터가 모이고 흩어진다는 것은 무엇일까?

이전 포스트에서 사용했던 데이터를 가지고 오고, 모든 변수들을 히스토그램으로 시각화해보자.

Data_for_study.csv

3.39MB

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

Rawdata = pd.read_csv("Data_for_study.csv")

plt.rc('font', family='NanumGothic')
Rawdata.hist(figsize=(16,25), layout=(5,3), grid=False,density=True)

plt.show()

위 코드는 pandas와 matplotlib.pyplot 두 가지를 사용하여, DataFrame 내에 있는 변수들을 시각화해주며, 히스토그램은 그 변수가 무엇이든 간에, 그 변수의 빈도를 이용해 그래프를 그린다. 또한, bins 파라미터를 통해, 키, 몸무게 같은 비율 척도는 실제 형태보다 단순화시켜, 모든 변수들의 추이를 쉽게 파악할 수 있다.
위 히스토그램들을 보면, "주중_인터넷이용시간"은 주로 0 ~ 100 사이에 가장 많은 데이터가 모여 있으며, 흩어진 정도는 그리 크지 않다는 것을 알 수 있다.
이러한 변수별 데이터가 어디에 모여있는지를 하나의 값으로 확인할 수 있는 방법이 바로 중심경향치다.

1. 최빈값(Mode)

◎ 최빈값(Mode): 빈도수가 가장 큰 관찰값

도수분포표에서 가장 값이 많이 모여 있는 관찰 값을 의미한다.
양적 자료, 질적 자료에서 모두 사용되나, 일반적으로 질적 자료에서 더 자주 사용된다.
위에서 불러온 데이터에서 명목변수: "흡연경험", 등간변수(리커트 5점 척도): "스트레스인지", 비율 변수: "몸무게"에 대하여 최빈값을 구해보자.

1.1. 도수분포표를 사용하여 최빈값 구하기

최빈값을 구하는 방법은 도수분포표를 구하고, 가장 빈도수가 높은 관찰 값을 선택하는 방법이 있다.
연속형 변수를 구간 화하는 것은 꽤 귀찮은 일이므로, 20개 이상의 관찰 값을 갖는 경우, 10개의 구간을 갖는 변수로 변환하여 도수분포표를 출력하는 함수를 만들었다.

def make_freq_table(data, column):
    """
    -------------------------------------------------------------------------------
    지정된 변수의 관찰값이 20개보다 많은 경우, 10개의 등급을 가진 데이터를 반환한다.
    -------------------------------------------------------------------------------
    Input: DataFrame, str
    Output: DataFrame
    """
    # array 생성
    target_array = data[column].to_numpy()

    # class의 수가 20개보다 많은 경우 10개로 줄인다.
    class_array = np.unique(target_array)

    if len(class_array) > 20:

        min_key = class_array.min()
        max_key = class_array.max()
        split_key = np.linspace(min_key, max_key, 10)

        a0 = str(round(split_key[0], 2)) + " 이하"
        a1 = str(round(split_key[0], 2)) + " ~ " + str(round(split_key[1], 2))
        a2 = str(round(split_key[1], 2)) + " ~ " + str(round(split_key[2], 2))
        a3 = str(round(split_key[2], 2)) + " ~ " + str(round(split_key[3], 2))
        a4 = str(round(split_key[3], 2)) + " ~ " + str(round(split_key[4], 2))
        a5 = str(round(split_key[4], 2)) + " ~ " + str(round(split_key[5], 2))
        a6 = str(round(split_key[5], 2)) + " ~ " + str(round(split_key[6], 2))
        a7 = str(round(split_key[6], 2)) + " ~ " + str(round(split_key[7], 2))
        a8 = str(round(split_key[7], 2)) + " ~ " + str(round(split_key[8], 2))
        a9 = str(round(split_key[8], 2)) + " 이상"
        new_index = [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9]


        target_array= np.where(target_array <= split_key[0], 0,
                               np.where((target_array > split_key[0]) & (target_array <= split_key[1]), 1,
                                        np.where((target_array > split_key[1]) & (target_array <= split_key[2]), 2,
                                                 np.where((target_array > split_key[2]) & (target_array <= split_key[3]), 3,
                                                          np.where((target_array > split_key[3]) & (target_array <= split_key[4]), 4,
                                                                   np.where((target_array > split_key[4]) & (target_array <= split_key[5]), 5,
                                                                            np.where((target_array > split_key[5]) & (target_array <= split_key[6]), 6,
                                                                                     np.where((target_array > split_key[6]) & (target_array <= split_key[7]), 7,
                                                                                              np.where((target_array > split_key[7]) & (target_array <= split_key[8]), 8, 9)))))))))


    # 도수분포표 생성
    freq_table = pd.DataFrame(pd.Series(target_array).value_counts(), columns = ["freq"])
    freq_table.index.name = column

    freq_table.sort_index(inplace = True)
    freq_table["ratio"] = freq_table.freq / sum(freq_table.freq)
    freq_table["cum_freq"] = np.cumsum(freq_table.freq)
    freq_table["cum_ratio"] = np.round(np.cumsum(freq_table.ratio), 2)
    freq_table["ratio"] = np.round(freq_table["ratio"], 2)

    if "new_index" in locals():
        freq_table.index = new_index
        freq_table.index.name = column

    return freq_table

np.linspace(start, end, num): start부터 end까지 num개를 일정한 간격으로 자르는 함수로, 아주 간편하게, 연속형 데이터를 범주화할 수 있다.
흡연경험의 도수분포표

make_freq_table(Rawdata, "흡연경험")

명목 변수인 흡연경험의 최빈값은 1.0인 것을 알 수 있다. 청소년건강행태조사 이용지침서 참고 시, "없다"가 88%로 가장 많이 등장하였다.

make_freq_table(Rawdata, "스트레스인지")

등간 변수(리커트 척도)인 스트레스인지의 최빈값은 3.0인 것을 알 수 있다. 청소년건강행태조사 이용지침서 참고 시, "조금 느낀다"가 가장 많이 등장하였다.

make_freq_table(Rawdata, "몸무게")

비율 변수인 몸무게에서 제일 많이 등장한 등급(Class)는 45.87 ~ 56.3 kg인 것을 알 수 있다. 표본집단인 중·고등학생 중 36%가 해당 구간에 존재한다.

1.2. 파이썬을 이용하여 최빈값 구하기

도수분포표를 일일이 구하고, 최빈값을 구하는 일은 꽤 번거로운 일이다.
데이터 분석에서 기본적으로 사용되는 라이브러리 중 하나인 pandas는 다양한 기본 함수를 제공하여, 이러한 문제를 쉽게 해결할 수 있게 해 준다.
Series.mode(): 최빈값을 출력한다.

>>> 흡연경험_최빈값 = Rawdata.흡연경험.mode()
>>> 흡연경험_최빈값
0    1.0
dtype: float64


>>> 스트레스인지_최빈값 = Rawdata.스트레스인지.mode()
>>> 스트레스인지_최빈값
0    3.0
dtype: float64


>>> 몸무게_최빈값 = Rawdata.몸무게.mode()
>>> 몸무게_최빈값
0    60.0
dtype: float64

Series.mode()는 Series로 결과를 출력한다.
양적 변수라 할지라도, 바로 최빈값을 찾는 경우, 굳이 도수분포표를 만드는 수고를 할 필요가 없으므로, 구간을 만드는 수고를 하지 않아도 된다.
이번에는, 최빈값에 해당하는 빈도수를 출력해보자.

# 최빈값과 최빈값 도수 출력
def mode_value_printer(data, column):
    
    mode_ = data[column].mode().values[0]
    freq =len(data[data[column] == mode_])
    
    print(f"{column} - 최빈값: {mode_}, 도수: {freq}")

>>> mode_value_printer(Rawdata, "흡연경험")
흡연경험 - 최빈값: 1.0, 도수: 48995

>>> mode_value_printer(Rawdata, "스트레스인지")
스트레스인지 - 최빈값: 3.0, 도수: 22915

>>> mode_value_printer(Rawdata, "몸무게")
몸무게 - 최빈값: 60.0, 도수: 2350

보시다시피 pandas 기본 함수를 사용하면, 아주 쉽게 최빈값과 그에 해당하는 도수를 찾을 수 있다.
그러나, 양적 변수, 그중에서도 관찰 값이 매우 많은 변수는 범주화를 시키는 것과, 단순하게 가장 많이 등장한 관찰 값을 찾는 것이 다른 결과를 가져온다.
때문에 양적 변수에서는 중심경향치를 확인하고자 할 때, 최빈값보다는 평균, 중위수와 같은 다른 값을 추출하는 경우가 더 많다(물론, 연구자의 의도에 따라 최빈값 역시 필요할 수 있으므로, 절대 양적 변수에 최빈값을 사용하지는 않는다고 생각해선 안된다).

2. 중앙값(Median)

◎ 중앙값(Median): 수치로 된 자료를 크기 순서대로 나열할 때, 가장 가운데에 위치하는 관찰값을 말한다.

$$Md = \frac{(n+1)}{2}$$

중앙값은 순서, 일정한 간격을 가지고 있는 양적 변수에 대해서만 사용 가능하며, 말 그대로 한 변수 내 모든 관찰값들의 중앙에 있는 값을 가리킨다.
중앙값에서 이슈라고 할 수 있는 것은 관찰값의 수가 짝수인지 홀수인지로, 아래 예시를 보자.

$$ A = {1, 3, 4, 7, 8, 10, 11, 15, 16}$$

위 예시 같이 집합 내 원소의 수가 홀수인 경우에는 그냥 $\frac{9+1}{2}=5$에 있는 관찰값을 중앙값으로 하면 되지만, 짝수인 경우는 조금 다르다.

$$ B = {2, 4, 6, 7, 9, 10} $$

위 예시 같이 집합 내 원소의 수가 짝수인 경우에는 $\frac{6+1}{2} = 3.5$가 되어, 3.5번째에 있는 관찰값을 중앙값으로 사용해야 하나, 3.5번째 관찰값은 존재할 수 없다.
이 때는, 3번째 관찰값인 6과 4번째 관찰값인 7의 평균을 중앙값으로 사용한다. 즉, $\frac{6+7}{2} = 6.5$가 중앙값이 된다.

2.1. 도수분포표를 이용하여 연속형 데이터의 중앙값 구하기

중앙값은 관찰값들의 중앙에 있는 값이므로, 도수분포표를 사용하지 않고 구할 수 있고, 그것이 정석이다.
그러나, 항상 모든 관찰값들을 알 수 있는 것이 아니고, 때에 따라서는 도수분포표를 사용해서 중앙값을 유추해야할 필요도 있다.
(물론, 원시자료를 손 델 수 있다면, 굳이 그럴 필요는 없지만!)
이번에는 범주화된 연속형 데이터의 도수분포표를 이용해서 중앙값을 구해보자.
위에서 만든 make_freq_table함수를 이용해서 키에 대한 도수분포표를 만들어보자.

make_freq_table(Rawdata, "키")

총데이터의 양은 55748개이며, 55748의 중앙값은 $\frac{55748+1}{2} = 27874.5$이다. 즉, 27,874.5번째에 있는 값이 있는 구간이 중앙값이다.
누적빈도를 볼 때, 27,874.5는 162.67 ~ 169.33 구간에 존재하므로, 중앙값이 있는 구간은 162.67 ~ 169.33임을 알 수 있다.
이 구간 안에서 비율을 사용해서 중앙값을 유추해보자

위 방법처럼 관찰 값의 비율과 빈도의 비율을 이용하면, 중위수를 유추해낼 수 있다.
실제 중위수랑 비교해보자.

>>> Rawdata.키.median()
165.0

실제 중위수와 도수분포표를 사용해서 유추한 중위수가 상당히 유사한 것을 알 수 있다.

2.2. 파이썬을 이용하여 중위수 구하기

파이썬을 이용해 중위수를 구하는 것은 정말 단순하다.

>>> Rawdata.스트레스인지.median()
3.0

>>> Rawdata.몸무게.median()
57.0

Series.median()을 사용하면, 중위수를 구할 수 있다.
numpy 함수를 사용하는 경우는 다음과 같다.

>>> np.median(Rawdata.스트레스인지.to_numpy())
3.0

>>> np.median(Rawdata.몸무게.to_numpy())
57.0

np.median(array)를 사용해서 중위수를 구하면 된다.

지금까지 최빈값과 중앙값을 구해보았다. 다음 포스트에서는 가장 대표적인 중심경향치인 평균에 대해 자세히 알아보도록 하겠다.

도수분포표와 시각화

만년필잉크 — Tue, 2 Mar 2021 17:42:15 +0900

도수분포표와 시각화

앞서 도수분포표에서 봤듯, 도수분포표는 수집한 데이터의 분포를 알기 위해 사용한다. 그러나 여전히 숫자만으로 데이터를 파악하기 때문에 데이터의 분포를 명확하게 이해하기 어려울 수도 있다. 도수분포표를 시각화한다면, 보다 쉽게 데이터의 분포를 파악할 수 있다.

도수분포표의 시각화이므로, 들어간 데이터의 도수(빈도)를 시각화 하는 것이다.
파이썬으로 도수분포표를 시각화하는 방법은 크게 두가지가 있다.

범주화된 데이터를 사용해서 히스토그램을 만들기
도수분포표 생성 후, 도수분포표를 기반으로 그래프 그리기

개인적으로 추천하는 방법은 도수분포표를 먼저 생성하고, 그래프를 그리는 것으로, 도수분포표 연산이 한 번 이루어지고 나면, 나머지 과정은 자원을 거의 먹지 않는다.
도수분포표만 만들면, 이를 이용해서 히스토그램(막대그래프 사용), 도수분포다각형, 누적도수분포곡선 3가지를 모두 쉽게 그릴 수 있다.

1. 히스토그램

히스토그램은 가장 대표적인 도수분포표의 시각화 방법이다.
위에서 설명한 파이썬으로 도수분포표 시각화를 하는 첫 번째 방법으로, 원본 데이터(범주화가 된)를 사용해서 히스토그램을 그리는 것이다.
히스토그램은 막대그래프로 한 변수를 구성하는 각 집단의 빈도를 이용하여, 막대 그래프를 그리는 것이다.
이전 데이터에서 사용했던, 청소년건강행태조사 2019년 데이터에서 일부 변수만 추려낸 데이터를 사용해보자.

Data_for_study.csv

3.39MB

"건강인지"를 히스토그램으로 나타내보자.

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

Rawdata = pd.read_csv("Data_for_study.csv")

# 한글 사용
plt.rc('font', family='NanumGothic')

# 전체 그래프 크기
fig = plt.figure(figsize=(8, 6))

# 히스토그래프 그리기
plt.hist(Rawdata.건강인지.to_numpy(), bins=9)

# x축 ticks 지정
plt.xticks(np.arange(1, 6), labels=["매우 좋음", "좋음", "보통", "나쁨", "매우 나쁨"])
plt.tick_params(axis="x", direction="in", labelsize = 12, pad = 20)

# title, xlabel, ylabel 지정
plt.title("건강인지 히스토그램", fontsize = 30, pad = 30)
plt.xlabel('건강인지', fontsize = 20, loc = 'center', labelpad = 20)
plt.ylabel('도수', fontsize = 20, rotation = 0, loc='center', labelpad = 30)

plt.show()

plt.hist(density=True)로 지정해주면, 빈도가 아닌, 비율로 나타낼 수도 있다.
그러나, 이 비율은 히스토그램 전체를 1로 하는 비율이 아닌, 최대 빈도를 1로 하는 비율이다.

fig = plt.figure(figsize=(8, 6))

plt.hist(Rawdata.건강인지.to_numpy(), bins=9, density=True)
plt.xticks(np.arange(1, 6), labels=["매우 좋음", "좋음", "보통", "나쁨", "매우 나쁨"])
plt.tick_params(axis="x", direction="in", labelsize = 12, pad = 20)

plt.title("건강인지 히스토그램", fontsize = 30, pad = 30)

plt.xlabel('건강인지', fontsize = 20, loc = 'center', labelpad = 20)
plt.ylabel('도수', fontsize = 20, rotation = 0, loc='center', labelpad = 30)


plt.show()

입력된 데이터는 숫자지만, 실제로는 문자인 Factor이므로, label을 문자로 입력하였다.

>>> Rawdata.건강인지.to_numpy()
array([1., 1., 2., ..., 4., 3., 3.])

실제 정의에 맞게 하려면, 다음과 같이 숫자를 원래 형태인 문자로 바꿔주고, 문자 배열에 대한 도수를 히스토그램으로 그려야 한다.

건강인지 = Rawdata.건강인지.to_numpy()
건강인지 = np.where(건강인지==1, "매우 좋음",
                np.where(건강인지==2, "좋음",
                         np.where(건강인지==3, "보통",
                                  np.where(건강인지==4, "나쁨", "매우 나쁨"))))

2. 도수분포다각형

도수분포다각형은 히스토그램의 각 중간점을 이어서 그린 것으로, 데이터가 연속적인 경우에 사용한다.
도수분포다각형을 사용하면, 분포의 윤곽이 보다 명확하게 보이며, 빈도의 증감을 보다 명확히 볼 수 있다.
또한, 서로 다른 집단에 대한 도수분포를 같은 그림 위에서 비교할 수 있다는 장점이 있다.
도수분포다각형, 누적도수분포곡선은 도수분포표를 기반으로 그리는 것이 훨씬 쉽다(히스토그램 역시, 이미 생성된 도수분포표를 기반으로 막대그래프로 그리는 것이 추가 연산 시간이 없으므로 쉽다).
이전 포스트에서 만들었던, 16세 남성의 키와 16세 여성의 키를 10cm 간격으로 범주화한 도수분포표를 대상으로 해서 만들어보도록 하자.
총합은 도수분포표를 이해하기 좋게 만든 것이므로, 제거하고, 필요한 각 클래스별 값만 유지하겠다.

def cat_height(array):
    cat_array = np.where(array<=140, "140 이하",
                     np.where((array>140) & (array<=150), "140~150",
                              np.where((array>150) & (array<=160), "150~160",
                                       np.where((array>160) & (array<=170), "160~170",
                                                np.where((array>170) & (array<=180), "170~180",
                                                         np.where((array>180) & (array<=190), "180~190", "190 이상"))))))
    return cat_array
    
    
def Freq_table(array):

    freq_table = pd.DataFrame(pd.Series(array).value_counts(), columns=["freq"])
    freq_table.sort_index(inplace = True)
    freq_table["ratio"] = freq_table.freq / sum(freq_table.freq)
    freq_table["cum_freq"] = np.cumsum(freq_table.freq)
    freq_table["cum_ratio"] = np.round(np.cumsum(freq_table.ratio), 2)
    freq_table["ratio"] = np.round(freq_table["ratio"], 2)

    return freq_table
    
남자_16세_키 = Rawdata[(Rawdata["연령"] == 16) & (Rawdata["성별"] == 1.0)]["키"].to_numpy()
여자_16세_키 = Rawdata[(Rawdata["연령"] == 16) & (Rawdata["성별"] == 2.0)]["키"].to_numpy()

M_DF = Freq_table(cat_height(남자_16세_키))
F_DF = Freq_table(cat_height(여자_16세_키))

fig = plt.figure(figsize=(8, 6))

plt.plot(F_DF.index, F_DF.ratio, label = "Female, 16 years old")
plt.plot(M_DF.index, M_DF.ratio, linestyle = "--", label = "Male, 16 years old")

plt.title("16세 남성 & 여성 키 도수분포다각형",fontsize = 20, pad = 20)
plt.xlabel("키", fontsize = 15)
plt.ylabel("비율", fontsize = 15, rotation = 0, labelpad = 30)
plt.legend(loc="upper right")

plt.show()

생성된 두 집단의 도수분포표를 상대적으로 비교하기 위해, 상대 빈도인 비율을 사용하여 그래프를 그렸다.
도수분포다각형이 히스토그램의 꼭짓점을 연결한 것임을 보기 위해 히스토그램도 뒤에 연하게 그려보자.

fig = plt.figure(figsize=(8, 6))


plt.plot(F_DF.index, F_DF.ratio, label = "Female, 16 years old")
plt.plot(M_DF.index, M_DF.ratio, linestyle = "--", label = "Male, 16 years old")

plt.bar(F_DF.index, F_DF.ratio, alpha = 0.4, color = "blue")
plt.bar(M_DF.index, M_DF.ratio, alpha = 0.4, color = "yellow")

plt.title("16세 남성 & 여성 키 도수분포다각형",fontsize = 20, pad = 20)
plt.xlabel("키", fontsize = 15)
plt.ylabel("비율", fontsize = 15, rotation = 0, labelpad = 30)
plt.legend(loc="upper right")

plt.show()

동일한 비율을 사용하기 위해 plt에서 histogram 함수가 아닌 막대그래프인 bar를 가지고 왔다.
히스토그램과 막대그래프는 본질이 다르지만, 도수분포표를 사용해서 그린다면 히스토그램과 막대그래프는 동일한 결과를 가지고 온다.
(히스토그램은 데이터가 한 차원만 들어가고, 그 빈도로 그래프를 그린다. 막대그래프는 두 차원의 데이터가 필요하며, 그 두 차원의 데이터를 이용해서 그래프를 그린다)
가지고 있는 전체 데이터를 이용해서 그래프를 그린다면 히스토그램을 사용하고, 이미 도수분포표를 만들었다면, 막대그래프를 그리길 추천한다.

3. 누적도수분포곡선

누적도수분포곡선은 위에서 도수분포다각형을 그렸던 방법에서, y축에 들어가는 데이터만 누적 도수로 바꾸면 된다.
이번에도 두 집단을 비교하기 쉽도록, 비율로 구해보도록 하겠다.

fig = plt.figure(figsize=(8, 6))


plt.plot(F_DF.index, F_DF.cum_ratio, label = "Female, 16 years old")
plt.plot(M_DF.index, M_DF.cum_ratio, linestyle = "--", label = "Male, 16 years old")

plt.bar(F_DF.index, F_DF.cum_ratio, alpha = 0.4, color = "blue")
plt.bar(M_DF.index, M_DF.cum_ratio, alpha = 0.4, color = "yellow")

plt.title("16세 남성 & 여성 키 누적도수분포곡선",fontsize = 20, pad = 20)
plt.xlabel("키", fontsize = 15)
plt.ylabel("비율", fontsize = 15, rotation = 0, labelpad = 30)
plt.legend(loc="lower right")

plt.show()

지금까지 파이썬을 사용해서 도수분포표의 시각화를 해보았다. 개인적으로는 도수분포표를 먼저 구하고, 그 도수분포표를 바탕으로 시각화를 진행하길 바란다.

도수분포표

만년필잉크 — Tue, 2 Mar 2021 14:03:29 +0900

도수분포표(Frequency Distribution Table)

◎ 도수분포표: 수집된 데이터를 분류한 후, 각 분류에 해당하는 데이터의 빈도, 비율 등으로 정리한 표를 말한다.

앞서 통계학은 크게 기술통계학(Descriptive statistics)과 추론통계학(Inferential statistics) 이 두 가지로 나뉘며, 이 둘은 별개의 존재가 아니라, 기술통계학 > 추론통계학순으로 순차적으로 이루어진다고 하였다.

기술통계학은 말 그대로 데이터가 가지고 있는 정보를 기술(Describe)하는 것이며, 도수분포표는 데이터의 각 범주별 빈도수와 비율을 이용하여, 데이터를 설명하는 방법으로 기술통계학의 기초가 되는 기법이다.

백 마디 말보다, 한 번 실제 만들어보는 것이 가장 좋은 방법이니, 실제로 도수분포표를 만들어보고, 도수분포표가 어떻게 생겼고, 도수분포표를 이용해서 무엇을 할 수 있기에 기술통계학의 기초가 되는 것인지 알아보도록 하자.

도수분포표를 학습할 때, 집단을 잘 구분하는 것이 중요하다.
한 변수 안에는 $m$개의 데이터가 존재하는데, 이 $m$개의 데이터를 중복을 제거하면 $n$개의 데이터가 남게 된다($m$ ≥ $n$).
이 중복이 없는 $n$의 데이터는 한 원소 안의 집단(Group), 등급(Class) 두 가지 용어로 부를 수 있는데, 본 포스트에서는 이해하기 쉽도록, 선택된 군은 집단(Group)으로, 한 변수 안의 중복이 제거된 데이터의 군은 등급(Class)라 부르겠다.

1. Python을 사용하여, 기본적인 도수분포표를 만들어보자.

1.1. 데이터 가지고 오기

이전 포스트(참고: "통계 분석을 위한 데이터 준비")에서 생성한 데이터를 기반으로 통계 분석을 진행하도록 하겠다. 해당 데이터는 청소년건강행태조사 2019년 데이터에서 대표적인 16개 변수만 선택하고, 간단하게 결측값을 처리한 데이터다. 보다 상세한 설명이 필요한 경우 위 참고를 보길 바란다.

Data_for_study.csv

3.69MB

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

데이터 분석을 할 때, 기본적으로 사용하는 라이브러리다.
pandas는 DataFrame을 이용해, 데이터를 관리하는 모든 과정을 굉장히 편하게 해 준다.
numpy는 빠른 수학 연산에 필수인 라이브러리다.
matplotlib.pyplot은 시각화에 필수인 라이브러리다.

Rawdata = pd.read_csv("Data_for_study.csv")
Rawdata

pd.read_csv("파일이름.csv"): csv 파일을 DataFrame으로 불러온다.

변수(Column)의 수는 총 14개이며, 55,748개의 대상이 들어가 있는 데이터가 불러와졌다.

1.2. 질적 변수 도수분포표 만들기

출력된 위 데이터만으로 데이터가 어떻게 생겼고, 그 안에 숨어있는 정보를 찾아내는 것은 불가능에 가깝다.
위 데이터를 가장 쉽게 정리하는 방법이 바로 도수분포표(Frequency distribution table)이다.
성별에 대한 도수분포표를 만들어보겠다.

>>> Rawdata.성별.value_counts()
1.0    29059
2.0    26689
Name: 성별, dtype: int64

value_counts(): 시리즈로 빈도표를 출력한다
1은 남자, 2는 여자이므로, 총 55,748명 중 남자가 29,059명, 여자가 26,689명임을 알 수 있다.
비율을 추가해보자.

성별_빈도표 = pd.DataFrame(Rawdata.성별.value_counts())
성별_빈도표.columns = ["freq"]
성별_빈도표["ratio"] = np.round(성별_빈도표.freq/sum(성별_빈도표.freq),2)
성별_빈도표

pd.DataFrame.columns: DataFrame의 컬럼명을 조작한다.
np.round(array, n): array의 값들을 n의 자리에서 반올림한다.

대한민국의 중, 고등학생을 모집단으로 하는 데이터의 표본집단에서 남성이 차지하는 비중은 52%, 여성이 차지하는 비중은 48% 임을 쉽게 알 수 있다.

1.3. 양적 변수 도수분포표 만들기

이번엔 동일한 방법으로 양적 변수인 키에 대해 도수분포표를 만들어보겠다.

키_빈도표 = pd.DataFrame(Rawdata.키.value_counts())
키_빈도표.columns = ["freq"]
키_빈도표["ratio"] = np.round(키_빈도표.freq/sum(키_빈도표.freq),2)
키_빈도표

데이터를 보기 쉽게 만드려고 했는데, 여전히 보기가 어렵다.
키와 같은 양적 변수는 들어갈 수 있는 값이 매우 다양하여 등급(Class)이 많기 때문에 이를 바로 도수분포표로 만들면, 여전히 보기 어렵다. 이를 범주화(Categorization)시켜 단순화해보자.

>>> 키_array = Rawdata.키.to_numpy()
>>> print("min:", 키_array.min())
>>> print("max:", 키_array.max())
min: 136.0
max: 196.0

DataFrame.column.to_numpy(): DataFrame의 특정 열 column을 numpy의 array로 변환시킨다.
array.min(): 배열의 최솟값
array.max(): 배열의 최댓값
최솟값이 136.0cm, 최댓값이 196.0cm이므로, "140 이하", "140~150", "150~160", "160~170", "170~180", "180~190", "190 이상"으로 데이터를 범주화해보자.

키_범주 = np.where(키_array<=140, "140 이하",
                np.where((키_array>140) & (키_array<=150), "140~150",
                         np.where((키_array>150) & (키_array<=160), "150~160",
                                  np.where((키_array>160) & (키_array<=170), "160~170",
                                           np.where((키_array>170) & (키_array<=180), "170~180",
                                                    np.where((키_array>180) & (키_array<=190), "180~190", "190 이상"))))))
                                                    
키_도수분포표 = pd.DataFrame(pd.Series(키_범주).value_counts(), columns=["freq"])
키_도수분포표.sort_index(inplace=True)
키_도수분포표

np.where(조건, a, b): 조건에 해당하는 경우 a로 해당하지 않는 경우 b를 반환
DataFrame.sort_index(): index로 정렬함.

비율을 추가해보자.

키_도수분포표["ratio"] = np.round(키_도수분포표.freq / sum(키_도수분포표.freq), 2)
키_도수분포표

1.4. 누적 빈도, 누적 비율 추가

이번에는 빈도(freq)와 비율(ratio)을 첫 집단부터 차근차근 누적시키는 누적 빈도(Cumulative frequency)와 누적 비율(Cumulative ratio)을 보자.

키_도수분포표["cum_freq"] = np.cumsum(키_도수분포표.freq)
키_도수분포표["cum_ratio"] = np.cumsum(키_도수분포표.ratio)
키_도수분포표

np.cumsum(array): array를 주어진 순서대로 누적합

2. 도수분포표의 개념 정리

위에서 만든 도수분포표를 기반으로, 도수분포표의 개념을 정리해 보자.

질적 변수는 일반적으로 구성하고 있는 등급(Class)의 수가 그리 많지 않기 때문에 바로 도수분포표를 생성해도 가시성이 높다. 물론, 질적 변수 역시 구성하고 있는 등급(Class)의 수가 매우 많다면, 재 범주화하여, 그 등급(Class)의 수를 줄여야한다.
예) 읍, 면, 동 단위로 지역명이 들어가 있는 변수는, 이를 시 단위로 재범주화 할 수 있음
양적 변수로 구성된 데이터는 중복을 제거하더라도, 구성하고 있는 등급(Class)가 매우 많아 도수분포표로 만들더라도, 가시성이 매우 떨어지므로, 변수의 성격에 따라 그 변수의 데이터 분포를 가장 잘 보여줄 수 있는 구간으로 데이터를 범주화시켜 도수분포표를 만든다.

각 등급(Class)에서 관찰된 객체의 수를 빈도수 또는 도수(Frequency)라고 하며, $f$로 나타낸다.
각 변수를 구성하는 데이터의 빈도, 비율 등을 파악하기 때문에 이 과정을 빈도 분석(Frequency Analysis)라 하며, 출력된 도수분포표를 빈도표라고도 한다.
빈도 분석을 통해 생성하는 도수분포표 자체도 통계 분석에서 목적이 될 정도로 중요하지만, 일반적으로는 데이터의 형태를 파악하는 기초 자료로 생성하는 경우가 많다.

누적 빈도(Cumulative frequency):
어떤 등급(Class)에 해당하는 빈도를 포함해, 그 이하 또는 그 이상에 있는 모든 빈도를 합친 것
누적 빈도를 사용하게 되면, 특정 등급(Class)에 있는 대상이 전체 데이터에서 차지하는 위치를 알 수 있다. 위 도수분포표를 보면, 중·고등학생 전체 집단에서 키가 170~180에 있는 집단이 전체 대상에서 96%에 위치하고 있음을 알 수 있다.
누적 빈도는 질적 변수에 대해서는 사용하지 않는 것을 추천한다. 양적 변수는 데이터에 순서가 있고, 값과 값 사이의 간격이 일정하므로, 누적 빈도를 통해 대상 등급(Class)의 객관적인 위치를 알 수 있다. 그러나, 명목 변수는 순서가 없고, 순서가 존재하는 서열 변수라 할지라도, 간격이 일정하지 않기 때문에, 대상 등급(Class)이 전체 등급의 어디에 위치하는지 알 수 없다.

3. 상대 빈도(Relative frequency) = 비율(Ratio)

위에서 생성한 키에 대한 도수분포표는 표본 집단인 중·고등학교에 재학 중인 청소년을 대상으로 한 것이다.

>>> print("만연령 min:", Rawdata.연령.min())
>>> print("만연령 max:", Rawdata.연령.max())
만연령 min: 12.0
만연령 max: 18.0

대상 집단의 연령 범위는 만 12세~18세이며, 성별이 남, 녀 두 가지가 들어 있기 때문에 단순하게 위 도수분포표를 보고, 해당 집단의 특성을 파악한다면 아래와 같은 정보 전달의 오류가 발생할 위험이 있다.
키 170cm는 12세 여성이란 집단에서는 굉장히 큰 키이지만, 18세 남성이란 집단에서는 그리 큰 키가 아니다. 위 도수분포표는 만 12세 ~ 18세 중·고등학생 표본집단을 대상으로 하였기 때문에 위 도수분포표만으로는 둘을 같게 볼 여지가 있다.
(물론, 대상을 만 12~18세라고 미리 설명해놨다면, 이런 문제는 발생하지 않는다.)
보다 정밀한 데이터 파악을 위해선, 연구자의 의도를 가장 잘 보여줄 수 있는 도수분포표(빈도표) 생성이 필요하다.
이번에는 만 16세인 사람으로 한정하여, 남성과 여성의 키를 보도록 하자.

def cat_height(array):
    cat_array = np.where(array<=140, "140 이하",
                     np.where((array>140) & (array<=150), "140~150",
                              np.where((array>150) & (array<=160), "150~160",
                                       np.where((array>160) & (array<=170), "160~170",
                                                np.where((array>170) & (array<=180), "170~180",
                                                         np.where((array>180) & (array<=190), "180~190", "190 이상"))))))
    return cat_array
    
    
def Freq_table(array):

    freq_table = pd.DataFrame(pd.Series(array).value_counts(), columns=["freq"])
    freq_table.sort_index(inplace = True)
    freq_table["ratio"] = freq_table.freq / sum(freq_table.freq)
    freq_table["cum_freq"] = np.cumsum(freq_table.freq)
    freq_table["cum_ratio"] = np.round(np.cumsum(freq_table.ratio), 2)

    # 반올림 및 총합 생성
    freq_table.loc["총합"] = [sum(freq_table.freq), sum(freq_table.ratio), "", ""]
    freq_table["ratio"] = np.round(freq_table["ratio"], 2)

    return freq_table

위에서 만들었던, 양적 변수의 범주화(키)와 도수분포표를 출력하는 코드들을 정리하여 별 개의 함수로 만들어놓았으며, 추가로 총합이 계산되도록 코드를 추가하였다.
이러한 코드 함수화를 통해, 코드의 재활용성, 가시성, 유지보수의 용이함 등의 이점을 얻을 수 있다.

남자_16세_키 = Rawdata[(Rawdata["연령"] == 16) & (Rawdata["성별"] == 1.0)]["키"].to_numpy()
여자_16세_키 = Rawdata[(Rawdata["연령"] == 16) & (Rawdata["성별"] == 2.0)]["키"].to_numpy()

Freq_table(cat_height(남자_16세_키))

Freq_table(cat_height(여자_16세_키))

상대 빈도(relative frequency)는 비율(ratio)과 동일하다.
상대 빈도 즉, 비율을 사용하면, 서로 다른 집단에 대하여, 각 범주별 차지하는 비중을 알 수 있게 되므로, 서로 다른 집단을 비교하는데 매우 유용하다.
위 표를 하나로 합쳐보자.

# 성별에 따른 변수명 구분을 위해 column 앞에 특정 문자를 붙여줌
M_DF = Freq_table(cat_height(남자_16세_키))
M_DF = M_DF.add_prefix("M_")
F_DF = Freq_table(cat_height(여자_16세_키))
F_DF = F_DF.add_prefix("F_")

# 병합 및, 결측값은 0으로 채운다.
T_DF = pd.concat([M_DF, F_DF], axis=1).sort_index()
T_DF.fillna(0, inplace=True)

T_DF

위 표를 보면, 남성(M)과 여성(F)의 도수분포표를 비율(ratio)을 이용해서, 두 집단의 규모 차이를 무시하고 비교할 수 있다.
만 16세 남성의 59%는 170~180cm에 존재하며, 만 16세 여성의 50%는 160~170cm에 존재한다는 것을 알 수 있다.

지금까지 기술통계학의 가장 기초가 되는 빈도 분석(Frequency analysis)의 도수분포표(Frequency distribution table)에 대해 알아보았다.

빈도 분석은 모든 데이터 분석의 기반이 되며, 데이터의 분포를 파악하고, 연구자의 의도를 대상에게 전달하는 데 있어, 작성하기도 쉽고, 이해하기도 쉬우므로, 강력한 영향을 미친다.

변수의 수가 무수히 많고, 하나하나의 변수를 구성하는 집단 역시 매우 많기 때문에, 모든 빈도를 보여주는 것보다, 연구자의 의도가 가장 잘 담겨 있는 대상에 대한 도수분포표를 보여주는 것이 매우 중요하며, 도수분포표를 생성하기 전에 자신이 전달하고자 하는 바가 무엇인지? 자신이 전달하고자 하는 바에서 대상 집단이 어떻게 되는지를 명확히 하도록 하자.

통계 분석을 위한 데이터 준비

만년필잉크 — Mon, 1 Mar 2021 23:16:17 +0900

데이터 분석을 하기 위해선, 제일 먼저 데이터가 필요하다. 난수 데이터를 생성하거나, 직접 데이터를 만드는 것도 나쁜 방법은 아니지만, 해당 포스팅을 보는 사람이 실제 데이터를 이용해서 논문을 쓰거나, 특정 결과물을 만들고 싶을 가능성이 높다고 생각하고, 실제 데이터 속에 숨어 있는 진짜 정보를 찾아내는 것이 지식이 되므로, 원시 자료(Rawdata)를 구하고, 학습에 필요한 변수들만 일부 추출하여, 기초 통계분석을 위한 학습용 데이터를 만들어보겠다.

0. 분석 환경 설명

분석 환경 구축은 상황에 따라 그 수준이 크게 차이가 나지만, 본 포스트에서는 윈도우 환경에서 아나콘다를 설치하고, 이를 통해 Python을 사용할 예정이다.

conda 4.9.2 버전, Python 3.7 버전을 사용하겠다.
자세한 설치 방법은 이전 포스트인 "Python 파이썬과 아나콘다"를 참고하기 바란다.
Python을 사용할 방법은 아나콘다를 설치하면서 함께 설치 된 주피터 노트북을 사용할 것이나, 보다 편한 툴을 원하는 사람은 파이참("Python 파이썬과 파이참")을 사용하길 바란다.
분석에는 기본적으로 pandas, numpy, scipy, matplotlib를 사용할 것이며, pandas는 1.1.3 버전, numpy는 1.19.2 버전, scipy는 1.5.2 버전, matplotlib는 3.3.2 버전을 사용할 것이다.
pandas, numpy, scipy, matplotlib는 아나콘다 설치 시, 기본적으로 설치되므로, 굳이 다른 라이브러리를 다운로드할 필요는 없으나, 이에 관심 있는 경우, "Python 필요한 모듈들을 설치해보자"를 참고하기 바란다.

1. 필요한 원시 자료 구하기

원시 자료(Rawdata)는 말 그대로, 아무런 가공도 하지 않은, 가장 기본적인 데이터 상태를 가리킨다.
정부 4.0 이후로, 수많은 공공 기관, 의료 기관 등에서 자체 관리하던 데이터를 통합 관리하려는 시도가 있었고, 그덕에 질 높은 원시 자료 구하기가 꽤 쉬워졌다.
추천하는 원시자료 홈페이지는 다음과 같다.
공공데이터포털 - 행정안전부에서 운영하는 각종 공공 데이터가 모여있는 곳
보건복지데이터포털 - 건강위험인지조사, 노인실태조사 등
고용조사 분석시스템 - 청년패널조사, 대졸자직업이동경로조사, 고령화연구패널조사
보건의료빅데이터개방시스템 - 전국 병의원 및 약국 현황, 의료장비 상세 현황, 요양기관 개설 현황 등
청소년건강행태조사 - 질병관리청
게임이용자 패널 연구 - 한국콘텐츠진흥원
한국복지패널 - 한국보건사회연구원
해당 포스트에서는 비교적 접근하기 쉽고, 데이터의 질도 상당히 좋은 한국복지패널을 사용하도록 하겠다.

2. 청소년건강행태조사 원시자료 구하기

위 참조를 통해 질병관리청의 청소년건강행태조사를 다운로드하자.
청소년건강행태조사는 흡연, 음주, 신체활동과 같은 변수를 통해 청소년층의 건강행태를 파악하는 것을 목적으로, 2005년부터 매년마다 중·고등학교 재학생을 대상으로 꾸준히 실시해온 국가승인통계조사로, 직관적인 데이터와 높은 참여율로, 다루기 매우 편한 데이터다.
Python을 사용하여 분석할 것이기 때문에, SAS나 SPSS 무엇을 다운로드 받든 지 큰 상관은 없으나, 본 포스트에서는 SPSS를 사용하여 분석을 진행하도록 하겠다.
본 포스트에서 다운로드할 데이터는 "제15차(2019) 청소년건강행태조사"다.

해당 원시자료에 관심이 있거나, 이를 이용하여 연구를 해보고 싶다면, 지침서나 통계집 등의 산출물을 자세히 읽어보는 것을 추천한다.

3. 데이터 가져오기

spss, sas 데이터는 pandas를 이용해서 쉽게 가지고 올 수 있다.

import pandas as pd

>>> Rawdata = pd.read_spss("kyrbs2019.sav")

---------------------------------------------------------------------------
ImportError                               Traceback (most recent call last)
<ipython-input-2-a3be1637ac91> in <module>
----> 1 Rawdata = pd.read_spss("kyrbs2019.sav")

~\anaconda3\lib\site-packages\pandas\io\spss.py in read_spss(path, usecols, convert_categoricals)
     34     DataFrame
     35     """
---> 36     pyreadstat = import_optional_dependency("pyreadstat")
     37 
     38     if usecols is not None:

~\anaconda3\lib\site-packages\pandas\compat\_optional.py in import_optional_dependency(name, extra, raise_on_missing, on_version)
    108     except ImportError:
    109         if raise_on_missing:
--> 110             raise ImportError(msg) from None
    111         else:
    112             return None

ImportError: Missing optional dependency 'pyreadstat'.  Use pip or conda to install pyreadstat.

처음 spss 데이터를 가지고 오는 경우, 위와 같은 오류가 뜰 수 있는데, ImportError에서 요청한 데로, pyreadstat 패키지를 깔면 해결된다.

>>> !pip install pyreadstat
Collecting pyreadstat
  Downloading pyreadstat-1.0.9-cp38-cp38-win_amd64.whl (1.2 MB)
Requirement already satisfied: pandas>0.24.0 in c:\users\gooop\anaconda3\lib\site-packages (from pyreadstat) (1.1.3)
Requirement already satisfied: python-dateutil>=2.7.3 in c:\users\gooop\anaconda3\lib\site-packages (from pandas>0.24.0->pyreadstat) (2.8.1)
Requirement already satisfied: pytz>=2017.2 in c:\users\gooop\anaconda3\lib\site-packages (from pandas>0.24.0->pyreadstat) (2020.1)
Requirement already satisfied: numpy>=1.15.4 in c:\users\gooop\anaconda3\lib\site-packages (from pandas>0.24.0->pyreadstat) (1.19.2)
Requirement already satisfied: six>=1.5 in c:\users\gooop\anaconda3\lib\site-packages (from python-dateutil>=2.7.3->pandas>0.24.0->pyreadstat) (1.15.0)
Installing collected packages: pyreadstat
Successfully installed pyreadstat-1.0.9
WARNING: You are using pip version 20.3.3; however, version 21.0.1 is available.
You should consider upgrading via the 'c:\users\gooop\anaconda3\python.exe -m pip install --upgrade pip' command.

주피터 노트북을 사용하는 경우라면, 위와 같이 코드를 치고, 아나콘다 Prompt나 파이참을 사용하는 경우, 해당 포스트를 참고하자("Python 필요한 모듈들을 설치해보자").

>>> Rawdata = pd.read_spss("kyrbs2019.sav")
>>> Rawdata

총 57303명의 객체(Rows)와 183개의 변수(Columns)가 있는 데이터가 가져와졌다.
위 표를 DataFrame이라고 하며, 이에 대한 보다 자세한 정보를 알고자 한다면, 해당 포스팅("Pandas-데이터 프레임의 구조와 용어 정리")을 참고하길 바란다.

4. 필요 변수(Columns)만 추출하기

이번에는 "제15차(2019) 청소년건강행태조사 원시자료(지침서)"를 보고, 가져온 원시자료를 파악해보자.
변수의 이름은 겹치지 않는 것이 매우 중요하며, 그 내용이 길면 다루기 어려워지므로, 보통 영어 알파벳과 숫자로 구성한다.
때문에, 원시자료 지침서를 참고하지 않는다면, 자신이 다룰 데이터의 변수들을 파악하기 쉽지 않으므로, 원시자료를 다루고자 한다면, 반드시 변수들이 정리되어 있는, 지침서나 코딩 북 등을 참고하기 바란다.
모든 변수를 보는 것은 매우 비효율적이므로, 앞으로 분석에 필요할 청소년건강행태조사의 대표적인 변수 16개만 골라, 앞으로 학습할 데이터를 만들도록 하겠다.
선택 변수 설명

변수명	변수 설명	변수명	변수 설명
SEX	성별	PA_TOT	하루 60분 이상 신체활동 일수
AGE	만나이	M_STR	평상시 스트레스 인지
HT	신장	M_SLP_EN	잠으로 피로 회복 정도
WT	체중	AC_LT	평생 음주 경험
E_S_RCRD	학업성적	TC_LT	평생 흡연 경험
E_SES	가정의 경제상태	INT_WD_MM	주중 학습 목적 이외 평균 인터넷 이용 시간
PR_HT	주관적 건강인지	INT_WK_MM	주말 학습 목적 이외 평균 인터넷 이용 시간

Target_DF = Rawdata[["SEX", "AGE", "HT", "WT", "E_S_RCRD", "E_SES",
                     "PR_HT", "PA_TOT", "M_STR", "M_SLP_EN", "AC_LT",
                     "TC_LT", "INT_WD_MM", "INT_WK_MM"]]

변수의 수를 줄였으므로, 변수 이름을 아예 한글로 바꿔서 알아보기 쉽게 만들자.

Target_DF.columns = ["성별", "연령", "키", "몸무게", "학업성적",
                     "경제상태", "건강인지", "운동일수", "스트레스인지",
                     "피로회복정도", "음주경험", "흡연경험",
                     "주중_인터넷이용시간","주말_인터넷이용시간"]
                     
Target_DF

Python은 UTF-8을 기반으로 만들어졌기 때문에, 한글을 사용했을 때, 문제가 발생하기 쉬운 다른 언어들과 달리 한글을 Column의 이름으로 사용하거나, 객체를 담는 변수의 이름으로 사용할 수도 있다.
물론, 가능은 하지만 실전에서는 가능한 한글을 사용하지 않기를 바란다.

5. 결측값 처리하기

출력된 표를 보니 NaN이라는 이상한 문자가 있는 것을 볼 수 있다.
이는 결측값(Missing Value)로 어떠한 연유에 의해 값이 누락된 것이다.
결측값을 해결하는 문제는 데이터 분석에서 매우 민감하고 중요한 부분이지만, 이는 현 포스트에서 다루고자 하는 기초 통계학 부분과는 거리가 있으므로, 이를 아주 단순하게 처리하고 가도록 하겠다.
결측값이 존재하는 변수는 다음과 같다.

>>> Target_DF.isna().sum()
성별                0
연령              234
키              1555
몸무게            1555
학업성적              0
경제상태              0
건강인지              0
운동일수              0
스트레스인지            0
피로회복정도            0
음주경험              0
흡연경험              0
주중_인터넷이용시간    14297
주말_인터넷이용시간    12488
dtype: int64

결측값이 발생한 이유에 대한 분석은 보고서를 읽는 것이 가장 정확하지만, 매우 단순하게 해당 부분을 해결하겠다.
"주중_인터넷이용시간", "주말_인터넷이용시간"은 결측값 제외 시, 최솟값이 10.0인 것을 볼 때, 인터넷을 사용하지 않은 사람을 결측값으로 처리한 것으로 판단하고, 모두 0으로 바꾸도록 하겠다.
연령, 키, 몸무게가 누락된 대상은 전체 데이터 셋 57,303명에서 차지하는 비중이 매우 작으므로, 제거하여 무시하도록 하겠다.

Target_DF["주중_인터넷이용시간"] = Target_DF.주중_인터넷이용시간.fillna(0)
Target_DF["주말_인터넷이용시간"] = Target_DF.주말_인터넷이용시간.fillna(0)
Target_DF.dropna(inplace = True)
Target_DF.reset_index(drop = True, inplace = True)
Target_DF

위 코드 실행 시, 붉은색으로 SettingWithCopyWarning이 뜨는데, 이는 pandas의 메모리를 절약하기 위한 방법인, 데이터 종속성으로 인해 발생하는 문제로, 기존의 Rawdata와 Target_DF가 별개로 존재하게 되므로, 발생하는 문제다. 이를 해결하기 위해선, copy함수를 이용해서 Target_DF를 생성할 때, Rawdata와 별개로 흐르게 만들면 되지만, 딱히 결과에 영향을 주진 않으므로, 그냥 넘어가도록 하자.
추출된 데이터 셋을 추후 쉽게 사용하기 위해 저장해놓도록 하겠다.

Target_DF.to_csv("Data_for_study.csv", index=False)

Data_for_study.csv

3.39MB

Python으로 하는 기초통계학은 해당 데이터를 사용하여 진행할 것이다. 해당 데이터를 참고 파일로 올려놓을 테니, 위 부분을 생략하고 진행하고자 하는 경우, 바로 데이터만 다운로드하고 사용해도 괜찮다.

변수(Variable)

만년필잉크 — Mon, 1 Mar 2021 12:02:38 +0900

처음 통계학을 접하게 되었을 때, 변수(Variable)가 무엇인지 헷갈리는 경우가 꽤 많다. 학교에서 데이터 분석 강의를 하거나, 주변인들이 데이터 분석에 대해 질문을 해올 때, "변수라는 용어를 많이 사용하는데 대체 그 변수가 구체적으로 무엇이냐?"라는 질문을 종종 해온다.

해당 파트에서 학습할 변수는 분포와 함께 데이터 분석에 있어, 상식으로 사용되는 개념이므로, 꼭 숙지하고 넘어가도록 하자.

변수(Variable)

"변수(Variable)"는 우리가 관심 있는 대상이 가지고 있는 속성(Attribute)이다.

위 한 줄이 가장 쉽게 변수를 설명할 수 있는 말인데, 막연하게 느껴질 수 있으므로, 좀 더 자세히 설명해보도록 하겠다. 이전 포스트("통계학이란? - 1.모집단과 표본집단")에서 "연구자가 관심 있는 대상"이 "모집단"이라고 했다.

이 모집단이 가지고 있는 속성(Attribute)이 바로 변수다. "속성(Attribute)"은 연구자가 정의할 수 있는 대상이 가지고 있는 성질이며, 동시에 대상을 특정 혹은 정의할 수 있는 개념이다.

예시를 통한 설명

당신이 "사람"이라는 대상에 대해 관심이 있다고 가정해보자. 그럼 사람은, 성별, 연령, 국적, 키, 몸무게, 거주지, 최종 학력 등의 속성을 가지고 있다고 할 수 있다.
만약 당신이 특정 속성을 갖는 사람을 찾고 싶다고 해보자. 성별이 여성, 연령이 24살이며 한국 국적을 갖고 있는 사람을 찾는다고 하면, 꽤 광범위하므로 찾기 쉽지 않을 것이다.
여기에 변수를 하나하나 추가해보자. 키가 153cm, 몸무게 54kg, 대전광역시 거주, 대학교 졸업, 원무과에서 근무함.
이런 식으로 변수가 하나하나 추가될수록 특정 개체를 쉽게 설명할 수 있게 된다. 우리는 우리가 관심 있는 대상을 이러한 변수들을 통해, 그들의 속성을 구체화시키고, 그들 개개인을 구분할 수 있다.
모집단이 연구자의 관심 집단이 바뀌면, 바뀌듯이 변수 역시 모집단에 종속되어 변한다.

변수와 개인정보

변수를 통해 개인을 특정할 수 있다고 하였는데, 변수에 따라 그 정도가 바뀌게 된다.
단 하나로 대상을 특정할 수 있는 변수가 있으며, 3개 이상의 변수가 동시에 사용되어 대상을 특정할 수 있는 변수도 있다.
예를 들어, 주민등록번호, 휴대폰 번호와 같은 변수는 아주 강력하게 특정 객체를 지목하게 한다.
이름, 거주지, 연령과 같이 함께 사용되어, 강력하게 특정 객체를 지목하는 변수도 있다.
이는 RDB의 Primary key, Super key와 유사한 개념이다.
때문에 주민등록번호, 휴대폰 번호, 이름 같이 강력한 변수는 아예 데이터에 넣지 않거나, 만약 데이터에 들어가 있는 경우, 그 관리 수준이 상당히 엄중하다.

1. 변수의 종류

변수는 크게 "질적 변수(Qualitative variable)", "양적 변수(Quantitative variable)" 둘로 나뉜다.
변수의 종류에 따라 접근하는 통계 분석 방법이 바뀌므로, 정확히 변수의 종류를 인식하는 것은 필수다.

2. 변수와 척도

척도는 어떠한 현상을 측정하기 위해 만든 도구를 의미한다.
연구자가 관심 있는 대상인 모집단이 존재하고, 그 모집단이 가지고 있는 속성인 변수가 존재하는데, 이 변수를 어떠한 도구를 이용해서 측정할 것인가를 이야기한다.
척도는 위 변수를 측정하는 방법으로써 1:1로 대응되어 존재한다.
(이산형 변수는 등간 변수라고도 부르며, 연속형 변수는 비율 변수라고도 부르므로, 변수의 이름과 척도의 이름은 동일하다.)

변수와 헷갈리기 꽤 쉬운 개념으로, 척도는 종종 변수와 혼용되어 지칭되기도 한다.
일반적으로, 명목 변수는 명목 척도로, 서열 변수는 서열 척도로, 등간 변수는 등간 척도로, 비율 변수는 비율 척도로 측정하기 때문에 이를 혼용하여 지칭해도 정보가 잘못 전달되거나 하는 문제가 발생할 가능성은 크지 않다.
그러나, 변수와 척도는 동일한 개념은 아니기 때문에 주의할 필요는 있는데, 위 사진에서 보듯, 상위 척도를 이용하여, 보다 하위 레벨의 변수를 측정할 수도 있기 때문이다.
예를 들어, 길이와 같은 연속형 변수를 1m보다 작다, 크다와 같이 이분화시켜 명목형 척도로 측정할 수 있으며, 10 cm 이하, 10cm ~ 1m 사이, 1m 이상 과 같은 서열 척도로 측정할 수도 있다.
그러나, 하위 수준의 변수를 보다 높은 수준의 척도로는 측정할 수 없다(성별과 같은 명목 척도를 연속형 척도로 측정할 수는 없다).

3. 질적 변수(Quantitative Variable)

범주형 변수(Categorical Variable)이라고도 하며, 말 그대로 변수 안에 있는 데이터들이 범주화되어 있다는 뜻이다.
즉, 변수 안에 N개의 집단이 존재하며, 그 집단을 숫자로 나타낸다 할지라도 그 숫자는 데이터의 양을 줄이기 위한 목적이지, 그 숫자엔 숫자로써의 의미가 존재하지 않는다.
즉, 문자로 나타낼 수 있는 변수를 의미한다.

3.1. 명목 변수(Nominal Variable)

완전히 서로 관련 없는 문자들로 이루어진 변수를 의미한다.
이를 쉽게 데이터화 하기 위해 숫자로 나타낸다 할지라도, 그 숫자에 대해선, 서로 구분하는 의미만 존재하지, 숫자가 가진 그 어떠한 정보도 존재하지 않는다.
예를 들어, 성별의 남자를 1로, 여자를 2로 표기한다 할지라도, 여기에는 "남자는 1등 여자는 2등이다.", "여자가 남자보다 2배 더 우월하다."와 같은 의미는 전혀 존재하지 않는다.
토트넘 축구 선수인 "손흥민의 등번호 7번"과 주장인 "위고 요리스의 등번호 1번"에는 그 어떠한 숫자적 의미가 존재하지 않는다.
야구의 4번 타자와 같은 특정 숫자에 상징성이 있을 수는 있으나, 등번호를 늘여놓았을 때, 그 순서에 일정한 방향을 가진 서열이 존재하지 않기 때문에, 부여된 숫자는 단순히 객체를 구분하는 역할만 한다.

3.2. 서열 변수(Ordinal Variable)

명목 척도 중에 순서의 개념이 존재하는 변수를 의미한다.
예를 들어, 최종 학력은 "무학", "초등학교", "중학교", "고등학교", "대학교", "대학원"과 같이 명목형 척도로 측정되지만, 순서가 존재하기 때문에, 이를 숫자로 만들었을 때, 그 숫자에 아무런 의미가 존재하지 않는다고 할 수는 없다.
즉, 숫자의 개념 중 순서의 개념이 존재하는 변수이다.
"무학 = 0, 초등학교 = 1, 중학교 = 2, 고등학교 = 3, 대학교 = 4, 대학원 = 5"로 나타낸다고 할 때, 이를 늘어놓으면, 5가 2보다 뒤에 있다라고는 할 수 있지만, "대학원(5) - 고등학교(3) = 중학교(2)"라고 할 수는 없다.

4. 양적 변수(Qualitative Variable)

단순하게 연속형 변수(Continuous)라고 지칭하는 경우도 종종 있는데, 이 경우, 양적 변수를 구성하는 이산형 데이터와 연속형 데이터를 구분하기 어려워질 수 있으므로, 그냥 양적 변수라고 하길 추천한다.
데이터를 숫자로 나타냈을 때, 숫자 그 자체인 경우다.
그 숫자를 이산형으로만 나타낼 수 있는가, 연속형으로도 나타낼 수 있는가에 따라 이산형 변수(등간 변수)와 연속형 변수(비율 변수)가 나뉜다.

4.1. 등간 변수(Interval Variable)

이산형으로만 나타낼 수 있는 숫자로, 각 숫자 사이가 일정하며, 그 사이에 그 어떠한 값도 존재하지 않는 데이터를 의미한다.
이산형이라는 말은 숫자가 연속되지 않고 일정한 거리로 떨어져 있다는 소리로, 이해하기 쉽게 이야기하면 소수점이 존재하지 않는 경우라고 할 수 있다(물론 이는 이해하기 쉬운 예시이지 온도와 같이 소수점을 갖는 등간 변수 역시 존재하므로, 등간 변수에는 절대 소수점이 등장하지 않는다고 생각해서는 안된다).
예를 들어, 남극에 있는 펭귄 수는 이산 되어 있는 숫자다. 펭귄이 반마리만 있는 경우, 이미 죽은 펭귄이므로, 이를 펭귄 0.5마리라고 할 수는 없다.
이글루 안에 펭귄 5마리가 있을 때, 이 이글루 안에 펭귄을 2마리 더 넣어 7마리로 만들 수 있고, 펭귄 3마리를 다시 빼서 4마리로 만들 수도 있으므로, 가감(더하기 빼기)이 가능하다.
그러나, 펭귄 5마리에게 펭귄 2마리를 곱하거나 나눈다는 것은 불가능하며, 펭귄 1마리를 2로 나누겠다는 소리는 애초에 단위가 다르기 때문에 시도해서도 안되며, 펭귄을 죽이겠다는 소리이므로, 이런 상상은 하지도 말자.
등간 변수와 비율 변수는 꽤 구분하기 어려운 개념인데, 대표적인 등간 변수인 온도는 36.2˚와 같이 소수점이 있는 경우도 존재하기 때문이다.
온도는 절대적인 기준을 갖는 것이 아닌, 일정한 간격을 가지고 상대적으로 존재하는 것이기 때문에 36˚보다 18˚가 두 배 더 춥다고 할 수는 없다.

4.2. 비율 변수(Ratio Variable)

연속형 숫자로 나타낼 수 있는 데이터로, 정수 사이에 수많은 값이 존재한다.
170 cm와 171cm 사이에는 170.5, 170.05, 170.005와 같이 소수점으로 나타낼 수 있는 수많은 숫자가 존재한다.
이를 비율 변수라고 부르는 이유는 측정된 데이터를 비율로 계산이 가능하기 때문으로, 이러한 비율 변수는 절대적인 기준이 존재하기 때문에 곱하고 나눌 수 있다.
이 절대적인 기준이라는 것은 이 속성이 존재하지 않을 수 있는 절대 영점(Absolute Zero Point)이 존재한다는 소리로, 길이나 무게는 0이 되는 순간, 대상에게 있어 그 속성의 값이 "없다"가 될 수 있으나, 온도는 존재하지 않는다는 개념이 존재하지 않는다.
비율 변수는 절대적인 기준이 존재하기 때문에 더하기, 빼기, 곱하기, 나누기가 모두 가능하다.
비율 변수는 통계 분석에 있어 가장 편리한 대상으로, 모든 척도로 측정할 수 있기 때문에, 하위 변수로 쉽게 변환할 수 있다. 그 덕에 모든 통계 분석 기법의 대상이 될 수 있다.

5. 정리

변수는 대상 집단(모집단)이 가지고 있는 속성이며, 이 변수는 크게 질적 변수(명목 변수, 서열 변수), 양적 변수(이산형 변수, 연속형 변수)로 나뉜다.
변수를 측정하는 도구는 척도이며, 상위 변수는 하위 변수로 그 수준을 바꿀 수 있으며, 그로 인해 하위 척도로도 상위 변수를 측정할 수 있다.
변수를 나누는 기준을 정리한 표는 다음과 같다.

변수	순서	더하기, 빼기	곱하기, 나누기	절대영점
명목 변수	X	X	X	X
서열 변수	O	X	X	X
등간 변수	O	O	X	X
비율 변수	O	O	O	O

위 기준만으로 나누기 애매한 경우도 종종 존재하기 때문에, 이를 보다 단순화시킨 질적 변수, 양적 변수로 이분화시켜 변수를 구분하는 경우가 많다.
변수의 종류에 따라 사용할 수 있는 통계 분석 기법이 크게 달라지기 때문에 변수의 종류가 무엇인지 판단하는 능력은 통계 분석을 위해 필수로 가지고 있어야 하는 기술이다.

연립일차방정식과 가우스 소거법(Gaussian elimination)

만년필잉크 — Fri, 26 Feb 2021 20:53:20 +0900

연립일차방정식과 가우스 소거법

앞서 행렬은 연립일차방정식의 계수와 변수를 분리하여 사용하게 되면서 등장하였다고 했다.
앞서 행렬의 기본적인 성질은 배웠으니, 이제 연립일차방정식과 행렬이 어떻게 연결되는지에 대해 알아보자.
연립일차방정식을 통해 첨가 행렬을 만들어보고, 가우스 소거법으로 연립일차방정식을 풀이해보자.

1. 연립일차방정식(System of Linear equations)

1.1. 일차방정식(Linear equation)

미지수 $x_1, x_2, x_3, ..., x_n$에 관한 일차방정식은 상수 $b$와 계수 $a_1, a_2, a_3, ..., a_n$이 실수일 때, 다음과 같은 꼴로 나타나는 방정식이다.
일차방정식이므로, 미지수 $x_1, x_2, x_3, ..., x_n$의 차수는 1이다.

$$a_1x_1 + a_2x_2 + a_3x_3 + \cdots a_nx_n = b$$

1.2. 연립일차방정식(System of Linear equations)

미지수 $x_1, x_2, x_3, ..., x_n$에 대하여 유한개의 일차방정식 모임은 아래와 같다.

$$a_{11}x_1 + a_{12}x_2 + a_{13}x_3 + \cdots a_{1n}x_n = b_1$$

$$a_{21}x_1 + a_{22}x_2 + a_{23}x_3 + \cdots a_{2n}x_n = b_2$$

$$a_{31}x_1 + a_{32}x_2 + a_{33}x_3 + \cdots a_{3n}x_n = b_3$$

$$ \vdots $$

$$a_{m1}x_1 + a_{m2}x_2 + a_{m3}x_3 + \cdots a_{mn}x_n = b_m$$

실수 $b_1, b_2, b_3, ..., b_m$이 모두 0이면 이 연립방정식을 동차(Homogeneous)라 하며, 반대의 경우에는 비동차(non-Homogeneous)라 한다.
미지수 $x_1, x_2, x_3, ..., x_n$에 대하여 어떤 수 $s_1, s_2, s_3, ..., s_n$을 각각 대입하여, 각 방정식이 모두 성립하면 어떤 수 $s_1, s_2, s_3, ..., s_n$을 연립일차방정식의 해(Solution)이라 한다.
연립일차방정식의 해 전체 집합을 연립일차방정식의 해집합(Solution set)이라 한다.
동일한 해집합을 가지는 두 연립일차방정식을 동치(Equivalent)라고 한다.
연립일차방정식의 해에 대하여, 일반적으로 다음 중 하나가 성립한다.

해를 갖지 않는다.
유일한 해를 갖는다.
무수히 많은 해를 갖는다.

1.3. 연립일차방정식과 행렬

위 연립일차방정식을 행렬로 나타내면 다음과 같다.

$$A = \begin{pmatrix}
A_{11}& A_{12} & A_{13}  & ... & A_{1n}\\
A_{21}& A_{22} & A_{23}  & ... & A_{2n}\\
A_{31}& A_{32} & A_{33}  & ... & A_{3n}\\
\vdots & \vdots & \vdots & \ddots & \vdots\\
A_{m1}& A_{m2} & A_{m3}  & ... & A_{mn}\\
\end{pmatrix},\ \ \

X = \begin{pmatrix}
x_1\\
x_2\\
x_3\\
\vdots \\
x_n
\end{pmatrix},\ \ \

B = \begin{pmatrix}
b_1\\
b_2\\
b_3\\
\vdots \\
b_m
\end{pmatrix}$$

$$AX = B$$

우리가 지금까지 봐왔던, 행렬은 바로 $A$로 이를 계수행렬(Coefficient matrix)라 한다.

2. 첨가행렬(Augmented matrix)

계수행렬 $A$와 상수항들이 모여서 만들어진 행렬$B$를 붙이면 첨가행렬(Augmented matrix)가 만들어진다.

$$(A | B) = \begin{pmatrix}
A_{11}& A_{12} & A_{13}  & ... & A_{1n} | b_1\\
A_{21}& A_{22} & A_{23}  & ... & A_{2n} | b_2\\
A_{31}& A_{32} & A_{33}  & ... & A_{3n} | b_3\\
\vdots & \vdots & \vdots & \ddots & \ \ \ \vdots \ \ | \ \vdots \\
A_{m1}& A_{m2} & A_{m3}  & ... & A_{mn} | b_m\\
\end{pmatrix}$$

첨가행렬은 행렬 방정식의 풀이와 역행렬 구하기에 응용된다.
가우스 소거법을 사용하여 연립일차방정식을 풀이해보자.

3. 가우스 소거법(Gaussian elimination)

선형대수학에서, 가우스 소거법은 연립일차방정식을 풀이하는 알고리즘으로, 풀이 과정에서 일부 미지수가 차츰 소거되어, 남은 미지수에 대한 선형 결합으로 풀이가 완성된다.
가우스 소거법은 보통 행렬을 사용하며, 첨가 행렬을 그와 풀이가 더 간단한 행렬로 변환하여 풀이를 완성한다.
가우스 소거법은 행렬식과 역행렬의 계산에도 응용된다.
가우스 소거법은 맨 위 일차방정식부터 임의의 k를 곱해가며 아래에 있는 일차방정식들을 하나하나 맨 앞의 계수부터 0으로 만들어가는 방법으로, 최종적으로 주대각선의 모든 값이 1인 상삼각행렬을 만들게 된다.
내용이 조금 길기 때문에 손으로 풀어보겠다.

가우스 소거법은 위에서부터 천천히 아래로 내려가면서, 주대각성분이 1인 상삼각행렬을 만들어가면 된다.
$①$, 최초 첨가행렬에서 첫 번째 행 $R_1$의 첫 원소인 $A_{11}=4$는 주대각성분이므로 이를 1로 만들어주기 위해, $R_1$에 $\frac{1}{4}$를 곱해주어, $A_{11}=1$로 만들어주었다.
$②$, 두 번째 행 $R_2$의 첫 원소인 $A_{21}=2$을 0으로 만들어주기 위해, $R_1$의 인자들에 $-2$를 곱하여 $R_2$에 더해주었다.
$③$, 세 번째 행 $R_3$의 첫 원소인 $A_{31}=3$을 0으로 만들어주기 위해, $R_1$의 인자들에 $-3$을 곱하여 $R_3$에 더해주었다.
$④$, 두 번째 행 $R_2$의 두 번째 원소인 $A_{22}=\frac{1}{2}$은 주대각성분이므로, $1$로 만들어주기 위해, $2$를 $R_2$에 곱해주었다.
$⑤$, 세 번째 행 $R_3$의 두 번째 원소인 $A_{32}=-\frac{33}{4}$를 0으로 만들어주기 위해, $R_2$에 $\frac{33}{4}$를 곱하여, $R_3$에 더해주었다.
이를 통해, 연립일차방정식의 해인 $x=2,\ y=-1,\ z=3$을 찾았다.

행렬이 연립일차방정식에서 어떻게 나오게 되었고, 행렬을 이용해서 연립일차방정식의 해를 쉽게 찾을 수 있는 가우스 소거법에 대해 간단하게 학습해보았다.

다음 포스트에서는 가우스 소거법에 대해 좀 더 알아보도록 하자.

역행렬(Inverse matrix)

만년필잉크 — Fri, 26 Feb 2021 15:41:05 +0900

역행렬(Inverse matrix)

$AA^{-1} = A^{-1}A = E$
선형대수학에서 가역행렬(Invertible matrix)은 그와 곱한 결과가 단위행렬인 행렬$A^{-1}$을 갖는 행렬$A$를 말한다.
이 행렬$A^{-1}$를 행렬 $A$의 역행렬이라고 한다.
고등학교 행렬 문제에서는 교환법칙의 성립 유/무를 묻는 문제가 많이 나온다.
수능 유형 예시)

$$A(A+B)=E \rightarrow AB = BA$$

$$put) A(A + B) = E = (A+B)A\ \rightarrow \ A^2+AB=E=A^2+BA \ \rightarrow \ AB=BA$$

1. 역행렬을 구하는 방법

행렬 A가 이차 정사각 행렬일 땐 다음 방법으로 구할 수 있다.

$$A = \begin{pmatrix} a & b\\ c & d \end{pmatrix},\ \ \ A^{-1}=\frac{1}{ad-bc}\begin{pmatrix} d & -b\\ -c & a \end{pmatrix}$$

위 역행렬을 구하는 방법에서 $ad-bc=0$인 경우, 분모가 0이 되므로 역행렬을 만들 수 없다.
즉, $ad-bc$의 값을 통해 역행렬이 존재하는지를 확인할 수 있다.
$ad-bc \neq 0$: $A^{-1}$이 존재한다.
$ad-bc = 0$: $A^{-1}$이 존재하지 않는다.
Python으로 역행렬을 구해보자.

>>> mat = np.array([[2, 1, 5],[0,0,1],[-1,0,2]])
>>> inv_mat = np.linalg.inv(mat)
>>> np.dot(mat, inv_mat)
array([[1., 0., 0.],
       [0., 1., 0.],
       [0., 0., 1.]])

만약 역행렬이 존재하지 않는 행렬이라면, 다음과 같은 오류를 반환한다.

>>> mat = np.array([[2, 1],[2,1]])
>>> inv_mat = np.linalg.inv(mat)
---------------------------------------------------------------------------
LinAlgError                               Traceback (most recent call last)
<ipython-input-12-72ac304bfc31> in <module>
      1 mat = np.array([[2, 1],[2,1]])
----> 2 inv_mat = np.linalg.inv(mat)

...

---> 88     raise LinAlgError("Singular matrix")
     89 
     90 def _raise_linalgerror_nonposdef(err, flag):

LinAlgError: Singular matrix

2. 이차 정사각행렬 역행렬 공식의 증명

역행렬 공식의 증명은 가우스 조던 소거법(Gauss-Jordan elimination method)로 구하는 방법과 전치행렬, 소행렬, 여인자를 이용해서 구하는 방법 두 가지가 있다.
그러나 이차 정사각행렬은 비교적 공식이 간단하므로, 옳바른 증명 방법은 아니긴 하지만, 위 기법들을 사용하지 않고도 구할 수 있다.
행렬 $A$와 역행렬 $A^{-1}$을 다음과 같이 정의하자.

$$A=\begin{pmatrix} a & b\\ c & d \end{pmatrix},\ \ A^{-1}=\begin{pmatrix} x & y\\ z & r \end{pmatrix}$$

$$AA^{-1}=E \rightarrow \begin{pmatrix} a & b\\ c & d \end{pmatrix}\begin{pmatrix} x & y\\ z & r \end{pmatrix} = \begin{pmatrix}1 & 0\\ 0 & 1 \end{pmatrix}$$

$$ax + bz = 1 \cdots ①$$

$$ay + br = 0 \cdots ②$$

$$cx + dz = 0 \cdots ③$$

$$cy + dr = 1 \cdots ④$$

위 식을 기반으로 $(ad-bc)$가 만들어지도록 4개의 식을 유도해보자

$$①*c - ③*a = (acx+bcz-c)-(acx+adz)=0\ \rightarrow \ (bc-ad)z = c \cdots ⑤$$

$$①*d-③*b = (adx+bdz-d)-(bcx+bdz)=0\ \rightarrow \ (ad-bc)x = d \cdots ⑥$$

$$②*c-④*a=(acy+bcr)-(acy+adr-a)=0\ \rightarrow \ (bc-ad)r = -a \cdots ⑦$$

$$②*d-④*b=(ady+bdr)-(bcy+bdr-b)=0\ \rightarrow \ (ad-bc)y = -b \cdots ⑧$$

⑤, ⑥, ⑦, ⑧을 볼 때, $ad-bc \neq 0$이다.
$ad-bc=0$인 경우, 행렬 $A$가 영행렬이기 때문에 전제가 성립하지 않는다.
⑤, ⑥, ⑦, ⑧의 양변을 $ad-bc$로 나눠보자.

$$⑤ \rightarrow z = \frac{-c}{ad-bc}$$

$$⑥ \rightarrow x = \frac{d}{ad-bc}$$

$$⑦ \rightarrow r = \frac{a}{ad-bc}$$

$$⑧ \rightarrow y = \frac{-b}{ad-bc}$$

⑤, ⑥, ⑦, ⑧으로부터 유도된 $x,y,z,r$를 $A^{-1}$에 대입하자.

$$A^{-1}=\frac{1}{ad-bc} \begin{pmatrix} d & -b\\ -c & a \end{pmatrix}$$

이차 정사각행렬의 역행렬을 구하는 공식이 유도 되었다.

3. 역행렬의 성질

3.1. $(A^{-1})^{n} = (A^{n})^{-1}$

$A$의 역행렬이 존재하면, $A^n$의 역행렬도 존재한다.
즉, $A^{100}$의 역행렬이 존재한다면, $A^{20}$의 역행렬도 존재한다는 소리다.

3.2. $(kA)^{-1} = \frac{1}{k}A^{-1}$

역원의 개념이므로, 상수 k가 뒤집어진다.
$k=0$인 경우, 어차피 영행렬이므로, 역행렬이 존재하지 않는다.

3.3. $(AB)^{-1} = B^{-1}A^{-1},\ \ (APB)^{-1} = B^{-1}P^{-1}A^{-1}$

3.4. 차수가 같은 두 행렬 A,B 모두 역행렬이 존재한다면, AB역시 역행렬이 존재한다.

역, 대우 모두가 참인 성질이다.
역) A, B중 적어도 하나가 역행렬이 존재하지 않는다면, AB의 역행렬 또한 존재하지 않는다.
대우) AB가 역행렬이 없으면, A, B 중 적어도 하나는 반드시 역행렬이 존재하지 않는다.

통계학이란?

만년필잉크 — Fri, 26 Feb 2021 13:40:36 +0900

통계학이란?

"통계학이란 불확실한 상황에서 현명한 의사결정을 하기 위한 이론과 방법의 체계이며, 통계학은 자료의 수집·분류·분석과 해석의 체계를 갖는다."
W.Allen Walls and Harry V.Roberts, Statistics: A New Approach(Glence, Ill., Free Press, 1956), p. 3.
(박정식, 윤영선, 박래수(2010) 현대통계학 제5판 참고)

"통계학은 실증적인 뿌리를 가지고 있으며 실질적 활용에 초점을 맞추고 있기 때문에, 순수수학과 구분되는 응용수학의 일종으로 여겨진다. 통계학의 방법을 통해, 실제 수치들을 왜곡하여 해석하는 것을 막고 연구를 바탕으로 합리적인 의사결정을 할 수 있다."
Moore, David(1992). <Teaching Statistics as a Respectable Subject>. F. Gordon and S. Gordon. <Statistics for the Twenty-First century>. Washington, DC: The Mathematical Association of America. 14-25쪽. ISBN 978-0-88385-078-7.
(Wikipidia 통계학 참고)

통계학은 Data를 다루는 학문으로, 연구자가 관심 있는 대상을 나타낼 수 있는 다량의 Data를 수집하는 것부터, 그 Data의 모양을 파악하고, 자신의 연구 모델에 맞게 Data를 체계화시켜, 그 안에 숨어 있는 패턴을 찾아내는 모든 과정에 대한 학문이라고 할 수 있다.
통계학은 머신러닝, 딥러닝을 비롯한 데이터를 다루는 각종 학문의 근간이 되므로, 통계학을 제대로 이해하지 못한다면, 다른 학문들의 원리를 제대로 이해할 수 없다.
통계학은 기본적으로 데이터가 어디에 모여 있고, 얼마나 흩어져 있는지를 통해서 데이터를 파악한다.

1. 모집단과 표본집단

◎ 모집단(Population): 연구자의 관심 대상이 되는 모든 개체의 집합으로, 연구 대상이 되는 데이터의 전체를 가리킨다.

◎ 표본집단(Sample): 모집단에서 추출해낸 개체의 집합이다.

모집단과 표본집단 예시 1)
- 연구자가 사람의 발 크기와 키에 대해 어떠한 경향성(Pattern)이 존재할 것이라고 생각했다고 해보자. 이를 확인하고자 한다면, 전 세계에 있는 모든 사람들(모집단)을 대상으로, 데이터를 모아야 할 것이다.
- 그러나, 이는 막대한 비용과 시간이 소모되기 때문에 불가능한 일이다. 때문에 연구자는 인종, 연령, 성별 등 다양한 변수들을 고려하여, 모집단을 대표할 수 있는 표본집단(Sample)을 추출하여, 모집단을 추정한다.

모집단과 표본집단 예시 2)
- 참치 통조림을 만드는 공장에서 제품에 이상이 있는지 확인하기 위해, X-ray를 비롯한 다양한 도구를 이용해서 전수 조사하였으나, 실제로 제품을 열어서 확인해보는 것이 가장 정확한 결과를 가져온다고 가정해보자.
- 모든 통조림을 열어서 확인해보는 것이 품질이 떨어지는 제품이 얼마나 발생하는지 알 수 있겠지만, 그렇게 했다간 통조림을 팔 수 없게 될 것이다. 때문에 모집단인 모든 통조림에서 통조림을 일부만 추출(표본집단)해서 모집단을 추정하게 된다.

모집단과 표본집단 예시 3)
- 당신이 통계 유치원 선생님이고, 기린반 어린이 30명과 해바라기반 어린이 25명과 함께 학예회 준비로 동요를 부르려고 하는데, 아이들이 뽀로로 주제가와 핑크퐁 아기 상어 중 무엇을 더 좋아할지를 몰라 이에 대해 고민하고 있다고 가정하자.
- 당신은 기린반 어린이와 해바라기반 어린이들을 대상으로 선호하는 캐릭터에 대해 조사를 할 수 있다. 이 경우 당신의 관심 대상인 기린반, 해바라기반 어린이들은 55명으로 매우 적기 때문에 모집단 전체에 대해 조사를 할 수도 있다.

모집단은 연구자의 마음에 따라 그 규모가 크게 달라지기 때문에, 예시 3)처럼 모집단의 규모가 작다면, 모집단 전체를 대상으로 분석을 할 수 있다. 즉, 반드시 표본집단을 통해서 통계 분석을 진행하는 것은 아니다.
그러나, 모집단이 작은 경우만 존재하지는 않기 때문에, 모집단을 가장 잘 대표할 수 있는 표본집단을 뽑아, 통계적 기법을 통해 모집단의 성격을 추정하는 것이 현대 통계학의 주류다.

2. 모수와 통계량

◎ 모수(Parameter): 모집단의 특성을 수치로 나타낸 것이다.

◎ 통계량(Statistic): 표본의 특성을 수치로 나타낸 것이다.

대전 여자 중학생의 평균 팔 굽혀 펴기 횟수를 알고 싶다고 가정해보자.
- 대전에 사는 여자 중학생들의 평균 팔 굽혀 펴기 횟수를 알기 위해, 완전 무작위로 각 중학교의 학년별 한 반의 여중생들을 대상으로 평균 팔 굽혀 펴기 횟수를 구했다.
- 모집단인 대전에 사는 모든 여자 중학생의 평균 팔 굽혀 펴기의 횟수(모수)와 표본집단의 평균 팔 굽혀 펴기 횟수(통계량)가 같다고 할 수 있을까?
- 우연히 샘플로 추출된 여중생들이 팔 굽혀 펴기를 유난히 잘하는 사람들이어서, 모수보다 통계량이 더 클 수도 있고, 반대로 우연히 운동을 너무 싫어하는 사람들이 뽑혀서 통계량이 모수보다 더 작을 수도 있다.
- 즉, 모수와 통계량은 같은 값이 아니다.

모집단의 특성을 나타내는 모수를 구하는 것이 가장 정확하겠으나, 앞서 봤듯 모수를 구하지 못하는 상황에서는 표본집단을 통해 모수를 추정해야 하고, 이때 표본집단의 특성을 나타내는 통계량을 이용하게 된다.
모수나 통계량은 앞서 말한 평균뿐만이 아니라, 각 집단을 나타낼 수 있는 다른 특성인 중위수, 최빈값, 최솟값, 최댓값, 분산, 표준편차 등도 다양한 지표들을 포함하는 개념이다.
모수는 그리스 문자($\mu,\ \sigma^2, \sigma$)로 표기하고, 통계량은 영어 알파벳($\bar{X}, S^2, S$)으로 표기하는 것이 관례다.
단, 모집단의 크기인 개체의 양은 $N$으로, 표본집단의 크기는 $n$으로 표기하는 것이 관례다.

3. 기술통계학과 추론통계학

◎ 기술통계학(Descriptive statistics): 데이터를 정리하고 요약하여, 데이터의 특성을 찾아 서술하는 통계학이다.

◎ 추론통계학(Inferential statistics): 모집단으로부터 추출한 표본집단의 특성(통계량)을 기반으로, 모집단 특성(모수)을 추측해내는 통계학이다.

기술통계학(Descriptive statistics)과 추론통계학(Inferential statistics)은 별개의 것이 아니며, 서로 연결되어 순차적으로 진행된다.
데이터를 분석하는 과정은 연구설계부터 자료수집, 자료 정리, 자료해석을 통해 모집단 또는 표본집단의 특성을 파악하는 기술통계학을 우선 실시한다.
표본을 대상으로 한 경우 표본에서 얻어진 통계량을 기초로 추론통계학을 실시해 모집단의 특성인 모수를 추정하게 된다.
즉, 기술통계량은 모집단, 표본집단 모두를 대상으로, 데이터의 특성(모수, 통계량)을 찾아내고, 대상 집단이 표본집단인 경우 추론통계학을 실시하여, 모수를 추정하게 된다.

기술통계학과 추론통계학의 예시)
- 기술통계학
  우리나라 남성들의 평균 키를 알기 위해, 모집단인 우리나라의 모든 남성들의 신장 Data를 수집하거나, 이는 비효율적이므로 일부를 표본집단으로부터 신장 Data를 추출하여 표본집단의 평균 키나 키의 표준편차를 구하여, 데이터의 특성을 파악한다.
- 추론통계학
  표본집단에서 구해진 통계량인 평균 키, 키의 표준편차를 기반으로 모집단인 우리나라 모든 남성들의 평균 키(모수)를 추정한다.

4. 모수통계학과 비모수통계학

◎ 모수통계학(Parametric statistics): 모집단의 분포에 대한 가정이 필요하며, 연속형 척도를 대상으로 한다.

◎ 비모수통계학(nonParametric statistics): 모집단에 대한 가정이 필요하지 않으며, 질적 자료나 양적 데이터라 할지라도 빈도수와 같은 비연속적인 데이터를 대상으로 한다.

모수통계학은 대상 집단의 모집단이 정규분포와 같은 분포를 따른다는 가정하에 진행된다.
즉, 연구자가 관심 있는 대상인 모집단의 분포 모양이 정규분포의 형태를 그리면서, 연속형 데이터를 대상으로 할 때, 모수통계학을 사용하고, 그 외의 기법들은 비모수통계학이라고 생각하면 된다.
추론통계학에서는 주로 비모수통계학보다 모수통계학을 사용하는데, 이는 모수통계학이 모수 추정에 있어 더 신뢰도가 높기 때문이다.
그러나, 모집단에 대한 정보가 전혀 없거나 부정확하여, 모수통계학의 가정을 만족시키지 못한 상태라면 비모수통계학의 신뢰도가 더 높다.

비모수통계학의 특징
- 분포 무관(Distribution-free) 검정법이라고도 불리며, 말 그대로 모집단의 분포에 상관없이 사용할 수 있다.
- 범주형 척도 같은 비연속성 데이터라 할지라도 분석할 수 있다.
- 계산 방법이 단순하여 빠르고 쉽게 통계량을 구할 수 있으며, 결과에 대한 해석과 이해가 쉽다.
- 표본을 많이 추출하기 어려운 경우에도 사용할 수 있다.

영인자(Zero Divisor)

만년필잉크 — Thu, 25 Feb 2021 17:53:56 +0900

영인자(Zero Divisor)

$A \neq O,\ B \neq O,\ AB = O$
$ A \neq O,\ A^2 = O$
행렬 $A$와 행렬 $B$가 영행렬이 아님에도 불구하고, 행렬 $AB$를 행렬곱하였을 때, 영행렬이 나오는 경우
위에서 보듯 $A$는 제곱하였을 때, 영행렬이 나왔다. 영인자의 존재로 인해 행렬에서는 방정식의 근, 지수법칙을 사용할 수 없다.
고등학교 행렬 문제에서 영인자의 존재는 수많은 반례를 가지고 오므로, 요주의 대상이다.

1. 영인자의 곱 순서

$$AB = O\ \overset{F}{\rightarrow} BA = O$$

$$ AB = O\ \overset{F}{\rightarrow} BA \neq O $$

영인자는 특정한 배열의 곱에서만 영행렬이 된다.
물론, 예외 역시 존재하기 때문에 $AB = BA = O$이 되는 경우도 존재한다.

>>> mat1 = np.array([[0, 0],[2, -2]])
>>> mat2 = np.array([[1, 0],[1, 0]])
>>> np.dot(mat1, mat2)
array([[0, 0],
       [0, 0]])
       
>>> np.dot(mat2, mat1)
array([[0, 0],
       [0, 0]])

2. 영인자는 역행렬을 가지지 않는다.

2.1. 증명

다음과 같은 정사각행렬 $A$가 있다고 하자.
$ A \neq O \rightarrow A^2 = O $
위 조건을 만족하는 행렬 $A$는 영행렬이 아니므로, 영인자이다.
정사각행렬이므로, 케일리 헤밀턴의 정리를 사용해보자
$ A^2 - (a+d)A + (ad - bc)E = O $
$A^2 = O$이고, $A \neq O,\ E \neq O$이므로, $(ad-bc)E = (a+d)A$가 성립해야한다.
그러나, 단위행렬의 배수는 제곱하여 영행렬이 될 수 없으므로, 영인자인 행렬 $A$는 단위행렬의 배수가 아니다.
그러므로, $(a+b)=0, (ad-bc)=0$이 성립한다.
$ad-bc=0$이므로, 역행렬 생성 법칙에 따라, 영인자 $A$는 역행렬을 가질 수 없다.

2.2. 케일리 헤밀턴 정리(Cayley–Hamilton theorem)

이차 정사각행렬 $A$에 대하여 케일리 헤밀턴 정리를 사용하면, 행렬의 거듭제곱을 아주 쉽게 구할 수 있다.
$A \neq kE$일 때 사용 가능하다(행렬 $A$가 단위행렬의 배수가 아닐 때).

$$ A = \begin{pmatrix}
a & b\\
c & d
\end{pmatrix} \neq kE $$

$$ A^2 - (a+d)A + (ad - bc)E = O $$

케일리 헤밀턴 정리 사용 예시

$$A = \begin{pmatrix}
1 & 2\\
3 & 4
\end{pmatrix}$$

$$A^2 - 5A -2E = O \rightarrow A^2 = 5A + 2E$$

2.3. 영인자와 역행렬 관계

위에서 봤듯이 영인자인 행렬은 역행렬이 존재할 수 없다.
반대로 말하자면, 역행렬이 존재하는 행렬은 영인자가 아니라는 소리다.
만약 행렬 $A$와 $B$가 역행렬이 존재한다면 영인자가 아니라는 의미이므로, 다음 공식이 성립한다.

$$(AB)^2 = A^2B^2 \ \overset{T}{\rightarrow}\ AB=BA$$

$$ABAB = AABB$$

$$A^{-1}ABABB^{-1} = A^{-1}AABBB^{-1}$$

$$BA = AB$$

그러나 행렬은 3차 이상에서부터는 성립하지 않는 경우가 많으므로 위 공식도 주의해야한다.

$$(AB)^3 = A^3B^3 \ \overset{F}{\rightarrow}\ AB=BA$$

$$ABABAB = AAABBB$$

$$A^{-1}ABABABB^{-1} = A^{-1}AAABBBB^{-1}$$

$$BABA = AABB$$

$BABA = ABAB$와 $BA = AB$는 다르다.

3. 영인자와 지수법칙

영인자의 존재로 인해 행렬에서는 지수법칙을 사용하기가 어렵다.
영인자의 존재로 인해 행렬은 지수에 대하여 다음과 같은 성질을 갖는다.

$$A^n(n\geq 3)\ \overset{F}{\rightarrow}\ A=O$$

$$A^n(n\geq 3)\ \overset{T}{\rightarrow}\ A^2=O$$

영인자의 존재로 인해, 위 명제에서 행렬 $A=O$이라고 할 수 없다.
행렬 $A$가 영인자인 경우 $A^2=O$이므로, 그 이상의 차수에서도 모두 영행렬이 나오게 된다.

3.1. 지수법칙이 반드시 성립불가한 것은 아니다.

하나의 행렬에서는 지수법칙이 성립한다.

$$A^m*A^n = A^{m+n},\ (m, n \in N)$$

$$(A^m)^n = A^{mn}$$

그러나, 하나의 행렬이 아닌 경우에는 성립하지 않는다.
이는 교환법칙이 성립하지 않기 때문이다.

$$(AB)^n \neq A^nB^n$$

$$ABABABAB \neq AAAABBBB$$

3.2. 영인자와 지수법칙

$$(AB)^n = A^nB^n \overset{F}{\rightarrow} AB = BA$$

영인자의 존재로 인해 위 명제는 성립하지 않는다.

3.2.1. 증명

$AB = O$로 영인자라고 가정해보자.
영인자의 성질로 인해 $BA \neq O$일 수 있다.

$$(AB)^n = O,\ A^nB^n = AA\cdots AABB\cdots BB = O$$

영인자 AB의 존재로 인해 $(AB)^n = A^nB^n$은 성립하였으나, $AB=BA$는 성립하지 않는다.

3.2.2. 역은 성립한다.

$$(AB)^n = A^nB^n \overset{T}{\leftarrow} AB = BA$$

$AB = BA$라는 말은 $AB$가 영인자인 경우라 할지라도 $AB=BA=O$이 성립하고, 교환 법칙이 성립할수도 있다는 의미이기 때문이다.

행렬의 성질

만년필잉크 — Thu, 25 Feb 2021 15:12:27 +0900

행렬의 성질

전제: $M_{(m*n)},\ A \in M,\ B \in M, \ C \in M$

1. 기본 연산

1.1. 행렬의 덧셈과 뺄셈

$A + B \in M$, $A - B \in M$
동형인 행렬끼리만 +, -가 가능하다(행렬은 덧셈 뺄셈에 대하여 닫혀 있다.)

>>> Mat1 = np.arange(0, 15).reshape((3,5))
>>> Mat2 = np.full((3,5), 3)
>>> Mat1 + Mat2
array([[ 3,  4,  5,  6,  7],
       [ 8,  9, 10, 11, 12],
       [13, 14, 15, 16, 17]])
       
>>> Mat1 - Mat2
array([[-3, -2, -1,  0,  1],
       [ 2,  3,  4,  5,  6],
       [ 7,  8,  9, 10, 11]])

1.2. 행렬의 곱셈

$AB^T \notin M$
행렬끼리 곱을 하면 행과 열의 모양이 바뀐다.
행렬끼리 곱을 하려면, 앞의 행렬의 열과 뒤의 행렬의 행의 크기가 동일해야 한다.
위 조건을 만족할 때, 출력된 행렬의 모양은 앞 행렬의 행($l$)과 뒤 행렬의 열($n$)의 모양인 행렬($l*n$)이 나온다.
$(l * m) * (m * n) = (l * n) $
행렬은 행렬끼리의 곱에 대하여 닫혀있지 않다고 할 수 있으나, 정방 행렬 간의 곱에 대해서는 닫혀 있다고 할 수 있다.
$m = n,\ AB \in M$

# 행렬 곱 시, 행렬의 모양이 바뀐다.
>>> Mat1 = np.arange(0, 15).reshape((3,5))
>>> Mat2 = np.full((3,5), 3)
>>> np.dot(Mat1, Mat2.T)
array([[ 30,  30,  30],
       [105, 105, 105],
       [180, 180, 180]])
       
# 정방행렬끼리의 곱을 하는 경우, 행렬 모양이 유지된다.
>>> Mat3 = np.arange(0, 9).reshape((3,3))
>>> Mat4 = np.full((3,3), 3)
>>> np.dot(Mat3, Mat4)
array([[ 9,  9,  9],
       [36, 36, 36],
       [63, 63, 63]])

2. 결합 법칙

2.1. 덧셈의 결합 법칙

$(A+B)+C = A+(B+C)$
행렬의 덧셈과 뺄셈은 각 행렬의 형태가 동일해야 하며, 그 순서를 어떻게 하는지는 상관없다.

>>> Mat1 = np.arange(0, 15).reshape((3,5))
>>> Mat2 = np.repeat(np.array([1,2,3]), 5).reshape((3,5))
>>> Mat3 = np.array([[1,3,5,7,9],[2,4,6,8,10],[3,6,9,12,15]])
>>> (Mat1 + Mat2) + Mat3 == Mat1 + (Mat2 + Mat3)
array([[ True,  True,  True,  True,  True],
       [ True,  True,  True,  True,  True],
       [ True,  True,  True,  True,  True]])

2.2 곱셈의 결합 법칙

$A(B^TC) = (AB^T)C$

>>> Mat1 = np.arange(0, 15).reshape((3,5))
>>> Mat2 = np.array([[1,3],[2,4],[3,6],[4,8],[5,10]])
>>> Mat3 = np.array([[1,3,5,7,9,11,13],[2,4,6,8,10,12,14]])
>>> np.dot(np.dot(Mat1,Mat2),Mat3) == np.dot(Mat1,np.dot(Mat2,Mat3))
array([[ True,  True,  True,  True,  True,  True,  True],
       [ True,  True,  True,  True,  True,  True,  True],
       [ True,  True,  True,  True,  True,  True,  True]])

3. 항등원(Identity Elementa)

3.1 행렬의 덧셈의 항등원

$ A + O = O + A = A$
영행렬은 행렬의 덧셈의 항등원이다.
뺄셈은 부호가 바뀌게 되므로 항등원이 없다.

>>> Mat1 = np.arange(0, 15).reshape((3,5))
>>> Mat2 = np.zeros((3,5))
>>> Mat1 + Mat2 == Mat2 + Mat1
array([[ True,  True,  True,  True,  True],
       [ True,  True,  True,  True,  True],
       [ True,  True,  True,  True,  True]])

3.2. 행렬의 곱셈의 항등원

$AE = EA = A$
모든 정방 행렬 $A$에 대하여 단위행렬 $E$를 곱하면 행렬 $A$가 나온다.

>>> Mat1 = np.arange(0, 16).reshape((4,4))
>>> Mat2 = np.identity(4)
>>> np.dot(Mat1, Mat2) == Mat1
array([[ True,  True,  True,  True],
       [ True,  True,  True,  True],
       [ True,  True,  True,  True],
       [ True,  True,  True,  True]])
       
>>> Mat1 == np.dot(Mat1, Mat2)
array([[ True,  True,  True,  True],
       [ True,  True,  True,  True],
       [ True,  True,  True,  True],
       [ True,  True,  True,  True]])

4. 역원

4.1. 덧셈에 대한 역원

$A+(-A) = (-A) + A = O$

>>> Mat1 = np.arange(0, 12).reshape((4,3))
>>> Mat1 + (-Mat1) == (-Mat1) + Mat1
array([[ True,  True,  True],
       [ True,  True,  True],
       [ True,  True,  True],
       [ True,  True,  True]])
       
>>> Mat1 + (-Mat1)
array([[0, 0, 0],
       [0, 0, 0],
       [0, 0, 0],
       [0, 0, 0]])

4.2. 곱셈에 대한 역원

$AA^{-1} = A^{-1}A = E$
역행렬을 갖지 않는 경우도 존재하므로, 항상 성립하는 것은 아니다.
$AB = BA = E$인 경우 B는 A의 역행렬이다.

>>> Mat = np.array([[0, 1],[2, 3]])
>>> Inv_Mat = np.linalg.inv(Mat)
>>> np.dot(Mat, Inv_Mat)
array([[1., 0.],
       [0., 1.]])

4.3. 곱셈에 대한 역원에서 파생된 행렬 성질

$A(A+B) = E \Rightarrow AB = BA$

4.3.1. 증명

$A(A+B) = E$이므로, $A^{-1}$은 존재한다. $A^{-1} = (A+B)$이므로, 다음 식이 성립한다.

$$A(A + B) = (A + B)A\ \rightarrow \ A^2 + AB = A^2 + BA \ \rightarrow \ AB = BA$$

5. 교환 법칙

5.1. 행렬의 교환 법칙은 성립하지 않는다.

$AB \neq BA$
교환법칙이 성립하지 않으므로 곱셈법칙, 지수법칙을 적용할 수 없다(항상은 아니며, 가능한 경우도 있으므로, 부분적으로 사용 가능하다).
대우: 곱셈법칙이 성립한다면 $AB = BA$가 성립한다. [거짓]
행렬에서는 대우 명제마저도 성립하지 않을 수 있다.

5.1.1 증명

$$(A+B)^2 = A^2 + 2AB + B^2\ \overset{T}{\rightarrow} \ AB = BA \cdots (1)$$

$$(A+B)^3 = A^2 + 3A^2B + 3AB^2 + B^3 \ \overset{F}{\rightarrow} \ AB = BA \cdots (2)$$

$AB$가 영인자인 경우, $A^2 + 3AAB + 3ABB + B^3 = A^3 + B^3 = A^2 + 3A^2B + 3AB^2 + B^3$은 성립한다.
$AB$는 영인자이므로, $AB=O$은 성립하나, $BA \neq O$이다.
행렬에서는 영인자의 존재로 인해 2차 함수에서 성립하는 것이 3차 함수 이상에서는 성립하지 않을 수 있다.

5.2. 교환 법칙 관련 재밌는 공식

$A + B = AB$라면 $AB = BA$이다.

5.2.1. 증명

$$A + B = AB \rightarrow AB - A - B = O \rightarrow (A-E)(B-E)-E=O$$

$(A-E)(B-E)=E$이므로, $(A-E)^{-1},\ (B-E)^{-1}$이 존재한다.

$$ (A-E)(B-E)=E=(B-E)(A-E)\rightarrow BA -A-B=O $$

$$ \therefore AB = BA $$

행렬(Matrix)

만년필잉크 — Thu, 25 Feb 2021 13:33:50 +0900

행렬(Matrix)

수학에서 행렬은 1개 이상의 수 또는 다항식 등을 사각형 모양으로 배열한 것이다. 가로 줄은 행(Row), 세로 줄은 열(Column)이라 부른다.

아서 케일리와 윌리엄 로원 해밀턴이 발명했으며, 행렬식의 값에 따라 연립방정식의 해가 다르게 나오는 것을 보고, 연립 방정식의 계수와 변수를 분리하여 사용하게 되면서 행렬이 등장하게 되었다.

1. 행렬의 정의

$m * n$ 행렬은 각 행 $i \in \{1,...,m\}$ 및 열 $j \in \{1,...,n\}$의 순서쌍 $(i, j)$에 대하여, 원소 $A_{ij} \in R$을 대응시키는 함수 $A = (A_{ij})_{ij}$이다.
행렬 $A$는 모든 성분을 사각형으로 배열하고 소괄호 또는 대괄호를 추가하여 다음과 같이 표기한다.

$$ A = \begin{bmatrix}
A_{11}& A_{12} & A_{13}  & ... & A_{1n}\\
A_{21}& A_{22} & A_{23}  & ... & A_{2n}\\
A_{31}& A_{32} & A_{33}  & ... & A_{3n}\\
\vdots & \vdots & \vdots & \ddots & \vdots\\
A_{m1}& A_{m2} & A_{m3}  & ... & A_{mn}\\
\end{bmatrix} $$

$A_{ij}$를 $A$의 $i$번째 행 $j$번째 열의 성분(Entry) 또는 원소(Element) 또는 계수(Coefficient)라 한다.
행렬 $A$의 각 성분은 행과 열의 번째 수를 첨수로 사용해, $A_{ij},\ A_{i,j},\ a_{ij},\ a_{i,j},\ A(i,j),\ A[i,j]$ 등과 같이 표현한다.
행렬은 실수에 대해 닫혀 있으며, 행렬 연산 시 실수가 나온다.
행과 열의 번째수가 동일한 성분 $A_{ii}\ (i \in \{1, ..., min\{m,n\}\})$을 $A$의 대각 성분(Diagonal entry) 또는 대각 원소(Diagonal element), 대각 요소, 주대각 성분이라고 한다.

행렬 $A$의 크기(Size)는 행과 열의 수의 순서쌍 $(m,n)$ 또는 $m*n$으로 나타낸다.
만약 행과 열의 수가 같다면($m=n$) 행렬$A$를 정사각 행렬(Square matrix) 또는 정방 행렬이라 부른다.
행과 열의 수가 다르다면($m \neq n$) 직사각 행렬(Rectangular matrix) 또는 장방 행렬이라 부르는데, 일반적으로 행렬은 직사각형이므로, 정방 행렬과 구분하고자 하는 경우가 아니라면 그냥 행렬이라 부른다.

만약, $m=1$이라면 행렬 $A$를 $1*n$ 행 백터(Row vector)라고 한다.
만약, $n=1$이라면 행렬 $A$를 $m*1$ 열 벡터(Column vector)라고 한다.
만약, $m=1,\ n=1$인 행렬 $A$는 스칼라(Scalar)라고 한다.

$$X = \begin{bmatrix} x_1 & x_2 & x_3 & ... &x_n \end{bmatrix}$$

$$X = \begin{bmatrix}
x_1\\
x_2\\
x_3\\
\vdots \\
x_n
\end{bmatrix}$$

$$X = \begin{bmatrix} x_1 \end{bmatrix}$$

즉, 벡터와 스칼라 역시 수학적으로는 행렬에 속한다.

2. Python과 다양한 형태의 행렬

Python에서는 Numpy 라이브러리를 사용해서 행렬, 벡터를 만든다.
Python의 Numpy라이브러리를 사용해서 다양한 형태의 행렬을 만들어보도록 하겠다.

import numpy as np

2.1. 직사각 행렬(Rectangular matrix)

>>> np.arange(0, 18).reshape((3,6))
array([[ 0,  1,  2,  3,  4,  5],
       [ 6,  7,  8,  9, 10, 11],
       [12, 13, 14, 15, 16, 17]])
       
       
# 랜덤한 값으로 만들수도 있다.
>>> np.random.randint(0, 20, size=(3, 6))
array([[16,  9,  1,  6,  7, 18],
       [ 4, 15, 15, 16, 13, 16],
       [ 8,  1,  2,  8, 11,  8]])

직사각형 모양의 행렬로, 장방 행렬이라고도 부르며, 가장 일반적인 행렬이다.

2.2. 정사각 행렬(Square matrix)

>>> np.arange(0, 16).reshape((4,4))
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11],
       [12, 13, 14, 15]])
       
       
>>> np.random.randint(0, 20, size=(3, 3))
array([[ 5,  8,  7],
       [13,  9,  0],
       [ 8, 17,  8]])

정사각형 모양의 행렬로, 정방 행렬이라고도 부른다.

2.3. 영행렬(Zero matrix)

>>> np.zeros((4, 5))
array([[0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0.]])

모든 원소가 0인 행렬로, 행렬 곱에서 영원으로 작용하는 행렬이다.

2.4. 항등행렬(Identity matrix)

>>> np.identity(4)
array([[1., 0., 0., 0.],
       [0., 1., 0., 0.],
       [0., 0., 1., 0.],
       [0., 0., 0., 1.]])

대각 성분은 모두 1이며, 나머지 원소는 0인 행렬이다.
행렬 곱셈에서 항등원으로 작용하며, 다른 행렬에 곱하면, 곱한 행렬이 그대로 나오게 된다.
단위행렬이라고도 부른다.

2.5. 대각행렬(Diagonal matrix)

# 대각행렬 만들기
>>> diag_M = np.diag((4, 2, 2, 5, 1, 6))
>>> diag_M
array([[4, 0, 0, 0, 0, 0],
       [0, 2, 0, 0, 0, 0],
       [0, 0, 2, 0, 0, 0],
       [0, 0, 0, 5, 0, 0],
       [0, 0, 0, 0, 1, 0],
       [0, 0, 0, 0, 0, 6]])

# 대각성분 뽑기
>>> np.diagonal(diag_M)
array([4, 2, 2, 5, 1, 6])

# 대각성분이 1인 행렬 만들기
>>> np.eye(3, 3)
array([[1., 0., 0.],
       [0., 1., 0.],
       [0., 0., 1.]])
       
# 장방행렬로 만들기
>>> np.eye(5, 3)
array([[1., 0., 0.],
       [0., 1., 0.],
       [0., 0., 1.],
       [0., 0., 0.],
       [0., 0., 0.]])

대각행렬은 주대각선 원소를 제외한 모든 원소가 0인 정방행렬이다.
영행렬, 단위 행렬은 대각 행렬에 포함된다.
장방행렬 역시 주대각 성분을 제외한 나머지 원소가 0인 경우 대각행렬에 포함된다.

2.6. 스칼라 행렬(Scalar matrix)

# 대각 성분이 모두 1인 대각행렬
>>> np.identity(4)
array([[1., 0., 0., 0.],
       [0., 1., 0., 0.],
       [0., 0., 1., 0.],
       [0., 0., 0., 1.]])
       
# 대각 성분이 모두 같은 대각행렬
>>> np.diag(np.full(4, 5))
array([[5, 0, 0, 0],
       [0, 5, 0, 0],
       [0, 0, 5, 0],
       [0, 0, 0, 5]])

주대각 성분이 모두 같은 원소로 된 대각행렬

2.7. 삼각행렬(Triangular matrix)

# 정방행렬
>>> Mat = np.arange(0, 36).reshape((6,6))
>>> Mat
array([[ 0,  1,  2,  3,  4,  5],
       [ 6,  7,  8,  9, 10, 11],
       [12, 13, 14, 15, 16, 17],
       [18, 19, 20, 21, 22, 23],
       [24, 25, 26, 27, 28, 29],
       [30, 31, 32, 33, 34, 35]])
       
# 상삼각행렬
>>> np.triu(Mat, 0)
array([[ 0,  1,  2,  3,  4,  5],
       [ 0,  7,  8,  9, 10, 11],
       [ 0,  0, 14, 15, 16, 17],
       [ 0,  0,  0, 21, 22, 23],
       [ 0,  0,  0,  0, 28, 29],
       [ 0,  0,  0,  0,  0, 35]])
       
# 하삼각행렬
>>> np.tril(Mat, 0)
array([[ 0,  0,  0,  0,  0,  0],
       [ 6,  7,  0,  0,  0,  0],
       [12, 13, 14,  0,  0,  0],
       [18, 19, 20, 21,  0,  0],
       [24, 25, 26, 27, 28,  0],
       [30, 31, 32, 33, 34, 35]])

정방행렬의 특수한 경우로, 주대각선을 기준으로 대각항의 위쪽이나 아래쪽 항들의 값이 모두 0인 경우를 의미한다.
주대각선 성분을 기준으로 아래가 모두 0이면 상삼각행렬(Upper Triangular matrix)이다.
주대각선 성분을 기준으로 위가 모두 0이면 하삼각행렬(Lower Triangular matrix)이다.

2.8. 전치행렬(Transpose Matrix)

>>> Mat = np.arange(0, 16).reshape((4,4))
>>> Mat
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11],
       [12, 13, 14, 15]])
       
# 전치행렬 만들기
>>> Mat.T
array([[ 0,  4,  8, 12],
       [ 1,  5,  9, 13],
       [ 2,  6, 10, 14],
       [ 3,  7, 11, 15]])
       
>>> np.transpose(Mat)
array([[ 0,  4,  8, 12],
       [ 1,  5,  9, 13],
       [ 2,  6, 10, 14],
       [ 3,  7, 11, 15]])

행렬 $A$의 전치행렬은 $A^T$로 표기한다.
주대각 성분을 기준으로 행과 열을 대칭으로 바꾼 행렬
주대각 성분을 기준으로 하므로, 주대각 성분은 변하지 않는다.
정사각행렬 $A$가 $A^T=A$를 만족하면 행렬 $A$는 대칭행렬이다.
(전치행렬인 $A^T$는 주대각 성분을 기준으로 행과 열을 대칭으로 바꾸기 때문이다.)
반대로, $A^T=-A$를 만족하면 반대칭행렬(Skew symmetric matrix) 또는 교대행렬(Alternating matrix)이라 한다.

2.9. 직교행렬(Orthogonal matrix)

>>> Ort_M = np.array([[0,0,1],[1,0,0],[0,1,0]])
>>> Ort_M
array([[0, 0, 1],
       [1, 0, 0],
       [0, 1, 0]])
       
# 행렬 Ort_M과 전치행렬 Ort_M을 행렬곱하였을 때, 단위 행렬이 나오는 행렬 Ort_M
>>> np.dot(Ort_M, Ort_M.T)
array([[1, 0, 0],
       [0, 1, 0],
       [0, 0, 1]])

행렬 A의 역행렬이 A의 전치행렬인 행렬 A를 직교행렬이라 한다.
직교행렬과 직교행렬의 전치행렬을 행렬곱하면 단위행렬이 나온다.
$A^{-1} = A^T, \ A^TA = I$

Tensorflow-4.3. Wide & Deep Learning(3) - 다중출력모델(규제기법)

만년필잉크 — Thu, 25 Feb 2021 00:37:24 +0900

이전 포스트까지 Wide & Deep Learning 모델을 사용해서 다중 입력 모델을 만들어보았다. 이번엔 이전 모델에 추가로 출력층을 추가하여 출력층을 2개로 만들어 보도록 하자.

다중 출력 모델

일반적으로 다중 출력 모델을 사용하는 이유는 다음과 같다.

프로세스가 서로 독립적인 경우:
동일한 데이터 셋에서 두 개 이상의 출력층을 생성하지만, 출력된 결과는 전혀 다른 작업을 위해 실행되는 경우로, 예를 들어 인터넷 사용 Log 데이터를 기반으로, 대상의 관심사 파악(분류 모델)과 인터넷 사용률 예측(회귀 모델)은 별개의 목적을 위해 진행된다.
프로세스가 한 목적을 위해 상호 보완적으로 이루어지는 경우:
하나의 목적을 이루기 위해 두 개 이상의 출력 값이 필요하여, 동일한 데이터 셋에서 두 개 이상의 출력층을 뽑아내는 경우로, 예를 들어 영상 속 물건을 인식하는 모델을 만든다면, 영상 속 물건의 위치(회귀 모델)와 물건의 종류(분류 모델)를 동시에 파악해야 한다.
규제 도구로써의 다중 출력 모델:
하위 네트워크가 나머지 네트워크에 의존하지 않고, 그 자체로 유용한 성능을 내는지 확인을 하기 위한 규제 기법으로 사용

이번 포스트에서는 Wide & Deep Learning model에 다중 출력 모델을 규제 도구로써 사용해보도록 하자.

1. 규제 도구로써의 다중 출력 모델

보조 출력층(Auxiliary Output)을 통해, 하위 네트워크가 나머지 네트워크에 의존하지 않고 그 자체로 유용한 것을 학습하는지 확인한다. 위 모델대로라면, Deep model에서의 출력된 값이 Wide model과의 연결로 인해, 원하는 결과를 뽑아내는 것인지, Deep model으로 인해 그러한 결과가 나왔는지 확인할 수 있다.
이를 통해, 과대 적합을 감소시키고, 모델의 일반화 성능이 높이도록 학습에 제약을 가할 수 있다.

2. 모델 생성 이전까지의 코드 가져오기

이전 포스트에서 만들었던, 모델 이전까지의 코드를 모두 가지고 온다.
입력층이 2개일 때는 입력 데이터를 목적에 맞게 나눴어야 했지만, 이번엔 출력층이 다른 데이터를 출력하는 것이 아니라, 보조 출력층(Auxiliary Output)과 주 출력층(Main Output)이 동일한 정답에 대해 어느 정도의 손실 값과 정확도를 내보내는지 알고 싶은 것이므로, Label dataset을 나누지 않아도 된다.

#################################### Import Module ####################################
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import callbacks
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.layers import (Input, Dense, concatenate)
########################################################################################





#################################### Import Dataset ####################################
# 캘리포니아 데이터 가져오기
Rawdict = fetch_california_housing()
CaliFornia_DF = pd.DataFrame(Rawdict.data, columns=Rawdict.feature_names)
########################################################################################




#################################### Data Handling #####################################
# 데이터를 쪼개기 좋게 변수의 순서를 바꾸자
CaliFornia_DF = CaliFornia_DF[["HouseAge", "Population", "Latitude", "Longitude", "MedInc",
                               "AveRooms", "AveBedrms", "AveOccup"]]

# train, validation, test set으로 쪼갠다.
X_train_all, X_test, y_train_all, y_test = train_test_split(CaliFornia_DF.values, Rawdict.target, test_size = 0.3)
X_train, X_valid, y_train, y_valid = train_test_split(X_train_all, y_train_all, test_size = 0.2)

# 정규화시킨다.
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_valid = scaler.transform(X_valid)
X_test = scaler.transform(X_test)

# 데이터 셋을 input layer의 수만큼 쪼갠다.
X_train_A, X_train_B = X_train[:, :1], X_train[:,1:]
X_valid_A, X_valid_B = X_valid[:, :1], X_valid[:,1:]
X_test_A, X_test_B = X_test[:, :1], X_test[:,1:]
########################################################################################

3. 모델 생성

######################################## Model ########################################
input_A = Input(shape=[1], name = "deep_input")
input_B = Input(shape=[7], name = "wide_input")
hidden1 = Dense(30, activation="relu", name = "hidden1")(input_A)
hidden2 = Dense(30, activation="relu", name = "hidden2")(hidden1)
concat = concatenate([input_B, hidden2], name = "concat")
output = Dense(1, name="main_output")(concat)

# 보조 출력층 생성
aux_output = Dense(1, name="aux_output")(hidden2)
model = keras.Model(inputs=[input_A, input_B], outputs=[output, aux_output])
########################################################################################

>>> model.summary()
Model: "model"
__________________________________________________________________________________________________
Layer (type)                    Output Shape         Param #     Connected to                     
==================================================================================================
deep_input (InputLayer)         [(None, 1)]          0                                            
__________________________________________________________________________________________________
hidden1 (Dense)                 (None, 30)           60          deep_input[0][0]                 
__________________________________________________________________________________________________
wide_input (InputLayer)         [(None, 7)]          0                                            
__________________________________________________________________________________________________
hidden2 (Dense)                 (None, 30)           930         hidden1[0][0]                    
__________________________________________________________________________________________________
concat (Concatenate)            (None, 37)           0           wide_input[0][0]                 
                                                                 hidden2[0][0]                    
__________________________________________________________________________________________________
main_output (Dense)             (None, 1)            38          concat[0][0]                     
__________________________________________________________________________________________________
aux_output (Dense)              (None, 1)            31          hidden2[0][0]                    
==================================================================================================
Total params: 1,059
Trainable params: 1,059
Non-trainable params: 0
__________________________________________________________________________________________________

앞서 학습했던 방법처럼 보조 출력층 생성 역시 Keras API 함수로 구현하는 것은 꽤 단순하다.
보조 출력층(aux_output)과 데이터를 받는 층(hidden2)을 연결시키고, model에서 outputs을 2개 다 잡아주면 된다.

4. 모델 컴파일

다중 입력 모델과 달리 다중 출력 모델에서는 모델 컴파일 방법이 바뀌게 된다.
이는, 컴파일에서 출력층에서 모델을 평가하게 되는 손실 함수를 결정하기 때문이고, 이 손실 함수는 출력층마다 다르게 설정해야 하기 때문이다.

# 모델 컴파일
model.compile(optimizer=Adam(learning_rate=0.005),
              loss = ["msle", "msle"],
              metrics=["accuracy"],
              loss_weights=[0.9, 0.1])

최적화나 모델 평가 지표는 출력층의 수와 상관없기 때문에 바뀌지 않는다.
손실 함수는 출력층이 2개가 되었으므로, 2개를 잡아줘야 한다(만약, 손실 함수를 하나만 잡아준다면, 모든 출력의 손실 함수가 같다고 가정한다 - 위 경우에는 출력층이 회귀모형이므로, msle로 같은 손실 함수를 사용하므로, msle 하나만 사용해도 된다).
loss_weights: 출력 층별 손실 값의 가중치를 정해준다. 케라스는 기본적으로 출력된 손실 값들을 모두 더해 최종 손실을 구하며, 이를 기반으로 학습을 한다. 여기서 사용된 보조 출력은 규제로 사용되었기 때문에 주 출력이 더 중요하다. 그러므로, 주 손실 값에 더 많은 가중치를 부여하였다.

5. 모델 학습 및 평가

모델 학습과 평가에서의 차이는 Label 역시 각 출력층에 맞게 2개가 들어가야 한다는 것이다.
해당 다중 출력 모델은 규제 목적으로 보조 출력층을 추가한 것이므로, 동일한 데이터를 label로 사용해도 된다.

early_stop = keras.callbacks.EarlyStopping(monitor='val_loss', patience=30, restore_best_weights=True)

# 학습
history = model.fit([X_train_A, X_train_B], [y_train, y_train],
                    epochs=300,
                    batch_size = 32,
                    validation_data=([X_valid_A, X_valid_B], [y_valid, y_valid]),
                    callbacks=[early_stop])

Epoch 1/300
362/362 [==============================] - 3s 6ms/step - loss: 0.2162 - main_output_loss: 0.1988 - aux_output_loss: 0.3726 - main_output_accuracy: 0.0027 - aux_output_accuracy: 0.0023 - val_loss: 0.0697 - val_main_output_loss: 0.0633 - val_aux_output_loss: 0.1276 - val_main_output_accuracy: 0.0048 - val_aux_output_accuracy: 0.0048
Epoch 2/300
362/362 [==============================] - 1s 2ms/step - loss: 0.0650 - main_output_loss: 0.0584 - aux_output_loss: 0.1243 - main_output_accuracy: 0.0026 - aux_output_accuracy: 0.0026 - val_loss: 0.0619 - val_main_output_loss: 0.0544 - val_aux_output_loss: 0.1295 - val_main_output_accuracy: 0.0048 - val_aux_output_accuracy: 0.0048
Epoch 3/300
362/362 [==============================] - 1s 2ms/step - loss: 0.0584 - main_output_loss: 0.0509 - aux_output_loss: 0.1260 - main_output_accuracy: 0.0027 - aux_output_accuracy: 0.0027 - val_loss: 0.0598 - val_main_output_loss: 0.0522 - val_aux_output_loss: 0.1279 - val_main_output_accuracy: 0.0048 - val_aux_output_accuracy: 0.0048
Epoch 4/300
362/362 [==============================] - 1s 2ms/step - loss: 0.0555 - main_output_loss: 0.0480 - aux_output_loss: 0.1229 - main_output_accuracy: 0.0018 - aux_output_accuracy: 0.0018 - val_loss: 0.0591 - val_main_output_loss: 0.0514 - val_aux_output_loss: 0.1281 - val_main_output_accuracy: 0.0045 - val_aux_output_accuracy: 0.0048

...

Epoch 54/300
362/362 [==============================] - 0s 1ms/step - loss: 0.0522 - main_output_loss: 0.0444 - aux_output_loss: 0.1227 - main_output_accuracy: 0.0024 - aux_output_accuracy: 0.0024 - val_loss: 0.0556 - val_main_output_loss: 0.0476 - val_aux_output_loss: 0.1276 - val_main_output_accuracy: 0.0045 - val_aux_output_accuracy: 0.0048
Epoch 55/300
362/362 [==============================] - 1s 1ms/step - loss: 0.0524 - main_output_loss: 0.0446 - aux_output_loss: 0.1225 - main_output_accuracy: 0.0026 - aux_output_accuracy: 0.0026 - val_loss: 0.0540 - val_main_output_loss: 0.0460 - val_aux_output_loss: 0.1263 - val_main_output_accuracy: 0.0045 - val_aux_output_accuracy: 0.0048
Epoch 56/300
362/362 [==============================] - 1s 2ms/step - loss: 0.0525 - main_output_loss: 0.0448 - aux_output_loss: 0.1215 - main_output_accuracy: 0.0024 - aux_output_accuracy: 0.0024 - val_loss: 0.0539 - val_main_output_loss: 0.0458 - val_aux_output_loss: 0.1265 - val_main_output_accuracy: 0.0048 - val_aux_output_accuracy: 0.0048
Epoch 57/300
362/362 [==============================] - 0s 1ms/step - loss: 0.0535 - main_output_loss: 0.0457 - aux_output_loss: 0.1234 - main_output_accuracy: 0.0033 - aux_output_accuracy: 0.0033 - val_loss: 0.0543 - val_main_output_loss: 0.0463 - val_aux_output_loss: 0.1264 - val_main_output_accuracy: 0.0045 - val_aux_output_accuracy: 0.0048

>>> model.evaluate([X_test_A, X_test_B], [y_test, y_test])

194/194 [==============================] - 0s 1ms/step - loss: 0.0533 - main_output_loss: 0.0454 - aux_output_loss: 0.1241 - main_output_accuracy: 0.0029 - aux_output_accuracy: 0.0032
[0.05328081175684929,
 0.04541592299938202,
 0.12406466901302338,
 0.0029069767333567142,
 0.0032299740705639124]

이전과 달리 값이 굉장히 많이 나오기 때문에 이를 파악하기 어려울 수 있는데, 그 내용은 생각보다 상당히 단순하다.
손실 값은 loss: 0.0533, main_output_loss: 0.0454, aux_output_loss: 0.1241이 나왔다.
여기서 loss만 신경 쓰면 된다. 위에서 우리는 main_output_loss와 aus_output_loss의 가중치를 0.9, 0.1로 부여하였는데, loss는 각 손실 값에 해당하는 가중치를 곱하여 합한 값이기 때문이다.

$$ 0.0533 = 0.9*0.0454 + 0.1*0.1241 $$

Deep model의 손실 값과 Wide & Deep Learning model의 손실 값을 동시에 반영하여, 총 손실 값을 계산하였으므로, Deep model이 Wide model과의 결합 없이도 우수한 성능을 보이는 것을 알 수 있다.
주 출력층의 Accuracy는 0.0029, 보조 출력층의 Accuracy도 0.0032로 Deep model, Wide & Deep Learning model 모두 Accuracy가 괜찮게 나왔다. 이로 인해 Deep model 자체만으로도 우수한 성능을 보이는 것을 알 수 있다.

5.1. 손실 값과 정확도를 시각화해보자.

def Drawing_Scalars(history_name):
    
    history_DF = pd.DataFrame(history_name.history)
    # 그래프의 크기와 선의 굵기를 설정해주었다.
    history_DF.plot(figsize=(12, 8), linewidth=3)

    # 교차선을 그린다.
    plt.grid(True)

    plt.legend(loc = "upper right", fontsize =15)

    plt.title("Learning Curve", fontsize=30, pad = 30)
    plt.xlabel('Epoch', fontsize = 20, loc = 'center', labelpad = 20)
    plt.ylabel('Variable', fontsize = 20, rotation = 0, loc='center', labelpad = 40)

    # 위 테두리 제거
    ax=plt.gca()
    ax.spines["right"].set_visible(False) # 오른쪽 테두리 제거
    ax.spines["top"].set_visible(False) # 위 테두리 제거
    
    plt.show()
    
    
Drawing_Scalars(history)

굉장히 많은 지표들이 추가되었지만, Early Stopping의 기준으로 사용한 val_loss를 본다면, patience가 30이었으므로, epochs 27에서 모델이 수렴하였다는 것을 알 수 있다.

[참고 자료]

이번 포스트에서는 다중 출력 모델을 Wide & Deep Learning model에서의 규제 기법으로 사용해보았다. Deep model의 결괏값에 대한 평가가 모델 전체 평가에 반영되었으므로, Deep Model의 일반화가 잘 이루어진 모델이 만들어졌다고 할 수 있다.

지금까지 Wide & Deep Learning 모델을 기반으로 다중 입력, 다중 출력 모델을 만드는 방법과 이를 통해 Wide & Deep Learning Model을 더 잘 사용할 수 있도록 해보았다.

Tensorflow-4.2. Wide & Deep Learning(2) - 다중입력모델

만년필잉크 — Wed, 24 Feb 2021 16:29:33 +0900

이전 포스트에서는 Wide & Deep Learning 모델에 대한 간단한 설명과 함수형 API를 사용해서 기초적인 Wide & Deep Learning 모델을 만들어보았다. 이때는 완전히 동일한 Input 데이터를 바라보았으나, Wide & Deep Learning 모델은 다른 Input Layer를 만들어 Wide model과 Deep model에 따로 학습시킬 수 있다.

1. 다중 입력 Wide & Deep Learning

Wide & Deep Learning model의 특징은 Wide model에 전달되는 Feature와 Deep model에 전달되는 Feature를 다르게 할 수 있다는 것이다.
즉, 입력되는 Feature에서 일부 특성은 Wide model로 나머지 특성은 Deep model로 전달할 수 있다.
(각 모델로 전달되는 특성은 중복 가능하다).
Deep model은 입력된 모든 데이터를 MLP에 있는 모든 층에 통과시키다 보니, 간단한 패턴이 연속된 변환으로 인해 왜곡될 위험이 있다.
때문에 Wide & Deep Learning model에서는 일반적으로 간단한 패턴이 있는 Column은 Wide model 쪽으로, 복잡한 패턴이 있는 Column은 Deep model 쪽으로 보낸다.
간단한 패턴이 있어 Wide model로 보낸 Column 역시 Deep model에서 숨겨진 패턴을 찾는데 도움이 될 수 있으므로, Wide model로 Input 될 데이터의 일부 혹은 전체를 Deep model에 같이 넣기도 한다.
이를 도식화해보면 다음과 같다.

위 모델을 보면 Input Layer가 2개 존재하는 것을 볼 수 있는데, 이처럼 한 번에 2개 이상의 Input이 존재하여 동시에 여러 입력을 하는 것을 다중 입력 모델이라 한다.
다중 입력 모델은 Keras의 함수형 API를 사용하면 쉽게 구현할 수 있다.

2. 데이터의 각 변수별 상세 정보 파악

이전 포스팅에서 해당 모델을 Input Layer 1개로 넣었을 때, 이미 Accuracy 0.0034, Loss 0.0242로 꽤 괜찮은 결과가 나왔었다. 굳이 데이터를 나눠서 넣을 필요는 없으나, Keras API를 이용해서 다중 입력하는 방법을 학습하기 위해, 데이터 셋을 쪼개 보도록 하겠다.
해당 포스트의 참고 논문(Heng-Tze Cheng et al.(2016))에서 예시로 든 단순한 패턴은 "설치한 앱"과 "열람한 앱"을 Cross-product transformation으로 생성한 희소 특징(Sparse feature)이다.
그러나, 해당 데이터셋에는 그 대상이 될 수 있는 범주형 데이터가 따로 없으므로, 데이터 패턴을 보는 가장 기초적인 방법인 히스토그램과 독립변수와 종속변수 간의 산점도(상관관계)를 만들어, 패턴이 아주 단순한 경우는 Wide model로, 그렇지 않은 경우는 Deep model로 넣어보겠다.

# Import Module
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import callbacks
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.layers import (Input, Dense, Concatenate, concatenate)

2.1. 데이터 셋 정보 보기

sklearn에서 기본으로 제공하는 데이터에서는 아주 쉽게 메타 정보를 볼 수 있다.

>>> Rawdict = fetch_california_housing()
>>> print(Rawdict.DESCR)
.. _california_housing_dataset:

California Housing dataset
--------------------------

**Data Set Characteristics:**

    :Number of Instances: 20640

    :Number of Attributes: 8 numeric, predictive attributes and the target

    :Attribute Information:
        - MedInc        median income in block
        - HouseAge      median house age in block
        - AveRooms      average number of rooms
        - AveBedrms     average number of bedrooms
        - Population    block population
        - AveOccup      average house occupancy
        - Latitude      house block latitude
        - Longitude     house block longitude

    :Missing Attribute Values: None

This dataset was obtained from the StatLib repository.
http://lib.stat.cmu.edu/datasets/

The target variable is the median house value for California districts.

This dataset was derived from the 1990 U.S. census, using one row per census
block group. A block group is the smallest geographical unit for which the U.S.
Census Bureau publishes sample data (a block group typically has a population
of 600 to 3,000 people).

It can be downloaded/loaded using the
:func:`sklearn.datasets.fetch_california_housing` function.

.. topic:: References

    - Pace, R. Kelley and Ronald Barry, Sparse Spatial Autoregressions,
      Statistics and Probability Letters, 33 (1997) 291-297

캘리포니아 주택 데이터 셋의 각 Row인 객체는 블록이다.
MedInc: 소득의 중앙값
HouseAge: 건물 연령 중앙값
AveRooms: 평균 객실 수
AveBedrms: 평균 침실 수
Population: 인구수
AveOccup: 평균 주택 점유율
Latitude: 위도
Longitude: 경도
종속변수(Target): MedHouseVal: 캘리포니아 지역의 주택 가격 중앙값

2.1. 변수별 히스토그램 보기

# 독립변수의 히스토그램 그리기
CaliFornia_DF = pd.DataFrame(Rawdict.data, columns=Rawdict.feature_names)
CaliFornia_DF.hist(figsize=(12,8), linewidth=3)
plt.show()

# 종속변수 히스토그램 그리기
plt.hist(Rawdict.target)
plt.show()

2.2 변수별 종속변수와의 산점도

fig, axes = plt.subplots(nrows=4, ncols=2, figsize = (12, 20))
ax = axes.ravel()

xlabels = Rawdict.feature_names
plt.suptitle("Predict Variable & MedHouseVal Scatter", y=0.93, fontsize=25)

for i in range(Rawdict.data.shape[1]):

    X = Rawdict.data[:,i]
    Y = Rawdict.target

    ax[i].scatter(X, Y, alpha = 0.025)
    ax[i].set_title(xlabels[i], fontsize=15, fontweight ="bold")

Row가 20,640으로 단순하게 산점도로 그리기엔 그 양이 너무 많아, alpha를 0.025로 주어, 데이터가 동일한 위치에 많이 존재하지 않는다면 연하게, 많이 겹칠수록 진하게 그려지도록 설정하였다.
각 변수별 히스토그램과 독립변수 & 종속변수의 산점도를 볼 때, 단순한 패턴을 갖는 것은 AveRooms, AveBedrms, Population, AveOccup로 이들은 히스토그램에서도 데이터가 한쪽에 지나치게 모여있기 때문에 딱히 패턴이 존재하지 않는다. 그러므로, 이들을 Wide model에 넣겠다.
MedInc은 그 정도가 강하다고 할 수 있는 수준은 아니지만, 위 데이터 중 가장 뚜렷한 경향성을 가지고 있다. 이를 단순한 패턴으로 인식할지도 모르니, Wide model과 Deep model 양쪽에 넣어보자.

3. 데이터셋 쪼개기

입력층이 2개이므로, Train dataset, Validation dataset, Test dataset 모두 2개로 쪼개져야 한다.
출력층은 1개이므로, Label은 쪼개지 않아도 된다.

# 데이터를 쪼개기 좋게 변수의 순서를 바꾸자
CaliFornia_DF = CaliFornia_DF[["HouseAge", "Latitude", "Longitude", "MedInc",
                               "AveRooms", "AveBedrms", "Population", "AveOccup"]]

# train, validation, test set으로 쪼갠다.
X_train_all, X_test, y_train_all, y_test = train_test_split(CaliFornia_DF.values, Rawdict.target, test_size = 0.3)
X_train, X_valid, y_train, y_valid = train_test_split(X_train_all, y_train_all, test_size = 0.2)

# 정규화시킨다.
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_valid = scaler.transform(X_valid)
X_test = scaler.transform(X_test)

# 데이터 셋을 input layer의 수만큼 쪼갠다.
X_train_A, X_train_B = X_train[:, :4], X_train[:,3:]
X_valid_A, X_valid_B = X_valid[:, :4], X_valid[:,3:]
X_test_A, X_test_B = X_test[:, :4], X_test[:,3:]

>>> X_train_A.shape
(11558, 4)

>>> X_train_B.shape
(11558, 5)

4. 모델 생성하기

input_A = Input(shape=[4], name = "deep_input")
input_B = Input(shape=[5], name = "wide_input")
hidden1 = Dense(30, activation="relu", name = "hidden1")(input_A)
hidden2 = Dense(30, activation="relu", name = "hidden2")(hidden1)
concat = concatenate([input_B, hidden2], name = "concat")
output = Dense(1, name="output")(concat)
model = keras.Model(inputs=[input_A, input_B], outputs=[output])

다중 입력 모델 생성 시, 주의사항은 층을 연결하는 부분인 concatenate layer다.
이전 포스트에서는 Concatenate layer를 사용하였고, 이번 포스트에선 맨 앞이 소문자인 concatenate layer를 사용하였는데, 둘 사이의 차이는 inputs(At least 2)라는 파라미터 여부다.
참고 1: tf.keras.layers.concatenate 공식 API 문서
참고 2: tf.keras.layers.Concatenate 공식 API 문서

>>> model.summary()

Model: "model"
__________________________________________________________________________________________________
Layer (type)                    Output Shape         Param #     Connected to                     
==================================================================================================
deep_input (InputLayer)         [(None, 4)]          0                                            
__________________________________________________________________________________________________
hidden1 (Dense)                 (None, 30)           150         deep_input[0][0]                 
__________________________________________________________________________________________________
wide_input (InputLayer)         [(None, 5)]          0                                            
__________________________________________________________________________________________________
hidden2 (Dense)                 (None, 30)           930         hidden1[0][0]                    
__________________________________________________________________________________________________
concat (Concatenate)            (None, 35)           0           wide_input[0][0]                 
                                                                 hidden2[0][0]                    
__________________________________________________________________________________________________
output (Dense)                  (None, 1)            36          concat[0][0]                     
==================================================================================================
Total params: 1,116
Trainable params: 1,116
Non-trainable params: 0
__________________________________________________________________________________________________

5. 모델 학습 및 평가하기

# 모델 컴파일
model.compile(optimizer=Adam(learning_rate=0.005),
              loss = "msle",
              metrics=["accuracy"])

early_stop = keras.callbacks.EarlyStopping(monitor='val_loss', patience=30, restore_best_weights=True)

# 학습
history = model.fit((X_train_A, X_train_B), y_train,epochs=300,
                    validation_data=((X_valid_A, X_valid_B), y_valid),callbacks=[early_stop])

Epoch 1/300
362/362 [==============================] - 2s 5ms/step - loss: 0.1601 - accuracy: 0.0015 - val_loss: 0.0413 - val_accuracy: 0.0028
Epoch 2/300
362/362 [==============================] - 1s 1ms/step - loss: 0.0390 - accuracy: 0.0018 - val_loss: 0.0376 - val_accuracy: 0.0028
Epoch 3/300
362/362 [==============================] - 0s 1ms/step - loss: 0.0367 - accuracy: 0.0017 - val_loss: 0.0364 - val_accuracy: 0.0028
Epoch 4/300
362/362 [==============================] - 0s 1ms/step - loss: 0.0342 - accuracy: 0.0022 - val_loss: 0.0354 - val_accuracy: 0.0028

...

Epoch 277/300
362/362 [==============================] - 1s 1ms/step - loss: 0.0256 - accuracy: 0.0029 - val_loss: 0.0291 - val_accuracy: 0.0028
Epoch 278/300
362/362 [==============================] - 1s 1ms/step - loss: 0.0247 - accuracy: 0.0020 - val_loss: 0.0290 - val_accuracy: 0.0028
Epoch 279/300
362/362 [==============================] - 0s 1ms/step - loss: 0.0258 - accuracy: 0.0027 - val_loss: 0.0295 - val_accuracy: 0.0028
Epoch 280/300
362/362 [==============================] - 0s 1ms/step - loss: 0.0256 - accuracy: 0.0019 - val_loss: 0.0288 - val_accuracy: 0.0028

>>> model.evaluate((X_test_A, X_test_B), y_test)
194/194 [==============================] - 0s 753us/step - loss: 0.0300 - accuracy: 0.0040
[0.02998056262731552, 0.004037467762827873]

def Drawing_Scalars(history_name):
    
    history_DF = pd.DataFrame(history_name.history)
    # 그래프의 크기와 선의 굵기를 설정해주었다.
    history_DF.plot(figsize=(12, 8), linewidth=3)

    # 교차선을 그린다.
    plt.grid(True)

    plt.legend(loc = "upper right", fontsize =15)

    plt.title("Learning Curve", fontsize=30, pad = 30)
    plt.xlabel('Epoch', fontsize = 20, loc = 'center', labelpad = 20)
    plt.ylabel('Variable', fontsize = 20, rotation = 0, loc='center', labelpad = 40)

    # 위 테두리 제거
    ax=plt.gca()
    ax.spines["right"].set_visible(False) # 오른쪽 테두리 제거
    ax.spines["top"].set_visible(False) # 위 테두리 제거
    
    plt.show()
    
    
Drawing_Scalars(history)

이전 포스트에서는 모든 데이터 셋을 Wide model과 Deep model에 넣었을 때는 Accuracy: 0.0034, Loss: 0.0242, epochs: 63에서 학습이 끝났으나, 이번 방법으로는 Accuracy: 0.0040, Loss: 0.0300, epochs: 280으로 기대에 미치는 성능이 나오진 않았다.
학습에 대한 평가는 큰 차이가 없으나, 도리어 epochs가 63에서 280으로 학습 시간이 크게 늘어, 성능이 도리어 크게 떨어진 모습을 보여주었다.

6. 위 문제를 해결해보자.

조기종료가 된 epochs가 63에서 280으로 증가했다는 소리는 주어진 데이터 셋이 이전보다 적합하지 않아, 학습하는데 시간이 오래 걸렸다는 소리다.
그렇다면, 위에서 보았던 독립변수의 데이터 분포(히스토그램)와 독립변수와 종속변수의 상관관계(산점도)로 데이터 패턴의 단순한 정도를 본 방법이 틀린 것일까?
앞서 우리가 학습하였던, "Tensorflow-4.0. 다층 퍼셉트론을 이용한 회귀모형 만들기"에서 회귀모형(Regression model)은 독립변수와 종속변수 간에 어떠한 경향성이 있다는 전제하에 독립변수가 변할 때, 종속변수가 변하고 이를 가장 잘 나타내는 계수를 찾는 것이 목적이라고 했다.
딥러닝 역시 회귀모형의 원리와 매우 유사하게 돌아가므로, 이번에는 독립변수와 종속변수의 산점도(상관관계)에서 어떠한 경향성도 갖지 않는 "HouseAge", "AveRooms", "AveBedrms", "Population", "AveOccup", "Latitude", "Longitude" 모두를 Wide model에 넣고, 약한 선형 관계를 보이는 "MedInc"만 Deep model에 넣어보도록 하겠다.

# Dataset 생성
# 데이터를 쪼개기 좋게 변수의 순서를 바꾸자
CaliFornia_DF = CaliFornia_DF[["HouseAge", "Population", "Latitude", "Longitude", "MedInc",
                               "AveRooms", "AveBedrms", "AveOccup"]]

# train, validation, test set으로 쪼갠다.
X_train_all, X_test, y_train_all, y_test = train_test_split(CaliFornia_DF.values, Rawdict.target, test_size = 0.3)
X_train, X_valid, y_train, y_valid = train_test_split(X_train_all, y_train_all, test_size = 0.2)

# 정규화시킨다.
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_valid = scaler.transform(X_valid)
X_test = scaler.transform(X_test)

# 데이터 셋을 input layer의 수만큼 쪼갠다.
X_train_A, X_train_B = X_train[:, :1], X_train[:,1:]
X_valid_A, X_valid_B = X_valid[:, :1], X_valid[:,1:]
X_test_A, X_test_B = X_test[:, :1], X_test[:,1:]

# Model 
input_A = Input(shape=[1], name = "deep_input")
input_B = Input(shape=[7], name = "wide_input")
hidden1 = Dense(30, activation="relu", name = "hidden1")(input_A)
hidden2 = Dense(30, activation="relu", name = "hidden2")(hidden1)
concat = concatenate([input_B, hidden2], name = "concat")
output = Dense(1, name="output")(concat)
model = keras.Model(inputs=[input_A, input_B], outputs=[output])


# 모델 컴파일
model.compile(optimizer=Adam(learning_rate=0.005),
              loss = "msle",
              metrics=["accuracy"])

early_stop = keras.callbacks.EarlyStopping(monitor='val_loss', patience=30, restore_best_weights=True)

# 학습
history = model.fit((X_train_A, X_train_B), y_train,epochs=300,
                    validation_data=((X_valid_A, X_valid_B), y_valid),callbacks=[early_stop])

Epoch 1/300
362/362 [==============================] - 2s 5ms/step - loss: 0.2047 - accuracy: 0.0032 - val_loss: 0.0548 - val_accuracy: 0.0014
Epoch 2/300
362/362 [==============================] - 1s 1ms/step - loss: 0.0520 - accuracy: 0.0031 - val_loss: 0.0470 - val_accuracy: 0.0014
Epoch 3/300
362/362 [==============================] - 1s 2ms/step - loss: 0.0477 - accuracy: 0.0036 - val_loss: 0.0451 - val_accuracy: 0.0014
Epoch 4/300
362/362 [==============================] - 1s 2ms/step - loss: 0.0439 - accuracy: 0.0041 - val_loss: 0.0443 - val_accuracy: 0.0014

...

Epoch 46/300
362/362 [==============================] - 0s 1ms/step - loss: 0.0438 - accuracy: 0.0019 - val_loss: 0.0438 - val_accuracy: 0.0014
Epoch 47/300
362/362 [==============================] - 0s 1ms/step - loss: 0.0446 - accuracy: 0.0036 - val_loss: 0.0439 - val_accuracy: 0.0014
Epoch 48/300
362/362 [==============================] - 0s 1ms/step - loss: 0.0446 - accuracy: 0.0033 - val_loss: 0.0444 - val_accuracy: 0.0014
Epoch 49/300
362/362 [==============================] - 0s 1ms/step - loss: 0.0430 - accuracy: 0.0029 - val_loss: 0.0440 - val_accuracy: 0.0014

>>> model.evaluate((X_test_A, X_test_B), y_test)
194/194 [==============================] - 0s 966us/step - loss: 0.0468 - accuracy: 0.0024
[0.04679189994931221, 0.002422480611130595]

>>> Drawing_Scalars(history)

Deep model로는 1개의 변수만 집어넣었고, Wide model로 7개 변수를 넣었더니, Accuracy: 0.0024, Loss: 0.0468, epochs: 49(EarlyStopping의 patience인자가 30이므로, 실제 수렴은 epoch 19에서 한 것을 알 수 있다)로 수렴하였다.
모든 변수를 Deep model과 Wide model로 보내는 경우, Accuracy: 0.0034, Loss: 0.0242, epochs: 63으로, 정확도가 미미한 수준으로 더 좋아졌고, 수렴 속도가 보다 빨라졌으나, 큰 차이가 있진 않다.
Deep Learning은 아주 많은 양의 데이터가 있을 때, 그 안에 우리가 인식하지 못하는 패턴을 찾아내는 것이므로, 위와 같은 밀집 특징(Dense Feature)에 대해서는 모든 데이터를 넣는 것을 추천한다.
희소 특징(Sparse Feature)은 Deep model을 통과하며, 학습이 제대로 이루어지지 않을 수 있으므로, Wide model에는 희소 특징만 넣도록 하자.

7. 참고 - 일반적인 다중 입력 모델의 사용 예

위 그림처럼 다중 입력은, 전혀 다른 데이터 셋 들로부터 하나의 결과를 도출해낼 수도 있다.
예를 들어, 물건 판매 웹사이트 사용자들에 대해 패턴을 뽑고자 한다면, 사용자들의 정보는 Dense 모델로, 사용자의 제품 후기는 RNN 모델로, 사용자의 관심 있는 제품 사진들을 CNN 모델로 학습시키고 이를 하나로 합쳐 하나의 결괏값을 뽑아낼 수도 있다.

[참고 자료]

arxiv.org/abs/1606.07792

Wide & Deep Learning for Recommender Systems

Generalized linear models with nonlinear feature transformations are widely used for large-scale regression and classification problems with sparse inputs. Memorization of feature interactions through a wide set of cross-product feature transformations are

arxiv.org

ai.googleblog.com/2016/06/wide-deep-learning-better-together-with.html

Wide & Deep Learning: Better Together with TensorFlow

Posted by Heng-Tze Cheng, Senior Software Engineer, Google Research The human brain is a sophisticated learning machine, forming rules by me...

ai.googleblog.com

지금까지 Wide & Deep Learning model을 Input Layer를 2개로 하여 다중 입력 모델로 만들어보았다. Keras API로 모델을 만드는 경우, 위처럼 쉬운 방법으로 다중 입력, 다중 출력 모델을 만들 수 있으므로, Keras로 모델을 만들 땐, 가능한 API로 만들도록 하자.

지금까지 Wide & Deep Learning model의 개념을 어느 정도 알아보았으니, 다음 포스트에서는 좀 더 가볍게 해당 모델로 다중 입력, 다중 출력 모델을 만들어보도록 하겠다.

Pandas-데이터 프레임 컬럼명 가지고 놀기

만년필잉크 — Wed, 24 Feb 2021 00:29:44 +0900

DataFrame을 가지고 노려면, 기본적으로 Index와 Column 그리고 내가 원하는 값을 가지고 오는 법을 알아야 한다. 이전 포스트에서 Index를 가지고 노는 법에 대해 알아보았으니, 이번 포스트에서는 Column을 가지고 노는 방법에 대해 알아보도록 하겠다.

데이터 프레임과 칼럼(Column)

이전 포스트에서 알아보았던, Index는 내가 원하는 Row(행, 레코드, 튜플)를 가지고 놀 수 있는 방법이었고, 이번에 학습할 Column은 열(변수, 속성, 필드)을 가지고 놀 수 있는 방법이다.

DataFrame은 각 Column마다 담겨 있는 데이터의 양은 같으나, 담을 수 있는 데이터가 다르므로, 칼럼을 잘 가지고 놀 수 있어야만, DataFrame을 조작하기 쉬워진다.

1. 데이터 프레임의 기본 칼럼

이전 "Pandas-데이터프레임 만들기"에서는 칼럼의 이름을 다 지정해줬었지만, 만약 데이터 프레임의 칼럼을 지정해주지 않는다면 어떻게 될까?

# Import Module
import pandas as pd
import numpy as np

# 기본 데이터 만들기
>>> np.random.seed(1234)
>>> matrix = np.random.randint(10, 100, size = (5,4))
>>> matrix
array([[57, 93, 48, 63],
       [86, 34, 25, 59],
       [33, 36, 40, 53],
       [40, 36, 68, 79],
       [90, 83, 57, 60]])

numpy의 array를 이용해서 단순한 행렬을 만들어보았다.
np.random.seed(): seed를 정해서 고정된 난수가 출력되도록 한다. 자신이 원하는 아무 숫자를 안에 넣고 실행 시, 그 seed에 대해 출력되는 난수는 동일한 값만 나오게 된다.
np.random.randint(low, high, size, dtype): low에서 high까지 자신이 지정한 size(shape)로 랜덤한 값이 출력된다.

>>> DF = pd.DataFrame(matrix)
>>> DF

칼럼을 지정하지 않고 DataFrame을 만들면 Index와 마찬가지로 0부터 시작하는 값이 매겨진다.

1.1. RangeIndex

이렇게 0부터 시작하는 index가 매겨지는 것을 RangeIndex라고 하는데, Python의 기본 함수인 range랑 그 기능이 거의 비슷하다.

# RangeIndex 생성
>>> pd.RangeIndex(10)
RangeIndex(start=0, stop=10, step=1)

# RangeIndex의 값을 list로 바꿔주자.
>>> list(pd.RangeIndex(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# range와 비교
>>> range(10)
range(0, 10)

>>> list(range(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

RangeIndex 역시 range처럼 특정 간격을 가지고 Data를 생성할 수 있으며, 객체의 값을 활성화해주지 않으면, 그 내용물이 튀어나오지 않는다.

# 시작, 끝, 간격을 조정해보자.
>>> pd.RangeIndex(start=10, stop = 30, step=2)
RangeIndex(start=10, stop=30, step=2)

>>> list(pd.RangeIndex(start=10, stop = 30, step=2))
[10, 12, 14, 16, 18, 20, 22, 24, 26, 28]

# 위 기능은 range와 같다.
>>> range(10, 30, 2)
range(10, 30, 2)

>>> list(range(10, 30, 2))
[10, 12, 14, 16, 18, 20, 22, 24, 26, 28]

index는 많은 양의 Data를 담는 DataFrame 특성 상, 그 숫자가 매우 커질 수 있기 때문에 range와 마찬가지로 이를 바로 출력하지 않고, 호출 시 출력한다.
RangeIndex는 크게 신경 쓸 것은 아니지만, DataFrame을 조작하다가 칼럼의 이름을 지정할 수 없는 경우가 있다. 이럴 때는 RangeIndex가 출력되므로, 이를 조작할 수는 있어야 한다.

2. Column의 이름 바꾸기

DataFrame의 Column이름을 바꾸는 방법은 크게 두 가지가 있다.

한 번에 다 바꾸기
내가 원하는 Column의 이름만 바꾸기

2.1. Column의 이름 한 번에 다 바꾸기

>>> DF.columns = ["C1", "C2", "C3", "C4"]
>>> DF

>>> DF.columns
Index(['C1', 'C2', 'C3', 'C4'], dtype='object')

>>> type(DF.columns)
pandas.core.indexes.base.Index

DataFrame.columns: DataFrame의 Column을 조작하는 가장 기본적인 방법으로 DataFrame의 Column을 pandas index라는 type으로 가지고 온다. array와 유사하므로, array라고 생각해도 큰 문제는 없다.

2.2. 특정 Column의 이름만 바꾸기

칼럼 C1은 math로 C3는 English로 바꿔보자.

>>> DF.rename(columns={"C1":"math", "C3":"English"}, inplace = True)
>>> DF

DataFrame.rename(columns={"old":"new"}, inplace=False): DataFrame의 old 컬럼을 new 컬럼으로 이름을 바꾼다.
이번에는 C2를 math로 바꿔보자.

>>> DF.rename(columns={"C2":"math"}, inplace = True)
>>> DF

DataFrame의 컬럼 역시 Index처럼 이름이 중복된다.
뒤에서 다시 다루겠지만, Index처럼 같은 이름의 컬럼 출력 시, 동일한 컬럼이 생성된다.

>>> DF.math

3. Column이름들을 꾸며주기

DataFrame의 컬럼의 이름은 위에서 봤듯이 중복될 수도 있고, DataFrame.columns라는 함수를 통해, array를 다루듯 조작할 수도 있다.
또한, Column의 이름들에 특정한 패턴으로 한 번에 조작을 해줄 수도 있다.
해당 예시를 보기 전에 조작이 쉽도록, 변수들의 이름을 전부 바꿔주었다.

DF.columns = ["mid math", "mid English", "fin math", "fin English"]

3.1. 컬럼명의 특정 문자 바꿔주기

>>> DF.columns = DF.columns.str.replace(" ", "_")
>>> DF

DataFrame.columns.str.replace(pat, repl): 판다스의 str모듈은 문자열 데이터를 다루는데 특화된 함수의 모음으로, 보통 칼럼 각각에 적용하지만, 칼럼의 이름에도 적용 가능하다.
컬럼을 다룰 때, 공백이 있는 경우 조작이 조금 불편해지므로, 가능한 공백은 언더바("_")로 치환하도록 하자.
str 모듈은 굉장히 유용한 함수들을 모아놓은 모듈이므로, 추후 자세히 다루도록 하겠다.

3.2. 모든 컬럼명 앞에 공통 문자 붙이기

>>> DF.add_prefix("A__")

3.3. 모든 컬럼명 뒤에 공통 문자 붙이기

>>> DF.add_suffix("_Dummy")

컬럼명의 앞이나 뒤에 공통된 문자를 붙여주는 기능은 데이터 전처리 시, 더미 변수를 만들거나, One-Hot Vector 등을 만들 때, 쉽게 쓸 수 있다.
지금처럼 모든 변수들에게 특정 문자를 붙이는 것보다는, 특정 컬럼들만 선택하여, 공통 문자를 바꾸는 것이 더 효과적이다. 이는 추후 컬럼 조회를 학습하면서 공부하도록 하겠다.

지금까지 컬럼명을 가지고 노는 방법에 대해 학습해 보았다. 다음 포스트에서는 컬럼명을 가지고 놀 수 있는 다른 방법에 대해 학습해보도록 하겠다.

Tensorflow-4.1. Wide & Deep Learning(1) - 함수형 API 사용하기

만년필잉크 — Tue, 23 Feb 2021 19:22:54 +0900

이전 포스트에서 다뤘던 선형 회귀 모형은 단일 입력층과 단일 출력층을 갖는 형태였다. 그러나, Keras를 사용하는 Tensorflow의 가장 큰 장점인 함수형 API모델을 사용하면, 다중 입력과 다중 출력을 갖는 모델을 만들 수 있다.

이번 포스트에서는 Keras의 장점인 함수형 API로 대규모 회귀 및 분류 모델에서 주로 사용되는 Wide & Deep Learning 모델을 만들어보자.

와이드 & 딥(Wide & Deep) 신경망

2016년 헝쯔 청(Heng-Tze Cheng et al.)의 논문에 소개된 신경망이다.
Heng-Tze Cheng et al., "Wide & Deep Learning for Recommender Systems." Proceedings of the First Workshop on Deep Learning for Recommender Systems (2016): 7 - 10. http://homl.info/widedeep

인간은 일반화와 암기를 통해 학습을 한다.

일반화(Deep Models): 인간은 "참새는 날 수 있다.", "비둘기는 날 수 있다."를 통해 "날개를 가진 동물은 날 수 있다"라 일반화를 시킨다.
암기(Wide Models): 반면에 "펭귄은 날 수 없다.", "타조는 날 수 없다." 등과 같은 예외 사항을 암기하여, 일반화된 규칙을 더욱 세분화시킨다.

Wide & Deep Learning은 이러한 인간의 일반화와 암기를 결합하여 학습하는 점에 착안하여, 만들어진 기계 학습 방법이다.
앞서 우리가 학습해왔던 심층 신경망(Deep Network)은 대상으로부터 공통된 패턴을 찾아내어 일반화시키지만, 그 패턴을 가지고 있으나, 이에 해당하지 않는 많은 반례들이 존재한다.
(일반적으로 딥 러닝에서는 이를 감안한 데이터 셋을 준비해 학습한다.)
Wide & Deep Learning은 여기서 더 나아가 넓은 선형 모델을 공동으로 학습시켜, 일반화(Deep Learning)와 암기(Wide Linear model)의 장점을 얻는다.
Wide & Deep Learning은 추천 시스템, 검색 및 순위 문제 같은 많은 양의 범주형 특징(Categorical Feature)이 있는 데이터를 사용하는 대규모 회귀, 분류 모델에서 유용하게 사용된다.
Wide & Deep Learning은 위 그림처럼 앞서 학습했던 다층 퍼셉트론(MLP - Deep way)에 입력 데이터의 일부 또는 전체 데이터가 출력층에 바로 연결(Wide way)되는 부분이 추가된 것이다.
이로 인해, Wide & Deep Learning은 복잡한 패턴과 간단한 규칙을 모두 학습할 수 있다.
(MLP에서는 간단한 패턴이 연속된 변환으로 인해 왜곡될 수 있다.)

1. Tensorflow의 함수형 API를 사용하여 Wide & Deep Learning을 구현해보자.

sklearn에서 제공하는 캘리포니아 주택 가격 데이터 셋을 사용해보자.
sklearn에서 제공하는 기초 함수로 데이터 셋을 분리해보자.
sklearn에서 제공하는 기초 함수로 데이터 셋의 스케일 조정을 실시해보자.

Wide model과 Deep model이 같은 데이터를 바라보는 Input이 1개인 Wide & Deep Learning Model을 만들어보자.

1.1 데이터셋 준비

# import Module
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
import pandas as pd

# 캘리포니아 주택 가격 데이터 셋 확인
Rawdict = fetch_california_housing()

Cal_DF = pd.DataFrame(Rawdict.data, columns=Rawdict.feature_names)
Cal_DF

# Data의 모든 컬럼들의 data type을 확인한다.
>>> Cal_DF.dtypes
MedInc        float64
HouseAge      float64
AveRooms      float64
AveBedrms     float64
Population    float64
AveOccup      float64
Latitude      float64
Longitude     float64
dtype: object


# Data의 모든 컬럼들의 결측값 개수를 확인한다.
>>> Cal_DF.isnull().sum()
MedInc        0
HouseAge      0
AveRooms      0
AveBedrms     0
Population    0
AveOccup      0
Latitude      0
Longitude     0
dtype: int64

데이터 셋은 모두 소수(float64)로 구성되어 있다.
결측 값은 모든 칼럼에 존재하지 않는다.

1.2 데이터셋 분리

>>> X_train_all, X_test, y_train_all, y_test = train_test_split(Rawdict.data, Rawdict.target, test_size = 0.3)
>>> X_train, X_valid, y_train, y_valid = train_test_split(X_train_all, y_train_all, test_size = 0.2)
>>> print("Train set shape:", X_train.shape)
>>> print("Validation set shape:", X_valid.shape)
>>> print("Test set shape:", X_test.shape)

Train set shape: (11558, 8)
Validation set shape: (2890, 8)
Test set shape: (6192, 8)

sklearn.model_selection.train_test_split(array, test_size, shuffle): dataset을 쉽게 나눌 수 있는 sklearn 함수로 일반적으로 dataset, label 이 두 array를 동시에 넣고 사용한다.
test_size: test Dataset의 비율(float)이나 총 숫자(int)로 나눠준다.
shuffle: Dataset을 쪼개기 전에 섞을지 여부를 정해준다.

1.3. 데이터셋 스케일 조정

# 스케일 조정
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_valid = scaler.transform(X_valid)
X_test = scaler.transform(X_test)

sklearn.preprocessing.StandardScaler(): 표준 정규분포로 스케일링할 준비를 한다.
sklearn.prepocessing은 이밖에도 MinMaxScaler, MaxAbsScaler, RobustScaler 등 다양한 스케일링 기법을 제공한다.

MinMaxScaler(): 최소-최대 스케일 변환, 이상치 영향이 크다.
MaxAbsScaler(): 최대 절대 값을 1로 변환(-1.0 ~ 1.0으로 만드나, 전부 양수인 경우, MinMaxscaler와 동일하다), 이상치 영향이 크다.
StandardScaler(): 표준 정규분포 스케일 변환
RobustScaler(): 중앙값과 사분위 범위(Interquartile range)를 사용하며, StandardScaler보다 표준화 후 동일한 값을 더 넓게 분포 시킴

StandardScaler().fit_transform(): 데이터셋을 표준 정규분포화 한다. 단, fit_transform에 들어가는 Dataset의 평균과 표준편차를 기준으로 저장하게 된다.
StandardScaler().transform(): 데이터셋을 표준 정규분포화 한다. 표준 정규분포화하는 평균과 표준편차는 fit 된 Dataset을 따른다.
앞서 학습하였듯, 스케일링 조정의 기준은 훈련 셋(Train set)이다. 그러므로, fit_transform()에는 Train set이 들어가야 하고, transform에는 검증 셋(Validation set)이나 시험 셋(Test set)이 들어가야 한다.

2. 모델 만들기

Wide & Deep Learning 같은 순차적이지 않은 신경망을 만들기 위해선 keras의 특징인 함수형 API를 이용해서 Layer를 만들어야 한다.
이번 모델은 1개의 Input Layer와 1개의 Output Layer를 갖는 Wide-Deep Learning 모델을 만들어보겠다.

from tensorflow import keras
from tensorflow.keras.layers import (Input, Dense, Concatenate)

# Model 생성하기
input_ = Input(shape=X_train.shape[1:])
hidden1 = Dense(30, activation="relu")(input_)
hidden2 = Dense(30, activation="relu")(hidden1)
concat = Concatenate()([input_, hidden2])
output = Dense(1)(concat)
model = keras.Model(inputs=[input_], outputs=[output])

함수형 API 모델 생성 방법

Input 객체 생성: Input layer는 배치 크기를 포함하지 않는, array의 모양을 정한다. 즉, Data의 크기가 아닌, 한 Row의 Data의 모양만 반영된다. 예를 들어, shape = (32,)가 되면, 32차원의 벡터가 입력된다는 의미다.
(변수 이름에 _가 들어간 것은 파이썬에서 언더스코어(_)의 기능을 이용한 것으로, 단순하게 input함수와 충돌되지 않도록 이렇게 만든 것이다.)
은닉층 객체 생성: 기존처럼 Layer를 add로 만들어진 모델에 은닉층을 쌓는 것이 아닌, 함수로 만들어 변수에 담는다. 여기서 케라스에서 층이 연결될 방법만 선언하였고, 그 어떤 데이터 처리도 발생하지 않은 상태이다.
결합층 객체 생성: Wide-Deep Learning은 선형 모델과 딥러닝 모델을 동시에 사용하는 방법이므로, 입력될 객체인 input_과 hidden2를 연결해준다.
출력층 객체 생성: 결합층에서 전달된 내용을 출력함
모델 생성: 입력과 출력이 지정된 Keras 모델 생성

tf.keras.layers.Concatenate(): 연결층이 Tensor를 연결하는 방법은 아래와 같다.

>>> x = np.arange(1, 41, 2).reshape(2,2,5)
>>> x
array([[[ 1,  3,  5,  7,  9],
        [11, 13, 15, 17, 19]],

       [[21, 23, 25, 27, 29],
        [31, 33, 35, 37, 39]]])


>>> y = np.arange(2, 21, 2).reshape(2,1,5)
>>> y
array y:
 [[[ 2  4  6  8 10]]

 [[12 14 16 18 20]]]


>>> tf.keras.layers.Concatenate(axis=1)([x, y])
<tf.Tensor: shape=(2, 3, 5), dtype=int32, numpy=
array([[[ 1,  3,  5,  7,  9],
        [11, 13, 15, 17, 19],
        [ 2,  4,  6,  8, 10]],

       [[21, 23, 25, 27, 29],
        [31, 33, 35, 37, 39],
        [12, 14, 16, 18, 20]]])>
   
   
>>> np.concatenate((x, y), axis=1)
array([[[ 1,  3,  5,  7,  9],
        [11, 13, 15, 17, 19],
        [ 2,  4,  6,  8, 10]],

       [[21, 23, 25, 27, 29],
        [31, 33, 35, 37, 39],
        [12, 14, 16, 18, 20]]])

tf.keras.layers.Concatenate()는 np.concatenate() 함수와 동일한 역할을 하며, axis를 어떻게 잡느냐에 따라, 출력되는 Tensor의 모양을 다르게 할 수 있다.

3. 모델 학습 및 최종 코드 정리

지금까지 작성했던 코드와 이전에 사용했던 괜찮은 기능들을 합쳐 코드를 정리해보자.

# Import Module
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import callbacks
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.layers import (Input, Dense, Concatenate)

# Dataset 생성
Rawdict = fetch_california_housing()
X_train_all, X_test, y_train_all, y_test = train_test_split(Rawdict.data, Rawdict.target, test_size = 0.3)
X_train, X_valid, y_train, y_valid = train_test_split(X_train_all, y_train_all, test_size = 0.2)

# 스케일 조정
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_valid = scaler.transform(X_valid)
X_test = scaler.transform(X_test)

# 모델 생성
input_ = Input(shape=X_train.shape[1:])
hidden1 = Dense(30, activation="relu")(input_)
hidden2 = Dense(30, activation="relu")(hidden1)
concat = Concatenate()([input_, hidden2])
output = Dense(1)(concat)
model = keras.Model(inputs=[input_], outputs=[output])

# 모델 컴파일
model.compile(optimizer=Adam(learning_rate=0.005),
              loss = "msle",
              metrics=["accuracy"])

# 학습
early_stop = keras.callbacks.EarlyStopping(monitor='val_loss', patience=30, restore_best_weights=True)

history = model.fit(X_train, y_train, 
                    epochs=100,
                    batch_size=32,
                    validation_data=(X_valid, y_valid),
                    callbacks=[early_stop])

Epoch 1/100
362/362 [==============================] - 3s 5ms/step - loss: 0.1195 - accuracy: 0.0031 - val_loss: 0.0360 - val_accuracy: 0.0014
Epoch 2/100
362/362 [==============================] - 1s 1ms/step - loss: 0.0340 - accuracy: 0.0031 - val_loss: 0.0342 - val_accuracy: 0.0014
Epoch 3/100
362/362 [==============================] - 1s 1ms/step - loss: 0.0329 - accuracy: 0.0027 - val_loss: 0.0326 - val_accuracy: 0.0014
Epoch 4/100
362/362 [==============================] - 0s 1ms/step - loss: 0.0336 - accuracy: 0.0034 - val_loss: 0.0321 - val_accuracy: 0.0014

...

Epoch 60/100
362/362 [==============================] - 0s 1ms/step - loss: 0.0219 - accuracy: 0.0045 - val_loss: 0.0263 - val_accuracy: 0.0014
Epoch 61/100
362/362 [==============================] - 0s 1ms/step - loss: 0.0221 - accuracy: 0.0033 - val_loss: 0.0285 - val_accuracy: 0.0014
Epoch 62/100
362/362 [==============================] - 0s 1ms/step - loss: 0.0244 - accuracy: 0.0033 - val_loss: 0.0267 - val_accuracy: 0.0010
Epoch 63/100
362/362 [==============================] - 0s 1ms/step - loss: 0.0227 - accuracy: 0.0032 - val_loss: 0.0264 - val_accuracy: 0.0010

>>> model.evaluate(X_test, y_test)
194/194 [==============================] - 0s 750us/step - loss: 0.0242 - accuracy: 0.0034
[0.02424260601401329, 0.0033914728555828333]

def Drawing_Scalars(history_name):
    
    history_DF = pd.DataFrame(history_name.history)
    # 그래프의 크기와 선의 굵기를 설정해주었다.
    history_DF.plot(figsize=(12, 8), linewidth=3)

    # 교차선을 그린다.
    plt.grid(True)

    plt.legend(loc = "upper right", fontsize =15)

    plt.title("Learning Curve", fontsize=30, pad = 30)
    plt.xlabel('Epoch', fontsize = 20, loc = 'center', labelpad = 20)
    plt.ylabel('Variable', fontsize = 20, rotation = 0, loc='center', labelpad = 40)

    # 위 테두리 제거
    ax=plt.gca()
    ax.spines["right"].set_visible(False) # 오른쪽 테두리 제거
    ax.spines["top"].set_visible(False) # 위 테두리 제거
    
    plt.show()
    
    
Drawing_Scalars(history)

위 모델의 학습 결과를 보면, accuracy는 빠르게 0에 가깝게 떨어진 것을 볼 수 있다.
model.evaluate()에서 test set을 대상으로 모델을 평가한 결과 Accuracy는 0.0034가 나왔다.
분류 모델을 사용할 때와, 위와 같은 연속형 데이터에 대한 회귀 모델은 Accuracy의 기준이 다르므로, 위 경우엔 Accuracy, loss 모두 0에 가깝게 나오는 것이 좋다.
참고자료: "머신러닝-5.2. 손실함수(3)-평균제곱근오차(RMSE)"
loss는 model.evaluate()에서 0.0242로 최종 손실 값이 0에 가깝게는 나왔으나, 기존 모델보다는 크게 나왔다. 그러나, 손실 값은 상대적인 기준이므로, 0에 가까울수록 좋은 것이긴 하나, 단순하게 나쁘게 봐서는 안된다.

[참고 자료]

arxiv.org/abs/1606.07792

Wide & Deep Learning for Recommender Systems

arxiv.org

ai.googleblog.com/2016/06/wide-deep-learning-better-together-with.html

Wide & Deep Learning: Better Together with TensorFlow

Posted by Heng-Tze Cheng, Senior Software Engineer, Google Research The human brain is a sophisticated learning machine, forming rules by me...

ai.googleblog.com

지금까지 Input layer가 1개인 Wide & Deep Learning model을 만들어보았다. 그러나, Wide & Deep Learning model의 가장 큰 특징은 Input 되는 층이 지금까지처럼 1개의 동일한 Layer가 아니라, 암기(Linear Learning)를 위한 데이터와 일반화(Deep Learning)를 위한 데이터가 Input 될 층을 따로 구성될 수 있다는 것이다.

다음 포스트에서는 Input layer가 2개인 경우에 대하여 Wide & Deep Learning model을 만들어보면서, Wide & Deep Learning model에 대해 더 알아보도록 하자.

Tensorflow-4.0. 다층 퍼셉트론을 이용한 회귀모형 만들기

만년필잉크 — Tue, 23 Feb 2021 19:22:30 +0900

꽤 많은 블로그나 책에서 머신러닝을 다룰 때, 회귀모형, 로지스틱 회귀모형을 꼭 다루고 넘어가는데, 이번 포스트에서는 우리가 통계학에서 흔히 다루는 회귀모형과 딥러닝이 대체 어떤 관계길래 다들 회귀모형부터 다루는지에 대해 알아보고자 한다.

사실 우리는 이미 이전 포스트에서 회귀모형, 로지스틱 회귀모형을 만들어보았으며, 만약, 통계에 조금 익숙한 사람이라면, 분석된 결과나 그 과정을 보면서, 이게 회귀분석 아닌가? 하는 생각이 들었을지도 모른다(물론, Odd Ratio, $R^2$과 같은 익숙한 지표들이 그대로 등장하진 않았지만, 그것과 유사한 역할을 하는 지표를 이미 봤을 것이다).

회귀모형(Regression Model)

통계에 익숙한 사람이라면, 통계의 꽃인 회귀 모형에 대해 이미 잘 알고 있을 것이다. 우리가 기존에 학습했던, "Tensorflow-1.4. 기초(5)-하이퍼 파라미터 튜닝", "Tensorflow-2.4. 타이타닉 생종자 분류 모델(3)-하이퍼 파라미터 튜닝"에서 만들었던 모델이 바로 회귀모형이다.

1. 통계학과 딥러닝의 회귀모형

회귀모형에 대해 잘 모를 수 있으므로, 통계학에서의 회귀모형에 대해 아주 단순하게 설명해보도록 하겠다.

회귀모형은 데이터 간에 어떠한 경향성이 있다는 생각에서 시작된다.
회귀모형은 독립변수와 종속변수가 서로 인과 관계가 있다고 할 때, 독립변수가 변하면 종속변수가 변하게 된다.

회귀식: $ y = b_1x_1 + b_2x_2 + b_3x_3 + c $

회귀모형은 데이터에 가장 적합한 계수($b_1, b_2, b_3, c$)를 구하는 것이 목적이다.
회귀모형은 그 적합한 계수를 찾는 방법으로 평균 제곱 오차(MSE)를 사용한다.
(실제값과 예측값의 편차 제곱의 평균, 참고: "딥러닝-5.1. 손실함수(2)-평균제곱오차(MSE)")

회귀식은 퍼셉트론 공식과 아주 똑 닮았다("머신러닝-2.1. 퍼셉트론(2)-논리회로"). 그리고 딥러닝을 통해 우리는 각각의 파라미터(가중치와 편향)를 찾아낼 수 있다.

독립변수(Dataset이자 상수)의 변화에 따른 종속변수(Label, 상수)의 변화를 가장 잘 설명할 수 있는 계수(weight과 bias)를 찾아내는 것은 회귀분석이며, 이 점이 다층 퍼셉트론을 이용하여, 데이터 자체를 가장 잘 설명할 수 있는 파라미터를 찾아내는 딥러닝(Deep Learning)과 같다고 할 수 있다.

1.1. 이 밖의 회귀모형의 특징

회귀모형은 기본적으로 연속형 데이터를 기반으로 한다.
독립변수, 종속변수가 모두 연속형 데이터여야 한다.
연속형 데이터가 아닌 독립변수 존재 시, 이를 가변수(Dummy variable)로 만든다.

2. 데이터셋

이번 학습에서는 R을 사용해본 사람이라면 아주 친숙한 데이터 중 하나인 자동차 연비 데이터(MPG)를 이용해서 회귀모형을 만들어보도록 하겠다.

# Import Module
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
from sklearn.model_selection import train_test_split

import pandas as pd
import numpy as np

>>> dataset_path = keras.utils.get_file("auto-mpg.data", "http://archive.ics.uci.edu/ml/machine-learning-databases/auto-mpg/auto-mpg.data")
Downloading data from http://archive.ics.uci.edu/ml/machine-learning-databases/auto-mpg/auto-mpg.data
32768/30286 [================================] - 0s 4us/step

tf.keras.utils.get_file()을 사용하면, 각종 데이터셋을 쉽게 가져올 수 있다.
데이터셋을 가지고 오는 곳은 UCI 머신러닝 저장소로 인터넷이 안 되는 환경이라면 데이터를 다운로드할 수 없으니, 조심하자.
sklearn처럼 데이터셋을 Dictionary에 깔끔하게 저장하여, 데이터를 다운로드하면, 모든 데이터에 대한 정보가 있는 상태가 아니므로, 데이터에 대해 파악하기 위해선 UCI 머신러닝 저장소에서 데이터에 대해 검색하여, 데이터 정보를 찾아봐야 한다.
해당 포스팅에서는 "Tensorflow 공식 홈페이지의 자동차 연비 예측하기: 회귀"를 참고하여 데이터셋을 준비하였다.

column_names = ['MPG','Cylinders','Displacement','Horsepower','Weight',
                'Acceleration', 'Model Year', 'Origin']
Rawdata = pd.read_csv(dataset_path, names=column_names, na_values = "?",
                      comment='\t', sep=" ", skipinitialspace=True)
Rawdata

3. 데이터 전처리

3.1. 결측 값 처리

>>> Rawdata.isna().sum()
MPG             0
Cylinders       0
Displacement    0
Horsepower      6
Weight          0
Acceleration    0
Model Year      0
Origin          0
dtype: int64

>>> print("전체 데이터에서 결측값 행의 비율:", Rawdata.isna().sum(1).sum()/len(Rawdata))
전체 데이터에서 결측값 행의 비율: 0.01507537688442211

위 결과를 보니, Horsepower에서 결측 값이 6개 발생한 것을 알 수 있다.
전체 데이터에서 결측 값 행의 비율을 보니 0.015로 매우 미미한 양이므로, 제거하도록 하자.

Rawdata.dropna(inplace = True)

3.2. 범주형 데이터의 원-핫 벡터화

칼럼 Origin은 숫자로 표시되어 있지만, 실제론 문자인 범주형 데이터이므로, 원-핫 벡터화 해주자.
(이는 회귀 모델에서의 가변수 처리와 매우 유사한 부분이라고 할 수 있다.)

# One-Hot Vector 만들기
def make_One_Hot(data_DF, column):
    
    target_column = data_DF.pop(column)

    for i in sorted(target_column.unique()):

        new_column = column + "_" + str(i)
        data_DF[new_column] = (target_column == i) * 1.0

이전 참고 포스트에서 만들었던, 원-핫 벡터 코드보다 판다스의 성격을 잘 활용하여 만든 코드다
DataFrame.pop(column): DataFrame에서 선택된 column을 말 그대로 뽑아낸다. 그로 인해 기존 DataFrame에서 해당 column은 사라지게 된다.
(target_column == i) * 1.0: Boolearn의 성질을 사용한 것으로 target_column의 원소를 갖는 위치는 True로, 원소가 없는 곳은 False가 된다. 이에 1.0을 곱하여 int로 바꿔줬다. Python은 동적 언어이므로, 1.0을 곱해주어도 int형으로 변하게 된다.

3.3. 데이터셋 분리

train set과 test set은 7:3으로 분리하도록 하겠다.
validation set은 이 단계에서 뽑지 않고, 학습 과정(fit)에서 뽑도록 하겠다.
MPG 변수는 연비를 의미하며 종속변수에 해당하므로, 이를 Label로 사용하겠다.

# Dataset 쪼개기
label = Rawdata.pop("MPG").to_numpy()
dataset = Rawdata.values
X_train, X_test, y_train, y_test = train_test_split(dataset, label, test_size = 0.3)

3.4. 특성 스케일 조정

해당 데이터 셋의 각 칼럼의 데이터는 다른 변수에서 나온 것이므로, 각각 변수별 기준으로 정규화해주어야 한다.
표준 정규 분포를 사용하여 특성 스케일 조정을 하도록 하겠다.
원-핫 벡터가 사용된 7:9까지의 열을 제외한 나머지 열에 대해 각각 특성 스케일 조정을 하겠다.

# 특성 스케일 조절
mean_point = X_train[:, :6].mean(axis=0)
std_point = X_train[:, :6].std(axis=0)

X_train[:, :6] = ((X_train[:, :6] - mean_point)/std_point)
X_test[:, :6] = ((X_test[:, :6] - mean_point)/std_point)

Numpy의 특징 중 하나인 Broadcasting 덕에 쉽게 정규화할 수 있다.

4. 모델 학습 및 평가

모델은 은닉층이 1개 있는 단층 퍼셉트론(Sigle-later Perceptron)으로 만들어보겠다.
(은닉층을 2개 이상 넣어 다층 퍼셉트론으로 만들어도 상관없다)
model은 Sequential 함수 안에 layer를 넣어주는 방법으로 만들어보겠다.
(추천하지는 않는 방법이지만 이런 방법도 있다는 것을 보여주고자 사용해보았다)
출력층의 활성화 함수는 선형(Linear)으로 설정하였다.
(activation의 Default는 linear이므로, 따로 설정하지 않아도 된다)
조기 종료(Early stop)를 콜백 함수로 주도록 하겠다.

# model 생성
model = keras.Sequential([
    keras.layers.Dense(60, activation = "relu"),
    keras.layers.Dense(1, activation = "linear")
])

# model compile 설정
opt = keras.optimizers.Adam(learning_rate=0.005)
model.compile(optimizer=opt, loss="mse", metrics = ["accuracy"])

# model 학습
early_stop = keras.callbacks.EarlyStopping(monitor='val_loss', patience=10, restore_best_weights=True)
model.fit(X_train, y_train, epochs=300, validation_split=0.2, callbacks=[early_stop])

Epoch 1/300
7/7 [==============================] - 2s 248ms/step - loss: 572.1581 - accuracy: 0.0000e+00 - val_loss: 497.8600 - val_accuracy: 0.0000e+00
Epoch 2/300
7/7 [==============================] - 0s 19ms/step - loss: 516.3237 - accuracy: 0.0000e+00 - val_loss: 443.4315 - val_accuracy: 0.0000e+00
Epoch 3/300
7/7 [==============================] - 0s 18ms/step - loss: 454.6065 - accuracy: 0.0000e+00 - val_loss: 385.6940 - val_accuracy: 0.0000e+00
Epoch 4/300
7/7 [==============================] - 0s 19ms/step - loss: 390.3198 - accuracy: 0.0000e+00 - val_loss: 321.7114 - val_accuracy: 0.0000e+00

...

Epoch 79/300
7/7 [==============================] - 0s 8ms/step - loss: 5.6932 - accuracy: 0.0000e+00 - val_loss: 7.2688 - val_accuracy: 0.0000e+00
Epoch 80/300
7/7 [==============================] - 0s 8ms/step - loss: 5.9354 - accuracy: 0.0000e+00 - val_loss: 7.3990 - val_accuracy: 0.0000e+00
Epoch 81/300
7/7 [==============================] - 0s 8ms/step - loss: 5.5025 - accuracy: 0.0000e+00 - val_loss: 7.3694 - val_accuracy: 0.0000e+00
Epoch 82/300
7/7 [==============================] - 0s 8ms/step - loss: 5.8313 - accuracy: 0.0000e+00 - val_loss: 7.2677 - val_accuracy: 0.0000e+00
<tensorflow.python.keras.callbacks.History at 0x1e00b62b1f0>

# model 평가
>>> model.evaluate(X_test, y_test)
4/4 [==============================] - 0s 2ms/step - loss: 10.2492 - accuracy: 0.0000e+00
[10.24919319152832, 0.0]

5. 정리

출력층에 활성화 함수로 기본값인 선형 함수(Linear)가 사용되었다.
활성화 함수로 선형 함수가 사용되는 경우, 단순하게 이전 층에서 출력된 값에 대하여 선형 함수의 계수 값만큼만 곱하므로, 은닉층에서의 값을 보존한 상태로 출력하게 된다.
참고: "딥러닝-3.0. 활성화함수(1)-계단함수와 선형함수"
손실 함수로 평균 제곱 오차(MSE)를 사용하였다.
참고: "딥러닝-5.1. 손실함수(2)-평균제곱오차(MSE)"
회귀모형은 주어진 데이터가 어떠한 경향성을 갖고 있다는 가정하에 변수들 사이의 경향성을 가장 잘 설명할 수 있는 계수들을 찾아내는 것이다.
우리는 딥러닝 모델을 사용해서 Feature로 독립변수들을 넣었고, Label에 종속변수를 넣었다.
우리는 딥러닝 모델을 이용해 Feature가 Label에 대한 어떠한 경향성, 즉 패턴을 갖고 있다고 보고, 그 패턴을 나타내는 파라미터(weight, bias)를 찾아냈다.
회귀분석은 일반적으로 최소제곱법(OLS)을 통해 최적의 가중치를 찾아내지만, 우리는 최적의 가중치를 경사 하강법과 역전파를 통한 학습으로 찾아내었다.
출력층의 활성화 함수를 Sigmoid 함수로 사용하여 이진 분류 하면, 로지스틱 회귀모형(Logistic Regression model)이 된다.

지금까지 딥러닝(Deep Learning)을 사용하여, 회귀모델을 만들어보았다. 앞서 "딥러닝을 통해 이런 것도 되는구나!"하고 넘어갔던 부분들이 사실은 회귀모델이고, 회귀모델의 아이디어와 딥러닝의 아이디어의 유사한 부분에서 꽤 재미를 느꼈을 것이다.

다음 포스트에서는 Keras의 장점인 함수형 API를 이용해 모델을 만들어, 얕은 신경망(Wide model)과 깊은 신경망(Deep model)을 합친 Wide & Deep Learning에 대해 학습해보도록 하겠다.

TensorBoard - 텐서보드로 학습 과정 검토하기

만년필잉크 — Fri, 19 Feb 2021 11:37:42 +0900

이전 포스트에서는 TensorBoard의 Log Data가 쌓일 경로 설정과 TensorBoard 실행하기에 대해 알아보았다. 이번 포스트에서는 TensorBoard를 실제로 사용하는 방법에 대해 알아보도록 하겠다.

1. SCALARS

Tensorboard를 실행하면, 처음 뜨는 화면으로, 이전 포스트에서 생성하였던 Scalar 값들을 이용해서 손실 값과 정확도를 이용해 그래프를 그린 것이다.
해당 그래프를 통해, 훈련 셋(Train set)과 검증 셋(Validation set)의 손실 값(Loss)과 정확도(Accuracy)의 추이를 볼 수 있다.
이전에 학습과정을 확인했던 포스팅에서는 Matplotlib.pyplot을 사용해서, 그래프를 그렸다.

이전 포스팅을 그대로 따라왔다면, 다음과 같은 화면이 뜰 것이다.

그래프 아래에 빨간 부분 클릭 시, 그래프가 커지게 된다.
위 그래프는 우리가 이전에 만들었던 matplotlib.pyplot으로 뽑았던 결과보다 자세한 결과를 보여준다. train_set과 validation_set이 다른 경향을 보여주는 부분을 크게 확대해서 보여주었다.
그래프를 보면 연한 파란색과 빨간색 그래프가 희미하게 있는 것을 볼 수 있는데, 이 희미한 그래프는 실제 값이고, 이를 부드럽게 만든 것이 우리가 보고 있는 진한 파란색, 빨간색 그래프다. 이 부드러운 정도는 좌측의 "Smoothing" 바를 움직여서 조절할 수 있다.
위 그래프에서 epoch_accuracy는 epoch별 accuracy의 변화를 보여준다. epoch_loss는 epoch별 loss의 변화를 보여준다.
위 그래프를 보면, train set에 대한 학습 과정을 보여주는 파란색은 epoch가 지날수록 train set에 최적화되어 가므로, 지속적으로 증가하거나 감소하는 것을 볼 수 있으나, valiation set인 빨간색은 accuracy에서는 증가하다가 감소하는 부분이 생기고, loss에서는 accuracy보다 더 큰 폭으로 출렁이다가, epoch 11을 최솟값으로 지속적으로 증가하는 것을 볼 수 있다.
해당 모델은 조기종료를 사용하였으며, 조기종료에서의 patience 파라미터를 10으로 주어, 최솟값이 등장한 이후 10만큼 추가 epoch를 실시해, 그 안에 보다 작은 최솟값이 등장하지 않는다면, 학습을 멈추게 하였다.

2. GPAPHS

좌측 상단의 SCALARS 옆에 있는 GRAPHS를 클릭하면, 다음과 같은 화면이 뜬다.

이는 노드와 엣지 등을 이용하여, 그래프로 학습이 일어난 과정을 시각화한 것이다.
위 내용을 보면, 무언가 처음 보는 것이 엄청 많기 때문에 이해하기가 쉽지 않다.
우리가 모델을 만들 때, 사용했었던 Sequential 쪽으로 마우스를 드래그하고, 휠을 스크롤하여, 큰 화면으로 만들어보면, sequential 우측 상단에 + 마크가 있는 것을 확인할 수 있다. 이를 더블 클릭해보자.

이를 보면 우리가 모델을 만들 때 사용했던, Flatten, Hidden1, Hidden2, Hidden3, Output layer가 등장하는 것을 알 수 있다.
Hidden1, Hidden2, Hidden3는 모델을 생성할 때, name 파라미터를 이용해서 부여한 이름이다.
모서리가 둥근 직사각형을 클릭하면 그 안에 요약되어 있는 내용들을 볼 수 있다.
이를 이용해서 모델의 각 부분에서 어떻게 학습이 이루어졌는지 확인할 수 있다.

3. TIME SERIES

TIME SERIES에서는 실시간으로 그래프의 변화를 볼 수 있다.

먼저, Setting을 손봐서, 그래프 자동 Update 시간을 바꾸자.

Reload Period는 자동 Update 시간으로 TensorBoard로 볼 데이터의 크기 학습 시간 등을 고려하여 설정해야 한다. 최소 시간은 15초이므로, 15로 설정하도록 하겠다.
모델은 조기 종료의 patience를 50으로 잡아, 학습이 오랫동안 이뤄지도록 하겠다.
해당 학습 코드는 아래와 같다.

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras.layers import (Dense, BatchNormalization, Dropout, Flatten)
from tensorflow.keras.datasets.mnist import load_data

import numpy as np
import os
import datetime




# Dataset 준비
(train_images, train_labels), (test_images, test_labels)= load_data()

# 무작위로 샘플 추출
np.random.seed(1234)
index_list = np.arange(0, len(train_labels))
valid_index = np.random.choice(index_list, size = 5000, replace = False)

# 검증셋 추출
valid_images = train_images[valid_index]
valid_labels = train_labels[valid_index]

# 학습셋에서 검증셋 제외
train_index = set(index_list) - set(valid_index)
train_images = train_images[list(train_index)]
train_labels = train_labels[list(train_index)]

# min-max scaling
min_key = np.min(train_images)
max_key = np.max(train_images)

train_images = (train_images - min_key)/(max_key - min_key)
valid_images = (valid_images - min_key)/(max_key - min_key)
test_images = (test_images - min_key)/(max_key - min_key)



################################ Model ################################
model = keras.models.Sequential()
model.add(keras.layers.Flatten(input_shape=[28, 28], name="Flatten"))
model.add(Dense(300, activation="relu", name="Hidden1"))
model.add(Dense(200, activation="relu", name="Hidden2"))
model.add(Dense(100, activation="relu", name="Hidden3"))
model.add(Dense(10, activation="softmax", name="Output"))
#######################################################################



opt = keras.optimizers.Adam(learning_rate=0.005)
model.compile(optimizer = opt,
              loss = "sparse_categorical_crossentropy",
              metrics = ["accuracy"])
              
              
              

dir_name = "Learning_log"

def make_Tensorboard_dir(dir_name):
    root_logdir = os.path.join(os.curdir, dir_name)
    sub_dir_name = datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
    return os.path.join(root_logdir, sub_dir_name)

# 콜백함수 - 텐서보드
TB_log_dir = make_Tensorboard_dir(dir_name)
TensorB = keras.callbacks.TensorBoard(log_dir = TB_log_dir)

# 콜백함수 - 조기 종료
early_stop = keras.callbacks.EarlyStopping(monitor="val_loss", min_delta=0, patience=50, restore_best_weights=True)


# 모델 학습
history = model.fit(train_images, train_labels,
                    epochs=100,
                    batch_size=32,
                    validation_data=(valid_images, valid_labels),
                    callbacks=[early_stop, TensorB])

이를 실행하고 TensorBoard를 보도록 하자.

Tensorboard - 텐서보드 시작하기

만년필잉크 — Thu, 18 Feb 2021 15:22:29 +0900

Tensorboard

텐서플로우가 익숙하지 않은 사람은, 텐서플로우로 코드를 짜는 과정에서 시각적으로 보이는 것이 많지 않고, 보이는 부분도 이해하기 쉽지 않다 보니, 자신이 모델을 만들고, 학습을 시켰음에도 정확히 자신이 무엇을 했고, 문제가 발생한다 할지라도 왜 문제가 발생했는지 이해하기 어려울 수 있다.

이 때 필요한 것이 시각화 도구인 Tensorboard로, 이전 포스팅에서 우리가 학습이 종료된 후, matplotbib.pyplot을 이용해 시각화를 했던 것과 달리, 텐서보드는 훈련하는 도중에도 실시간 시각화를 할 수 있다.

Tensorboard는 텐서플로우뿐만 아니라 파이토치(Pytorch)에서도 사용 가능하므로, 그 사용법을 꼭 익히도록 하자.

1. Tensorboard의 기능

텐서보드는 주로 시각화 기능을 제공하지만, 그 외에도 간단한 통계 분석, 자동 클러스터링 등 다양한 편의 기능을 제공한다. 다음 내용은 Tensorflow 홈페이지에서 이야기하는 텐서보드의 대표적인 기능이다(텐서플로우 공식 홈페이지).

손실 및 정확도 같은 측정 도구 추적 및 시각화
모델 네트워크 시각화
시간의 경과에 따른 가중치, 편향, 기타 텐서의 히스토그램의 변화
저차원 공간에 임베딩 투영
이미지, 텍스트, 오디오 데이터 표시
TensorFlow 프로그램 프로파일링
TensorBoard.dev를 사용하여 실험 결과를 쉽게 호스팅, 추적 및 공유 가능

위 내용을 보면, 텐서보드가 머신러닝을 사용하기 위해 반드시 필요한 존재인 것은 아니지만, 텐서보드가 제공하는 다양한 기능을 통해서 보다 정확하고, 편리하게 기계학습을 진행할 수 있다는 것을 알 수 있다.

지금까지의 포스팅에서는 학습을 하기 위해 데이터가 어떻게 생겼고, 손실 값과 정확도를 추적하는 과정에서 새로운 함수를 만들거나, 다른 라이브러리의 기능을 가져와서 구현했으나, 텐서보드를 사용하면 이보다 쉽게 더 강력한 결과를 볼 수 있다.

2. Tensorboard 디렉터리 세팅하기

Tensorboard는 Tensorflow 설치 시, 자동으로 설치가 되고, 우리가 지금까지 사용했던 keras에서도 Tensorboard를 지원하기 때문에 따로 Tensorboard를 설치하지 않고도 사용할 수 있다.
Tensorboard는 시각화하고자 하는 Log 데이터를 모아야 한다.
텐서보드는 Log 데이터가 쌓이는 디렉터리를 모니터링하고, 자동으로 변경된 부분을 읽어 그래프를 업데이트한다.
위 기능으로 인해 Tensorboard는 실시간 데이터를 시각화할 수 있으나, 약간의 지연이 생기게 된다.

2.1. Log Data가 저장될 디렉터리 경로 만들기

import os

# Log data를 저장할 디렉터리 이름 설정
dir_name = "Learning_log"

# main 디렉터리와 sub 디렉터리 생성 함수
def make_Tensorboard_dir(dir_name):
    root_logdir = os.path.join(os.curdir, dir_name)
    sub_dir_name = datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
    return os.path.join(root_logdir, sub_dir_name)

os 모듈: 운영 체제와 상호 작용을 할 때, 사용하는 Python 기본 모듈로, Python 안에서 끝내는 것이 아닌 자신의 컴퓨터와 어떠한 작업을 하고자 한다면, 해당 모듈을 필수로 사용하게 된다.
os.curdir: 현재 디렉터리를 가지고 온다.
os.path.join('C:\Tmp', 'a', 'b'): 주어진 경로들을 합쳐서 하나로 만든다.
dir_name은 Tensorboard가 바라 볼 디렉터리의 이름이다.
코드 실행 시, 생성된 로그 데이터가 섞이지 않도록, dir_name 디렉터리 아래에 현재 날짜와 시간으로 하위 디렉터리의 경로를 만들어낸다.

3. Log를 생성해보자.

이전 TensorFlow를 학습할 때, 만들었던 모델을 가져와서 실행해보도록 하자.

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras.layers import (Dense, BatchNormalization, Dropout, Flatten)
from tensorflow.keras.datasets.mnist import load_data

import numpy as np
import os
import datetime

# Dataset 준비
(train_images, train_labels), (test_images, test_labels)= load_data()

# 무작위로 샘플 추출
np.random.seed(1234)
index_list = np.arange(0, len(train_labels))
valid_index = np.random.choice(index_list, size = 5000, replace = False)

# 검증셋 추출
valid_images = train_images[valid_index]
valid_labels = train_labels[valid_index]

# 학습셋에서 검증셋 제외
train_index = set(index_list) - set(valid_index)
train_images = train_images[list(train_index)]
train_labels = train_labels[list(train_index)]

# min-max scaling
min_key = np.min(train_images)
max_key = np.max(train_images)

train_images = (train_images - min_key)/(max_key - min_key)
valid_images = (valid_images - min_key)/(max_key - min_key)
test_images = (test_images - min_key)/(max_key - min_key)



################################ Model ################################
model = keras.models.Sequential()
model.add(keras.layers.Flatten(input_shape=[28, 28], name="Flatten"))
model.add(Dense(300, activation="relu", name="Hidden1"))
model.add(Dense(200, activation="relu", name="Hidden2"))
model.add(Dense(100, activation="relu", name="Hidden3"))
model.add(Dense(10, activation="softmax", name="Output"))
#######################################################################



opt = keras.optimizers.Adam(learning_rate=0.005)
model.compile(optimizer = opt,
              loss = "sparse_categorical_crossentropy",
              metrics = ["accuracy"])

Tensorboard 콜백 함수와 조기 종료 콜백 함수를 동시에 사용하도록 하겠다.

dir_name = "Learning_log"

def make_Tensorboard_dir(dir_name):
    root_logdir = os.path.join(os.curdir, dir_name)
    sub_dir_name = datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
    return os.path.join(root_logdir, sub_dir_name)

# 콜백함수 - 텐서보드
TB_log_dir = make_Tensorboard_dir(dir_name)
TensorB = keras.callbacks.TensorBoard(log_dir = TB_log_dir)

# 콜백함수 - 조기 종료
early_stop = keras.callbacks.EarlyStopping(monitor="val_loss", min_delta=0, patience=10, restore_best_weights=True)


# 모델 학습
history = model.fit(train_images, train_labels,
                    epochs=100,
                    batch_size=32,
                    validation_data=(valid_images, valid_labels),
                    callbacks=[early_stop, TensorB])

Epoch 1/100
1719/1719 [==============================] - 6s 3ms/step - loss: 0.3810 - accuracy: 0.8795 - val_loss: 0.1590 - val_accuracy: 0.9504
Epoch 2/100
1719/1719 [==============================] - 4s 2ms/step - loss: 0.1460 - accuracy: 0.9599 - val_loss: 0.1781 - val_accuracy: 0.9490
Epoch 3/100
1719/1719 [==============================] - 4s 2ms/step - loss: 0.1113 - accuracy: 0.9695 - val_loss: 0.1440 - val_accuracy: 0.9600
Epoch 4/100
1719/1719 [==============================] - 4s 2ms/step - loss: 0.1018 - accuracy: 0.9704 - val_loss: 0.1030 - val_accuracy: 0.9692

...

Epoch 19/100
1719/1719 [==============================] - 4s 2ms/step - loss: 0.0462 - accuracy: 0.9891 - val_loss: 0.1291 - val_accuracy: 0.9744
Epoch 20/100
1719/1719 [==============================] - 4s 2ms/step - loss: 0.0472 - accuracy: 0.9901 - val_loss: 0.1196 - val_accuracy: 0.9762
Epoch 21/100
1719/1719 [==============================] - 4s 2ms/step - loss: 0.0398 - accuracy: 0.9909 - val_loss: 0.1714 - val_accuracy: 0.9698
Epoch 22/100
1719/1719 [==============================] - 4s 2ms/step - loss: 0.0483 - accuracy: 0.9899 - val_loss: 0.1745 - val_accuracy: 0.9714

위 코드를 실행하면, 위 사진과 같이 자신의 워킹 디렉터리 내에 Tensorboard용 디렉터리와 자기가 코드를 실행한 횟수만큼 서브 디렉터리가 생성된 것을 볼 수 있다.
생성된 서브 디렉터리 안에는 train과 validation이라는 디렉터리가 생성되며, 그 아래에는 event라는 파일이 새로 생성된 것을 볼 수 있다.

4. Tensorboard 실행하기

텐서보드 실행방법은 크게 두 가지다.

4.1. Terminal을 이용해서 실행하기

머신러닝을 사용한다면, 서버에 붙어서 사용할 가능성이 높으므로, 주피터 노트북을 기준으로 터미널에 접속하는 방법을 설명하도록 하겠다.

New > Terminal을 클릭하면 검은 화면이 뜨게 된다.

이 화면에서 방금 만들었던 텐서보드용 디렉터리를 찾아가면 된다.
위 과정대로 따라왔다면, 자신의 워킹 디렉터리에 만들었을 것이므로, 워킹 디렉터리를 찾아가자

>>> os.getcwd()
'C:\\Jupyter\\Blog\\ML'

os.getcwd(): 해당 주피터 파일의 워킹 디렉터리 주소를 반환한다.

cd 'C:\\Jupyter\\Blog\\ML'를 위 검은 창에 적으면, 해당 디렉터리로 이동한다.
dir 입력 시, 그 디렉터리에 있는 파일들을 모두 가져온다.
디렉터리 안에 텐서보드를 위해 만들었던 Learning_lig 디렉터리가 존재하는 것을 볼 수 있다.
터미널 안에 아래 코드를 입력하자.

tensorboard --logdir=./Learning_log --port=6006

위 사진 같이 글이 뜰 것인데 여기서 http://localhost:6006/ 을 주소창에 쓰거나 클릭하면, 텐서보드로 이동한다.

터미널을 종료해도 텐서보드 서버가 켜졌기 때문에 접속 가능하다.
물론, 컴퓨터를 종료하는 등 텐서보드 서버를 끄는 행동을 한다면, 위 과정을 다시 반복해야 한다.

4.2. 주피터 노트북 안에서 텐서보드 실행하기

조금 더 쉽지만, 개인적으로는 선호하지 않는 방법이다(가시성이 좀 떨어진다.)
지금까지 코드를 작성했던, 주피터 노트북 안에 다음 코드를 실행해보자.

%load_ext tensorboard
%tensorboard --logdir=./Learning_log --port=6006

지금까지 텐서보드를 사용하기 위해, Log 디렉터리를 생성하고, 텐서보드를 실행하는 방법에 대해 알아보았다. 다음 포스트에서는 텐서보드를 사용해서 훈련 셋(Train set)과 검증 셋(Validation set)의 손실 값(loss)과 정확도(accuracy)를 평가하는 방법에 대해 알아보도록 하자.

Pandas-데이터 프레임 Index 가지고 놀기

만년필잉크 — Thu, 18 Feb 2021 09:20:57 +0900

이전 포스트에서 DataFrame의 생김새와 부위별 이름에 대해 알아보았다. DataFrame의 가장 큰 특징은 index가 존재한다는 것이고, 이 index를 얼마나 잘 가지고 노느냐에 따라 DataFrame을 얼마나 효율적으로 사용할 수 있는지가 나뉘게 된다.

데이터 프레임과 인덱스

Pandas에 대해 흔히들 가지고 있는 오해가 Pandas는 순차적으로 데이터를 조회하기 때문에, 데이터 전처리 속도가 매우 느리다는 것이다.

이 말은 반은 맞고, 반은 틀리다고 할 수 있는데, DataFrame에서 특정 데이터를 단순하게 조회하면, 순서대로 하나하나 조회하기 때문에 속도가 매우 느려지고, 도리어 이 특징을 이용해서, 데이터 전처리 속도를 줄일 수도 있다.

그러나, 인덱스를 사용하여 조회를 하게 된다면, 순차적 조회가 아닌 한 번에 index에 해당하는 값을 가지고 오기 때문에 조회 속도가 엄청 빨라진다.

그러므로, Pandas를 사용해야 하는 데이터 분석가라면 반드시 이 인덱스를 잘 가지고 놀 수 있어야 한다.

1. DataFrame 생성 시, 원하는 Index 부여하기

index는 DataFrame을 생성하면서 부여할 수도 있고, DataFrame을 생성한 후에도 바꿔줄 수 있다.
다음과 같은 데이터 셋을 만들어보자.

import pandas as pd

name_list = ["박명수", "유재석", "노홍철", "길", "정준하", "정형돈", "하하"]
math_list = [65, 95, 70, 80, 100, 85, 60]
english_list = [75, 80, 85, 90, 65, 75, 100]
class_list = [1, 2, 1, 2, 2, 2, 1]
index_list = list(range(10, 24, 2))

exam = pd.DataFrame({"name":name_list, "math":math_list, "english":english_list,
                     "class":class_list}, index=index_list)
exam

range(start, end, by): start부터 end까지 값을 by 간격으로 만들 준비를 한다.
(list 함수 같은 것으로 가동해주지 않으면, 대기 상태를 유지한다)
생성된 데이터 프레임을 보듯, 데이터 프레임 생성 시, index 파라미터에 넣어준 list를 index로 부여한다.

2. 내가 원하는 칼럼을 index로 부여하기

이미 index가 정해졌다 할지라도, index는 내가 원하는 칼럼을 index로 만들어줄 수 있다.

exam.set_index("name", inplace=True)
exam

DataFrame.set_index(column, drop=True, append=False, inplace=False): set_index()는 말 그대로, 내가 원하는 칼럼을 index로 설정해주는 함수다.
drop 파라미터는 기존 칼럼을 index로 넣을 때, 기존 칼럼을 말 그대로 버려버릴지를 묻는 것이다.
append 파라미터는 기존 인덱스에 내가 원하는 칼럼까지 추가해서 인덱스를 만들지를 묻는 것이다.
inplace 파라미터는 원본 데이터에 덮어씌울지를 물어보는 것이다. 여기서는 inplace = True를 하였으므로, index가 바뀐 것을 바로 원본에 적용하였다.
중복되는 값이라 할지라도 index로 만들 수 있다.

exam.set_index("class", inplace=True)
exam

데이터 프레임의 인덱스에 대해 "중복이 돼서는 안 되는 유니크한 값이어야 한다."라 오해를 하는 경우가 종종 있는데, 위에서 보시다시피 중복이 가능하다. 이는, 데이터 프레임의 인덱스의 특징이며, 이 특징을 잘 이용하는 것이 중요하다.
데이터 프레임의 인덱스는 중복 가능하므로, 조회 시, 해당 인덱스에 해당하는 값을 모두 가지고 온다.

exam.loc[2]

DataFrame.loc[index]: index에 해당하는 행을 조회하는 방법으로 추후 자세히 다루도록 하겠다.

3. 인덱스 초기화

무한도전 멤버들의 이름을 인덱스로 했었다가 class로 인덱스를 설정하니, 무한도전 멤버들의 이름이 사라져 버렸다.
이는 DataFrame.set_index()는 기본적으로 기존 index를 없애는 것을 전재로 하기 때문이다.
이러한 일을 막기 위해선 set_index()를 하기 전에 인덱스를 초기화해줘야 한다.

exam.reset_index(drop = False, inplace = True)
exam

DataFrame.reset_index(drop=False, inplace=False): reset_index는 인덱스를 말 그대로 초기화시켜버린다.
drop 파라미터는 기존의 index를 버릴지 말지를 결정하는 파라미터다
무한도전 멤버들의 이름이 index인 상태에서 reset_index()하고 set_index()를 하였다면, 이번처럼 기존 인덱스가 날아가버리는 일을 막을 수 있다.

4. 새로운 list를 인덱스로 부여하고 인덱스를 조작해보자

처음에 만들었던, name_list를 index로 부여하여, 무한도전 멤버의 이름이 index인 상태로 돌아가 보자.

exam.index = name_list
exam

DataFrame.index: DataFrame의 index를 조작할 수 있다.
이전에는 index의 이름이 name으로 나왔으나, index는 본래 이름이 따로 없기 때문에 index의 이름이 없는 상태로 출력된 것을 볼 수 있다.

4.1. 인덱스 이름 부여

exam.index.name = "name"
exam

DataFrame.index는 뒤에 다른 함수들을 붙여 추가적인 기능들을 실행할 수 있다.
이번에는 DataFrame.index.name으로 하여 index의 이름을 부여해보았다.

4.2. 인덱스 데이터 추출

>>> exam.index
Index(['박명수', '유재석', '노홍철', '길', '정준하', '정형돈', '하하'], dtype='object', name='name')

list를 index에 넣었듯, array로 index를 뽑아낼 수도 있다.
이러한 index 조작은 데이터 프레임을 다룰 때, 상당히 쓸모 있는 기술이므로 꼭 숙지하도록 하자.

5. 멀티 인덱스(Multi index)와 인덱스를 기준으로 정렬

멀티 인덱스는 말 그대로 index를 한 번에 여러 개 사용하는 방법이다.
무한도전 멤버의 이름을 칼럼으로 되돌리고, class, name으로 멀티 인덱싱을 해보자.

exam.reset_index(drop=False, inplace=True)
exam.set_index(["class", "name"], inplace = True)
exam

멀티 인덱스는 set_index(column)에서 칼럼을 여러 개 넣어서 실시할 수 있다.
멀티 인덱스를 하고 나니, class 2의 길, 정준하, 정형돈의 class가 하나로 붙어 깔끔하게 나온 것을 볼 수 있다.
그러나, 썩 깔끔해 보이지 않으므로 인덱스를 기준으로 정렬시켜보자.

5.1. 인덱스 기준 정렬

exam.sort_index(inplace=True)
exam

DataFrame.sort_index(ascending=True, inplace=False): 말 그대로 index순으로 정렬(sort)한다.
ascending 파라미터는 오름차순, 내림차순을 의미하며, 기본적으로 오름차순 정렬이 실행된다.

5.2. 멀티 인덱스의 실제 모습

멀티 인덱스를 실행하게 되면, 데이터의 형태를 보다 쉽게 파악할 수 있다는 장점이 있다. 때문에 멀티 인덱스는 group_by를 하여 두 집단 이상의 기술 통계량을 볼 때, 멀티 인덱스로 출력되게 된다.
멀티 인덱스를 하면, class는 하나의 index로 뭉친 것처럼 보이는데, 눈에만 저렇게 보이지 실제로는 따로 떨어져 있다.

>>> exam.index
MultiIndex([(1, '노홍철'),
            (1, '박명수'),
            (1,  '하하'),
            (2,   '길'),
            (2, '유재석'),
            (2, '정준하'),
            (2, '정형돈')],
           names=['class', 'name'])

exam의 index를 보면, 튜플로 묶여 있는 것을 볼 수 있다.

5.3. 멀티 인덱스 해제

exam.reset_index(drop=False)

멀티 인덱스 해제는 reset_index()를 하여 쉽게 할 수 있다.

지금까지 판다스에서 인덱스를 가지고 노는 법에 대해 학습해보았다. 판다스에서 인덱스를 얼마나 잘 활용하느냐에 따라 판다스의 속도는 크게 변하므로, 인덱스를 잘 활용하길 바란다.

Pandas-데이터 프레임의 구조와 용어 정리

만년필잉크 — Wed, 17 Feb 2021 23:42:22 +0900

이전 포스트에서 데이터 프레임을 만들어보았으니, 이번에는 데이터 프레임의 부위별 이름을 알아보자.

데이터 프레임의 구조와 용어 정리

위 표는 우리가 지금까지 봐온 데이터 프레임이다. 데이터 프레임의 생김새는 우리가 자주 봐왔던 표(Table)처럼 생겼다.
Data를 사용하는 분야에서 기본적으로 사용하는 관계형 데이터베이스(Relational Database, RDM)의 테이블(Table)도 데이터 프레임과 동일하게 생겼다.
RDB를 여기저기서 많이 사용하다 보니, 그 용어를 데이터 프레임에도 사용하는 경우가 많기 때문에, RDB에서 사용하는 용어도 함께 정리하도록 하겠다.

1. 칼럼(Column)

칼럼(Column)은 단어 그대로 열을 의미하며, 행과 열을 가진 데이터에서 열은 모두 칼럼이라고 불린다.
변수(Variable), 속성(Attribute), 필드(Field)라고도 불린다.
데이터에서 객체(대상)가 가지고 있는 특징이 들어간다.
예를 들어, 이름, 성별, 나이와 같은 대상 집단이 가지고 있는 특징이다.
차수(Degree): RDB에서는 칼럼의 수를 가리킨다.
예) 위 테이블의 Degree는 11이다.
도메인(Domain): RDB에서 한 칼럼에서 가질 수 있는 값의 집합
예) 성별의 도메인은 "남", "여" 둘 뿐이며, 그 외의 값은 들어갈 수 없다.

2. 로우(Row)

말 그대로 행을 가리키며, 데이터 하나하나를 의미한다. 그러다 보니, 모양이 데이터 프레임과 조금 다르더라도, 데이터 하나하나를 지칭할 때, 단순하게 Row라고 부르기도 한다.
튜플(Tuple), 레코드(Record)라고도 불린다.
데이터의 대상이 되는 객체 하나하나를 의미한다.
예를 들어, 위 데이터 프레임에서 index가 417번인 사람은, 고객번호(PassengerId)가 1309번이고, 이름이 Peter, Master. Michael J이며, 성별이 male인 사람이다.
카디널리티(Cardinality): 행의 총 개수이다.

3. 인덱스(Index)

데이터 프레임만의 특징으로, index는 중복될 수도 있고, 동일한 index에 해당하는 row의 값이 다를 수도 있다.
index를 어떻게 조작하느냐에 따라, 데이터 프레임에서의 데이터 조회 속도 차이가 엄청 커진다.
RDB의 key와 유사해 보이지만, RDB의 key는 고유 개체를 식별할 수 있는 유니크한 값임에 반해, 데이터 프레임의 index는 중복이 가능하고, index가 동일하나, row에 있는 값은 다를 수 있으므로, key와 굉장히 다르다.

지금까지 데이터 프레임의 행, 열의 다른 용어와 그것이 의미하는 바에 대해 간단히 다뤄봤다. 위 단어 외에도 인스턴스(Instance), 엔티티(Entity)와 같은 다양한 단어가 있으나, 데이터 프레임이던 테이블이던 기본적으로 행과 열이 중심이기 때문에 위 용어만 알면, 데이터에 대한 기본적인 의사소통은 할 수 있을 것이다.

다음 포스트에서는 index를 가지고 노는 방법에 대해 학습해보도록 하겠다.

Tensorflow-3.8. 이미지 분류 모델(8)-모델 저장과 불러오기

만년필잉크 — Wed, 17 Feb 2021 18:03:55 +0900

지금까지 tensorflow.keras를 사용해서 일어나는 전반적인 과정에 대해 천천히 살펴보았다. 모델 평가는 하이퍼 파라미터 최적화(Hyper Parameter optimization)의 개념으로 들어가게 되면, 그 양이 꽤 길어지므로, 거기까진 나중에 따로 들어가도록 하겠다.

이번 포스트에서는 지금까지 학습했던 내용들을 정리하고, .evaluate() 함수로 지금까지 만들었던 모델의 성능을 평가한 후, 모델을 저장 및 불러오기를 해보도록 하겠다.

1. 학습 코드 최종 정리 및 모델 평가

# Import module
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras.layers import (Dense, BatchNormalization, Dropout, Flatten)
from tensorflow.keras.datasets.mnist import load_data

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

# Dataset 준비
(train_images, train_labels), (test_images, test_labels)= load_data()

# 무작위로 샘플 추출
np.random.seed(1234)
index_list = np.arange(0, len(train_labels))
valid_index = np.random.choice(index_list, size = 5000, replace = False)

# 검증셋 추출
valid_images = train_images[valid_index]
valid_labels = train_labels[valid_index]

# 학습셋에서 검증셋 제외
train_index = set(index_list) - set(valid_index)
train_images = train_images[list(train_index)]
train_labels = train_labels[list(train_index)]

# min-max scaling
min_key = np.min(train_images)
max_key = np.max(train_images)

train_images = (train_images - min_key)/(max_key - min_key)
valid_images = (valid_images - min_key)/(max_key - min_key)
test_images = (test_images - min_key)/(max_key - min_key)





# 모델 생성
model = keras.models.Sequential()
model.add(keras.layers.Flatten(input_shape=[28, 28], name="Flatten"))
model.add(Dense(300, activation="relu", name="Hidden1"))
model.add(Dense(200, activation="relu", name="Hidden2"))
model.add(Dense(100, activation="relu", name="Hidden3"))
model.add(Dense(10, activation="softmax", name="Output"))





# 모델 컴파일
opt = keras.optimizers.Adam(learning_rate=0.005)
model.compile(optimizer = opt,
              loss = "sparse_categorical_crossentropy",
              metrics = ["accuracy"])
              
              
              
              
              
early_stop = keras.callbacks.EarlyStopping(monitor="val_loss", min_delta=0, patience=10, restore_best_weights=True)
history = model.fit(train_images, train_labels,
                    epochs=100,
                    batch_size=5000,
                    validation_data=(valid_images, valid_labels),
                    callbacks=[early_stop])

Epoch 1/100
11/11 [==============================] - 2s 162ms/step - loss: 1.4978 - accuracy: 0.4962 - val_loss: 0.4193 - val_accuracy: 0.8836
Epoch 2/100
11/11 [==============================] - 1s 53ms/step - loss: 0.3403 - accuracy: 0.9037 - val_loss: 0.2377 - val_accuracy: 0.9270
Epoch 3/100
11/11 [==============================] - 1s 58ms/step - loss: 0.2092 - accuracy: 0.9373 - val_loss: 0.1695 - val_accuracy: 0.9480
Epoch 4/100
11/11 [==============================] - 1s 51ms/step - loss: 0.1490 - accuracy: 0.9554 - val_loss: 0.1303 - val_accuracy: 0.9590
Epoch 5/100
11/11 [==============================] - 1s 52ms/step - loss: 0.1113 - accuracy: 0.9664 - val_loss: 0.1108 - val_accuracy: 0.9632

...

Epoch 19/100
11/11 [==============================] - 1s 47ms/step - loss: 0.0034 - accuracy: 0.9996 - val_loss: 0.0777 - val_accuracy: 0.9800
Epoch 20/100
11/11 [==============================] - 1s 47ms/step - loss: 0.0024 - accuracy: 0.9998 - val_loss: 0.0782 - val_accuracy: 0.9790
Epoch 21/100
11/11 [==============================] - 1s 52ms/step - loss: 0.0016 - accuracy: 1.0000 - val_loss: 0.0784 - val_accuracy: 0.9786
Epoch 22/100
11/11 [==============================] - 1s 52ms/step - loss: 0.0012 - accuracy: 0.9999 - val_loss: 0.0816 - val_accuracy: 0.9794
Epoch 23/100
11/11 [==============================] - 1s 47ms/step - loss: 0.0012 - accuracy: 0.9999 - val_loss: 0.0813 - val_accuracy: 0.9796

# 모델 평가
>>> model.evaluate(test_images, test_labels)
313/313 [==============================] - 1s 2ms/step - loss: 0.0718 - accuracy: 0.9794
[0.07175429910421371, 0.9793999791145325]

model.evaluate(test_set, test_label): 시험 셋으로 생성된 모델을 최종 평가한다.
위 모델은 정확도가 0.979로 굉장히 정확도가 높은 모델이 만들어졌다.
이 evaluate의 accuracy를 기준으로 하이퍼 파라미터를 튜닝하는 경우가 꽤 많은데, 그렇게 되면 시험 셋에 최적화가 돼버릴 위험이 있다.
이를 방지하기 위해, 시험 셋은 최종 평가의 수단으로만 쓰고, 검증 셋을 대신 사용하여, 최적화를 하여, 특정 데이터 셋에 최적화되는 현상은 피하도록 하자.
이 하이퍼 파라미터 튜닝(Hyper Parameter Tuning)은 추후 자세히 다루도록 하겠다.

2. 모델 저장하기

지금까지 힘들게 만든 모델은 지금 당장 사용할 수도 있지만, 나중에 사용할 수도 있기 때문에, 모델 저장과 불러오기를 할 수 있어야 한다.

model.save("MNIST_210217.h5")

model.save("저장하고자_하는_모델_이름.h5")
위 방법 사용 시, 원하는 이름과 경로에 모델의 아키텍처와 파라미터가 저장되게 된다.

저장되는 내용은 다음과 같다.

모델을 재구성하기 위한 모델의 구성 정보(모델 아키텍처)
재학습을 할 수 있도록 마지막 학습 상태
모델을 구성하는 각 뉴런의 파라미터

3. 모델 불러오기

MNIST_model = keras.models.load_model("MNIST_210217.h5")

모델 불러오기는 keras.models.load_model("불러오고자_하는_파일_이름.h5") 로 쉽게 할 수 있다.
모델에 데이터를 넣어 결과를 출력하는 방법은 다음과 같다.

>>> np.argmax(MNIST_model.predict(test_images), axis=-1)
array([7, 2, 1, ..., 4, 5, 6], dtype=int64)

단순 예시를 위해 시험 셋을 넣은 것이며, 실제로는 만들어진 모델의 목적에 맞는 새로운 데이터 셋을 넣어야 한다.
모델의 아키텍처는 summary를 이용해서 보도록 하자.

>>> MNIST_model.summary()
Model: "sequential"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
Flatten (Flatten)            (None, 784)               0         
_________________________________________________________________
Hidden1 (Dense)              (None, 300)               235500    
_________________________________________________________________
Hidden2 (Dense)              (None, 200)               60200     
_________________________________________________________________
Hidden3 (Dense)              (None, 100)               20100     
_________________________________________________________________
Output (Dense)               (None, 10)                1010      
=================================================================
Total params: 316,810
Trainable params: 316,810
Non-trainable params: 0
_________________________________________________________________

지금까지 Tensorflow를 사용해서 모델을 학습하는 과정을 세세히 들여다보았다. 지금까지 했던 부분에서 빼먹은 부분이 없는 것은 아니지만, 이는 앞으로 쭉 학습을 해나가면서 채워가도록 하겠다.

Tensorflow-3.7. 이미지 분류 모델(7)-조기 종료와 콜벡

만년필잉크 — Wed, 17 Feb 2021 17:12:45 +0900

지금까지 이미지 분류 모델을 만들고, 학습까지 시켜보았다. 지난 포스트에서는 학습 과정을 보며, 학습이 제대로 이루어졌는지를 평가하고, 최적의 epochs를 결정하는 방법에 대해 공부해보았다.

그러나, 지금 같이 데이터의 양이 작고, epochs가 상대적으로 적은 경우엔 학습이 완전히 끝난 후 그래프를 그려서 학습 과정을 살필 수 있었지만, 만약에 epochs가 1,000 이거나 데이터의 크기가 1,000만 개를 가뿐히 넘겨 학습 시간이 길어지는 경우라면, 이전에 했던 방법으로 접근해서는 안된다.

이때, 등장하는 개념이 바로 조기 종료다.

조기 종료(Early Stopping)

0. 선행 코드

# Import module
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras.layers import (Dense, BatchNormalization, Dropout, Flatten)
from tensorflow.keras.datasets.mnist import load_data

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

# Dataset 준비
(train_images, train_labels), (test_images, test_labels)= load_data()

# 무작위로 샘플 추출
np.random.seed(1234)
index_list = np.arange(0, len(train_labels))
valid_index = np.random.choice(index_list, size = 5000, replace = False)

# 검증셋 추출
valid_images = train_images[valid_index]
valid_labels = train_labels[valid_index]

# 학습셋에서 검증셋 제외
train_index = set(index_list) - set(valid_index)
train_images = train_images[list(train_index)]
train_labels = train_labels[list(train_index)]

# min-max scaling
min_key = np.min(train_images)
max_key = np.max(train_images)

train_images = (train_images - min_key)/(max_key - min_key)
valid_images = (valid_images - min_key)/(max_key - min_key)
test_images = (test_images - min_key)/(max_key - min_key)





# 모델 생성
model = keras.models.Sequential()
model.add(keras.layers.Flatten(input_shape=[28, 28], name="Flatten"))
model.add(Dense(300, activation="relu", name="Hidden1"))
model.add(Dense(200, activation="relu", name="Hidden2"))
model.add(Dense(100, activation="relu", name="Hidden3"))
model.add(Dense(10, activation="softmax", name="Output"))





# 모델 컴파일
opt = keras.optimizers.Adam(learning_rate=0.005)
model.compile(optimizer = opt,
              loss = "sparse_categorical_crossentropy",
              metrics = ["accuracy"])

1. 검증 손실 값과 과대 적합

조기 종료를 이해하기 위해선 이전에 만들었던 그래프를 다시 한번 봐야 한다.

위 그래프는 훈련 셋과 검증 셋의 손실 값(Loss)과 정확도(Accuracy)를 시각화한 것이다.
검증 셋의 손실 값(val_loss, 녹색)은, 쭉 감소하다가 갑자기 손실 값이 증가하게 된다.
이는 모델이 학습 셋에 지나치게 최적화되어, 학습 셋이 아닌 다른 데이터 셋을 이상하게 출력하는 과대 적합(Overfitting) 현상이 발생하여, 일어나는 현상이다.
조기 종료는 검증 셋의 손실 값이 최소가 되는 순간(최적의 모델) 학습을 멈춤으로써, 이러한 과대 적합을 멈추는 아주 간단하면서도 강력한 규제 방법 중 하나다.
참고: "Tensorflow-3.2. 이미지 분류 모델(2)-검증 셋(Validation set)"
조기 종료는 이전 "Tensorflow-3.3. 이미지 분류 모델(3)-모델 생성"에서 잠깐 언급하고 넘어갔던, "스트레치 팬츠(Stretch pants) 방식"을 위한 도구 중 하나다.

2. 콜벡(callbacks)

콜벡(callbacks)은 학습 과정에서 영향을 주거나, 발생한 통계 데이터를 출력해주는 함수들의 집합이다.
대표적인 callbacks 함수는 이전 포스트에서 우리가 다뤘던 history로, 워낙 유용하다 보니 자동으로 적용되어 있다.
callbacks 함수는 Sequential이나 .fit() 메서드에 전달 가능하다.
조기 종료는 이 callbacks 안에 포함되어 있다.

2.1. 조기 종료

조기 종료는 다음과 같은 방법으로 사용할 수 있다.

early_stop = keras.callbacks.EarlyStopping(monitor="val_loss", min_delta=0, patience=10, restore_best_weights=True)
history = model.fit(train_images, train_labels,
                    epochs=1000,
                    batch_size=5000,
                    validation_data=(valid_images, valid_labels),
                    callbacks=[early_stop])

keras.callbacks.EarlyStopping()의 중요 파라미터는 다음과 같다.

monitor: 관찰할 값 - 일반적으로 검증 손실 값인 var_loss를 사용하며, 간간히 var_acc가 사용되기도 한다.
min_delta: 개선 기준 최소 변화량 - 개선되고 있다고 판단할 수 있는 최소 변화량으로 변화량이 min_delta보다 작다면 개선이 없다고 판단한다.
patience: 정지까지 기다리는 epochs - 당장 최솟값이 나왔다 할지라도, 이 값이 학습을 하다 보면, 더 떨어질 수도 있다. 그러므로, patience에 정해진 epochs만큼 학습을 더 실시하고, 그동안 개선이 없다면, 학습을 멈춘다.
restore_best_weights: 최선 값이 발생한 때로 모델 가중치 복원 여부 - False로 돼 있다면, 학습의 마지막 단계에서 얻어진 모델 가중치가 사용된다.

val_loss는 증감을 반복하므로, epochs를 조금 줘서 기다리도록 하자.
위 코드를 실행하면 다음과 같은 결과가 나온다.

Epoch 1/1000
11/11 [==============================] - 2s 177ms/step - loss: 1.5362 - accuracy: 0.4834 - val_loss: 0.4362 - val_accuracy: 0.8714
Epoch 2/1000
11/11 [==============================] - 1s 55ms/step - loss: 0.3673 - accuracy: 0.8928 - val_loss: 0.2479 - val_accuracy: 0.9252
Epoch 3/1000
11/11 [==============================] - 1s 55ms/step - loss: 0.2225 - accuracy: 0.9336 - val_loss: 0.1759 - val_accuracy: 0.9436
Epoch 4/1000
11/11 [==============================] - 1s 61ms/step - loss: 0.1550 - accuracy: 0.9539 - val_loss: 0.1353 - val_accuracy: 0.9560
Epoch 5/1000
11/11 [==============================] - 1s 55ms/step - loss: 0.1185 - accuracy: 0.9649 - val_loss: 0.1108 - val_accuracy: 0.9640

...

Epoch 19/1000
11/11 [==============================] - 1s 54ms/step - loss: 0.0032 - accuracy: 0.9997 - val_loss: 0.0786 - val_accuracy: 0.9806
Epoch 20/1000
11/11 [==============================] - 1s 51ms/step - loss: 0.0026 - accuracy: 0.9999 - val_loss: 0.0841 - val_accuracy: 0.9794
Epoch 21/1000
11/11 [==============================] - 1s 52ms/step - loss: 0.0024 - accuracy: 0.9998 - val_loss: 0.0831 - val_accuracy: 0.9794
Epoch 22/1000
11/11 [==============================] - 1s 60ms/step - loss: 0.0017 - accuracy: 1.0000 - val_loss: 0.0800 - val_accuracy: 0.9798
Epoch 23/1000
11/11 [==============================] - 1s 51ms/step - loss: 0.0013 - accuracy: 1.0000 - val_loss: 0.0845 - val_accuracy: 0.9792

epochs를 1000으로 지정하였으나, val_loss가 최솟값을 찍었기 때문에 epoch 23에서 학습을 정지하였다.
조기 종료를 사용하면, 별도의 과정 없이, 손쉽게 최적의 epochs를 찾아낼 수 있으므로, 오차 역전파법을 찾아내 지금의 딥 러닝을 있게 한 1등 공신 중 한 명인 제프리 힌턴은 조기 종료를 "훌륭한 공짜 점심(beautiful free lunch)"이라고 불렀다고 한다.
이외에도 콜벡에는 학습 중간에 자동 저장을 하는 ModelCheckPoint나 학습률을 스케쥴링하는 LearningRateSchedule 등 유용한 기능이 많다. 관심 있는 사람은 다음 아래 사이트를 참고하기 바란다.
(keras.io/ko/callbacks/)

Callbacks - Keras Documentation

Usage of callbacks 콜백은 학습 과정의 특정 단계에서 적용할 함수의 세트입니다. 학습 과정 중 콜백을 사용해서 모델의 내적 상태와 통계자료를 확인 할 수 있습니다. 콜백의 리스트는 (키워드 인수

keras.io

[참고 서적]

지금까지 조기 종료(Early stopping)와 콜백에 대해 알아보았다. 다음 포스트에서는 최종 과정인 모델 평가와 모델 저장 및 불러오기에 대해 학습해보도록 하겠다.

Tensorflow-3.6. 이미지 분류 모델(6)-학습과정 확인

만년필잉크 — Wed, 17 Feb 2021 14:19:40 +0900

이전 포스트에서 모델을 학습시키는 것에 대해 알아보았다. 기존 포스팅에서는 학습을 시키고, 이를 가만히 기다리기만 했었는데, 이 학습 과정에서 발생하는 Log를 분석할 수 있다면, 언제 학습을 멈춰야 할지, 과적합이 발생하였는지 등을 정보다 정확히 알 수 있다. 이번 포스팅에서는 학습과정을 확인하는 방법에 대해 알아보도록 하겠다.

학습과정 확인(History)

0. 이전 코드 정리

# Import module
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras.layers import (Dense, BatchNormalization, Dropout, Flatten)
from tensorflow.keras.datasets.mnist import load_data

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

# Dataset 준비
(train_images, train_labels), (test_images, test_labels)= load_data()

# 무작위로 샘플 추출
np.random.seed(1234)
index_list = np.arange(0, len(train_labels))
valid_index = np.random.choice(index_list, size = 5000, replace = False)

# 검증셋 추출
valid_images = train_images[valid_index]
valid_labels = train_labels[valid_index]

# 학습셋에서 검증셋 제외
train_index = set(index_list) - set(valid_index)
train_images = train_images[list(train_index)]
train_labels = train_labels[list(train_index)]

# min-max scaling
min_key = np.min(train_images)
max_key = np.max(train_images)

train_images = (train_images - min_key)/(max_key - min_key)
valid_images = (valid_images - min_key)/(max_key - min_key)
test_images = (test_images - min_key)/(max_key - min_key)

# 모델 생성
model = keras.models.Sequential()
model.add(keras.layers.Flatten(input_shape=[28, 28], name="Flatten"))
model.add(Dense(300, activation="relu", name="Hidden1"))
model.add(Dense(200, activation="relu", name="Hidden2"))
model.add(Dense(100, activation="relu", name="Hidden3"))
model.add(Dense(10, activation="softmax", name="Output"))

# 모델 컴파일
opt = keras.optimizers.Adam(learning_rate=0.005)
model.compile(optimizer = opt,
              loss = "sparse_categorical_crossentropy",
              metrics = ["accuracy"])

# 모델 학습하기
history = model.fit(train_images, train_labels,
                    epochs=100,
                    batch_size = 5000,
                    validation_data=(valid_images, valid_labels))

이전 포스팅에서는 model.fit()을 따로 다른 변수에 담지 않았으나, 이번 포스팅에서는 이들을 history라는 변수에 담고, 이를 분석해보도록 하겠다.

1. History

model.fit()을 실시하여, 학습을 시작하게 되면, 다음과 같은 Log가 출력되게 된다.

history = model.fit(train_images, train_labels,
                    epochs=100,
                    batch_size=5000,
                    validation_data=(valid_images, valid_labels))

Epoch 1/100
11/11 [==============================] - 2s 182ms/step - loss: 1.5596 - accuracy: 0.4747 - val_loss: 0.4669 - val_accuracy: 0.8640
Epoch 2/100
11/11 [==============================] - 1s 57ms/step - loss: 0.3706 - accuracy: 0.8902 - val_loss: 0.2654 - val_accuracy: 0.9182
Epoch 3/100
11/11 [==============================] - 1s 55ms/step - loss: 0.2260 - accuracy: 0.9337 - val_loss: 0.1824 - val_accuracy: 0.9416
Epoch 4/100
11/11 [==============================] - 1s 51ms/step - loss: 0.1626 - accuracy: 0.9514 - val_loss: 0.1369 - val_accuracy: 0.9562
Epoch 5/100
11/11 [==============================] - 1s 52ms/step - loss: 0.1198 - accuracy: 0.9642 - val_loss: 0.1176 - val_accuracy: 0.9624

...

Epoch 96/100
11/11 [==============================] - 1s 52ms/step - loss: 2.8271e-05 - accuracy: 1.0000 - val_loss: 0.1096 - val_accuracy: 0.9788
Epoch 97/100
11/11 [==============================] - 1s 57ms/step - loss: 2.7180e-05 - accuracy: 1.0000 - val_loss: 0.1100 - val_accuracy: 0.9790
Epoch 98/100
11/11 [==============================] - 1s 56ms/step - loss: 2.6393e-05 - accuracy: 1.0000 - val_loss: 0.1101 - val_accuracy: 0.9790
Epoch 99/100
11/11 [==============================] - 1s 50ms/step - loss: 2.5213e-05 - accuracy: 1.0000 - val_loss: 0.1103 - val_accuracy: 0.9792
Epoch 100/100
11/11 [==============================] - 1s 51ms/step - loss: 2.4920e-05 - accuracy: 1.0000 - val_loss: 0.1106 - val_accuracy: 0.9792

model.fit()는 History 객체를 반환하며, 이 것이 바로 fit()을 실행하면 반환되는 출력 Log이다.
출력되는 값은 model.compile을 할 때, metrics를 어떻게 지정하느냐에 따라 달라진다.
가장 일반적으로 사용되는 accuracy를 넣고, validation data를 넣으면, loss, accuracy, val_loss, val_acc가 출력되게 된다.
이는 매 에포크마다의 모델을 평가하는 점수라고 할 수 있으며, 그 뜻은 다음과 같다.

loss: 훈련 셋 손실 값
accuracy: 훈련 셋 정확도
val_loss: 검증 셋 손실 값
val_acc: 검증 셋 정확도

만약 검증 셋을 추가하지 않는다면 val_loss, val_acc가 출력되지 않으며, metrics에서 accuracy를 지정하지 않는다면, accuracy도 출력되지 않는다.

2. History 데이터를 다뤄보자.

# history를 출력시켜보자.
>>> history
<tensorflow.python.keras.callbacks.History at 0x20f001a1d00>

history를 출력시켜보면, <tensorflow.python.keras.callbacks.History at ~~~~~>와 같은 이상한 문자가 출력된다. Python에서는 이를 객체라 부르며, 해당 객체에 다양한 함수를 이용하여 학습과정에서 발생한 다양한 정보를 볼 수 있다.
예를 들어, history.epoch를 입력하면, 전체 epoch를 list로 출력하며, history.params 입력 시, 훈련 파라미터가 반환된다.
우리에게 필요한 것은 history.history로, 이 데이터는 한 에포크가 끝날 때마다 훈련 셋과 검증 셋을 평가한 지표들이 모여 있는 것이다.

# history.history는 각 지표들이 담겨있는 dictionary다
>>> type(history.history)
dict

# history.history의 생김새는 다음과 같다.
>>> history.history
{'loss': [1.1046106815338135,
  0.32885095477104187,
  0.2113472819328308,
  0.1513378769159317,
  0.11605359613895416,
  0.09276161342859268,
  
...

  0.9787999987602234,
  0.9789999723434448,
  0.9789999723434448,
  0.979200005531311,
  0.979200005531311]}

데이터를 파악하기 쉽도록 DataFrame의 형태로 바꿔서 보자.

history_DF = pd.DataFrame(history.history)
history_DF

적합한 epoch를 알기 위해 해당 데이터를 시각화해보자.
index는 epoch와 동일하다.

# 꺾은선 그래프를 그리자.
# 그래프의 크기와 선의 굵기를 설정해주었다.
history_DF.plot(figsize=(12, 8), linewidth=3)

# 교차선을 그린다.
plt.grid(True)

# 그래프를 꾸며주는 요소들
plt.legend(loc = "upper right", fontsize =15)
plt.title("Learning Curve", fontsize=30, pad = 30)
plt.xlabel('Epoch', fontsize = 20, loc = 'center', labelpad = 20)
plt.ylabel('Variable', fontsize = 20, rotation = 0, loc='center', labelpad = 40)

# 위 테두리 제거
ax=plt.gca()
ax.spines["right"].set_visible(False) # 오른쪽 테두리 제거
ax.spines["top"].set_visible(False) # 위 테두리 제거

시각화를 해서 4개 지표의 변화 추이를 보았다.
위 그래프의 결과를 해석해보면 다음과 같다.

훈련 셋과 검증 셋의 그래프가 비슷한 형태를 보였다. 이는 과적합(Overfitting)이 되지 않았다는 것을 의미한다.
훈련 셋, 검증 셋의 Accuracy는 1을 향해 상승하였다. loss는 0을 향해 하강하는 형태를 보였다. 이는 안정적으로 학습을 하고 있는 것을 의미한다.
훈련 셋, 검증 셋의 Accuracy와 loss는 epoch 20부터 수렴하기 시작했다.
검증 셋의 loss는 epoch가 20을 넘는 순간부터 소폭 증가하는 형태를 보였다.
검증 셋의 손실 값이 최저값을 약 epoch 20에서 달성하였으므로, 모델이 완전히 수렴하였다고 할 수 있다.

기존에 epochs을 100으로 설정하였으나, loss와 accuracy가 수렴한 지점을 볼 때, 이는 과하게 큰 값임을 알 수 있다. epochs를 30으로 줄여서 다시 학습을 해보도록 하자.
epoch가 불필요하게 큰 경우, 리소스의 낭비가 발생하기도 하지만, 과적합(Overfitting)이 될 위험이 있으므로, 적합한 epoch에서 학습을 해주는 것이 좋다.
epoch가 커지면 커질수록 훈련 셋의 성능은 검증 셋의 성능보다 높게 나온다. 검증 셋의 손실(var_loss)의 감소가 아직 이루어지고 있는 상태라면, 모델이 완전히 수렴되지 않은 상태라 할 수 있으므로, 검증 셋 손실의 감소가 더 이상 이루어지지 않을 때 까진 학습을 해야 한다.

epochs를 30으로 하여 다시 학습해보자.

history = model.fit(train_images, train_labels,
                    epochs=30,
                    batch_size=5000,
                    validation_data=(valid_images, valid_labels))

history_DF = pd.DataFrame(history.history)

# 꺾은선 그래프를 그리자.
# 그래프의 크기와 선의 굵기를 설정해주었다.
history_DF.plot(figsize=(12, 8), linewidth=3)

# 교차선을 그린다.
plt.grid(True)

plt.legend(loc = "upper right", fontsize =15)

plt.title("Learning Curve", fontsize=30, pad = 30)
plt.xlabel('Epoch', fontsize = 20, loc = 'center', labelpad = 20)
plt.ylabel('Variable', fontsize = 20, rotation = 0, loc='center', labelpad = 40)

# 위 테두리 제거
ax=plt.gca()
ax.spines["right"].set_visible(False) # 오른쪽 테두리 제거
ax.spines["top"].set_visible(False) # 위 테두리 제거

위 그래프를 보면 검증 셋이 연습 셋 보다 더 빠르게 0과 1로 다가가는 것으로 오해할 수 있으나, 훈련 셋의 지표는 epoch 도중에 계산되고, 검증 셋의 지표는 epoch 종료 후 계산되므로, 훈련 곡선을 왼쪽으로 소폭(에포크의 절반만큼) 이동시켜야 한다.
혹시나 해서 하는 말이지만, 모델이 생성된 후에 다시 학습을 하려면, 커널을 재시작해서 모델의 파라미터를 초기화시키고 학습해야 한다. Tensorflow는 이미 학습이 되어 파라미터가 생긴 모델을 재학습 시키면, 기존의 파라미터를 감안하여 학습을 하게 된다.

[참고 서적]

지금까지 모델 학습 과정에서 발생한 history 객체를 이용해서, 학습 셋과 검증 셋의 지표들을 시각화하고, 과적합이 발생하였는지, 적합한 epochs이 얼마인지 탐색해보았다.

간단하게 검증 셋과 학습 셋의 그래프가 비슷한 경향을 보이면 과적합이 일어나지 않고 있다는 것을 의미하며, 0과 1에 수렴하지 못한다면, 하이퍼 파라미터가 주어진 데이터셋에 맞지 않다는 것을 의미한다. 또한 epochs가 수렴 이후에도 지속되는 경우, 연습 셋에 과적합 될 수 있으므로, 적당한 epochs를 설정하는 것이 중요하다.

그러나, 꼭 위 방법처럼 epoch를 갱신해서 다시 학습을 해줘야 하는 것은 아니다. 다음 포스트에서는 epoch가 아직 남았더라도, 조건을 만족하면 알아서 학습을 멈추는 조기 종료에 대해 알아보도록 하겠다.

Tensorflow-3.5. 이미지 분류 모델(5)-모델 학습

만년필잉크 — Wed, 17 Feb 2021 11:07:52 +0900

이전 포스트까지 모델 컴파일에 대해 알아보았다. 이번 포스트에서는 모델을 학습에 대해 자세히 알아보도록 하자.

모델 학습과 학습 과정 확인

0. 이전 코드 정리

# Import module
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras.layers import (Dense, BatchNormalization, Dropout, Flatten)
from tensorflow.keras.datasets.mnist import load_data

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

# Dataset 준비
(train_images, train_labels), (test_images, test_labels)= load_data()

# 무작위로 샘플 추출
np.random.seed(1234)
index_list = np.arange(0, len(train_labels))
valid_index = np.random.choice(index_list, size = 5000, replace = False)

# 검증셋 추출
valid_images = train_images[valid_index]
valid_labels = train_labels[valid_index]

# 학습셋에서 검증셋 제외
train_index = set(index_list) - set(valid_index)
train_images = train_images[list(train_index)]
train_labels = train_labels[list(train_index)]

# min-max scaling
min_key = np.min(train_images)
max_key = np.max(train_images)

train_images = (train_images - min_key)/(max_key - min_key)
valid_images = (valid_images - min_key)/(max_key - min_key)
test_images = (test_images - min_key)/(max_key - min_key)

# 모델 생성
model = keras.models.Sequential()
model.add(keras.layers.Flatten(input_shape=[28, 28], name="Flatten"))
model.add(Dense(300, activation="relu", name="Hidden1"))
model.add(Dense(200, activation="relu", name="Hidden2"))
model.add(Dense(100, activation="relu", name="Hidden3"))
model.add(Dense(10, activation="softmax", name="Output"))

# 모델 컴파일
opt = keras.optimizers.Adam(learning_rate=0.005)
model.compile(optimizer = opt,
              loss = "sparse_categorical_crossentropy",
              metrics = ["accuracy"])

1. 모델 학습

# 모델 학습하기
history = model.fit(train_images, train_labels,
                    epochs=100,
                    batch_size = 5000,
                    validation_data=(valid_images, valid_labels))

Epoch 1/100
11/11 [==============================] - 2s 185ms/step - loss: 1.5537 - accuracy: 0.4795 - val_loss: 0.4806 - val_accuracy: 0.8638
Epoch 2/100
11/11 [==============================] - 1s 52ms/step - loss: 0.3852 - accuracy: 0.8864 - val_loss: 0.2727 - val_accuracy: 0.9204
Epoch 3/100
11/11 [==============================] - 1s 53ms/step - loss: 0.2276 - accuracy: 0.9327 - val_loss: 0.1879 - val_accuracy: 0.9406
Epoch 4/100
11/11 [==============================] - 1s 53ms/step - loss: 0.1617 - accuracy: 0.9522 - val_loss: 0.1460 - val_accuracy: 0.9558
Epoch 5/100
11/11 [==============================] - 1s 52ms/step - loss: 0.1213 - accuracy: 0.9650 - val_loss: 0.1222 - val_accuracy: 0.9618

...

Epoch 96/100
11/11 [==============================] - 1s 54ms/step - loss: 2.8528e-05 - accuracy: 1.0000 - val_loss: 0.1078 - val_accuracy: 0.9804
Epoch 97/100
11/11 [==============================] - 1s 59ms/step - loss: 2.9069e-05 - accuracy: 1.0000 - val_loss: 0.1080 - val_accuracy: 0.9806
Epoch 98/100
11/11 [==============================] - 1s 56ms/step - loss: 2.7108e-05 - accuracy: 1.0000 - val_loss: 0.1082 - val_accuracy: 0.9806
Epoch 99/100
11/11 [==============================] - 1s 51ms/step - loss: 2.8243e-05 - accuracy: 1.0000 - val_loss: 0.1086 - val_accuracy: 0.9806
Epoch 100/100
11/11 [==============================] - 1s 50ms/step - loss: 2.6565e-05 - accuracy: 1.0000 - val_loss: 0.1086 - val_accuracy: 0.9804

이전 포스팅까지는 model.fit(train_set, train_label, epochs)만 설정하였었으나, 이번 포스팅에서는 model.fit(train_set, train_label, epochs, batch_size, validation_data)로 처음 보는 인자들이 여럿 등장한 것을 볼 수 있다.
train_set, train_label, epochs는 여러 번 본 인자이므로 넘어가고, batch_size와 validation_data를 위주로 설명해보겠다.
아직 epochs에 대한 개념이 헷갈린다면 다음 포스팅을 참고하기 바란다.
참고: "머신러닝-6.2. 최적화(3)-학습단위(Epoch, Batch size, Iteration)

2. Batch size

model.fit() 함수 안에 batch_size라는 인자가 추가된 것을 볼 수 있다.
batch_size는 전체 데이터셋을 한 번에 학습시키자니, 데이터가 너무 크기 때문에 메모리 과부하와 속도 저하 문제가 발생하므로, 데이터를 Batch size만큼 쪼개서 학습을 시키는 것을 의미한다.
학습 단위에 대한 보다 자세한 설명은 다음 포스팅을 참고하기 바란다.
Batch size는 전체 데이터셋을 Batch size로 나눴을 때, 나머지가 생기지 않은 크기로 만드는 것이 좋다.
Batch size를 너무 크게 하면, 메모리 과부하가 발생하기 쉬우나, 더 많은 데이터를 보고 파라미터를 결정하므로 학습이 안정적으로 진행된다.
Batch size를 너무 작게 하면, 자주 파라미터 갱신이 발생하므로 학습이 불안정해진다.
Batch size를 얼마나 잡느냐에 대해선 정답이 없다고 할 수 있는데, 어떤 사람들은 자신의 머신이 가진 메모리를 넘지 않는 선에서 Batch size를 최대로 잡는 것이 좋다고 하고, 또 다른 사람은 32보다 큰 미니배치를 사용해선 절대 안된다고도 했다.
양쪽 다 주장이 꽤 탄탄하므로, 미니 배치를 크게도 해보고 작게도 해보며, 결과를 비교해보도록 하자.

2.1. Batch size의 효과

Batch size는 학습에 걸리는 시간과 학습에 소모되는 메모리에 큰 영향을 미친다.
얼마나 차이가 나는지 확인하기 위해 Batch size를 설정하지 않은 학습과 설정하지 않은 학습을 비교해보도록 하자.

A. Batch size를 지정하지 않는 경우

from time import time
start = time()

history = model.fit(train_images, train_labels,
                    epochs=100,
                    validation_data=(valid_images, valid_labels))
...

>>> print("코드 동작 시간: {} minutes".format(round((time() - start)/60, 2)))
코드 동작 시간: 6.39 minutes

time 모듈의 time() 함수는 1970년 1월 1일 0시 0분 0초 이후 경과한 시간을 초 단위로 반환하는 함수로, time함수의 차를 이용해서, 특정 구간에서 소모된 시간을 알 수 있다.
Batch size를 사용하지 않고, 모든 데이터를 한 번에 학습시키는 경우, 6.39분이 소모된 것을 볼 수 있다.

B. Batch size를 지정한 경우

start = time()

history = model.fit(train_images, train_labels,
                    epochs=100,
                    batch_size=5000,
                    validation_data=(valid_images, valid_labels))
...

>>> print("코드 동작 시간: {} minutes".format(round((time.time() - start)/60, 2)))
코드 동작 시간: 1.0 minutes

Batch size를 사용하자, 학습에 소모된 시간이 1.0분으로 6배 이상 감소한 것을 볼 수 있다.
이번에 학습에 사용한 MNIST는 그다지 큰 데이터도 아님에도 소모 시간 차이가 이렇게 크게 발생한 것을 볼 때, 이보다 더 큰 데이터를 다루게 되는 실제 상황에서 Batch size 지정은 필수임을 알 수 있다.

3. validation data

이전 학습에서 validation_data를 지정하지 않았듯, 검증 셋을 지정하지 않아도 학습을 하는 데는 문제가 없지만, 검증 셋이 존재한다면, 매 학습 때마다 모델을 평가하여, 최적의 모델을 만들어내는데 큰 도움이 된다.
검증 셋에 대해 헷갈리는 분을 위해 이전 포스트 링크를 걸어놓도록 하겠다.
(참고: "Tensorflow-3.2. 이미지 분류 모델(2)-검증 셋(Validation set)")
validation data는 위 방법처럼 검증 셋을 미리 뽑고, 학습을 진행하는 방법도 있지만 자동으로 검증 셋을 뽑아놓는 방법도 존재한다.
model.fit() 함수의 파라미터에 validation_split이라는 인자가 존재하는데, 이는 float으로 지정할 수 있으며, 데이터를 섞기(Shuffle) 전에 지정한 비율만큼의 데이터를 검증 셋으로 사용한다.
그러나, 참고 포스팅에서 보듯 검증 셋을 대표성 있게 추출하는 것은 매우 중요하므로, 사전에 검증 셋을 미리 추출하는 것을 추천한다.
이밖에도 validation_steps, validation_batch_size, validation_freq와 같은 검증 셋 관련 파라미터들이 더 존재하지만, 이들에 대해서는 추후 다루도록 하겠다.

지금까지 모델의 학습(Fit)에 대해 알아보았다. 이전에 fit()에 사용했던 파라미터들은 학습을 위해 필요한 최소한의 파라미터들이었다면, 이번에 사용한 파라미터들은 가장 일반적으로 사용되는 파라미터들이다.

fit() 함수는 이밖에도 샘플별 가중치 조정(sample_weight)이나, 특정 클래스에 대한 가중치 조정(class_weight)과 같은 다양한 기능들을 더 가지고 있다. 그러나, 이들까지 모두 다루기는 쉽지 않고, 이번에 다룬 내용만 알더라도 Tensorflow를 적당히 다루는데 지장이 없으므로, 여기까지 학습을 하고, 나중에 필요하다면 더 자세히 다뤄보도록 하겠다.

다음 포스트에선 학습 과정에서 나온 Log들을 분석하는 History 객체의 사용법에 대해 학습해보도록 하겠다.

Pandas-데이터 프레임 만들기

만년필잉크 — Tue, 16 Feb 2021 22:26:42 +0900

이전 포스트에서 판다스(Pandas)가 무엇인지 간단한 소개와 판다스의 대표적인 데이터 타입인 데이터 프레임(DataFrame)과 시리즈(Series)를 살펴보았다.

이번 포스트는 판다스의 상징인 데이터 프레임을 만드는 방법에 대해 알아보도록 하겠다.

데이터 프레임 만들기

1. 판다스 가져오기

판다스를 사용하기 앞서 먼저 판다스를 설치하고 판다스를 사용하겠다고 선언해보자.
Python 모듈 설치는 크게 Anaconda를 사용하여 일반적으로 사용하는 Pandas를 포함한 각종 라이브러리를 한 번에 다운로드하는 방법이 있고, pip를 이용해서 다운로드하는 방법이 있다.
해당 방법을 서술하기엔 그 내용이 꽤 길고 헷갈리기 쉽기 때문에 Pandas를 비롯한 각종 라이브러리를 설치하는 방법이 적힌 이전 포스트로 가는 참조를 걸어놓겠다.
참고 1 - 라이브러리 설치 방법: "Python 필요한 모듈들을 설치해보자"
참고 2 - Anaconda 설치 방법: "Python 파이썬과 아나콘다"
참고 3 - 오프라인 환경에서 라이브러리 설치 방법: "Python 오프라인 환경에서 파이썬 패키지를 설치해보자"
위 방법대로 Pandas를 정상적으로 설치하였다는 전제하에 Pandas에 대해 학습해보도록 하겠다.

# Import module
import pandas as pd

Python에서 #은 주석을 만드는 특수 문자로 코드(Syntax) 앞에 입력 시, 해당 행의 명령어들을 주석 처리한다.
import pandas as pd는 문자 그대로 "import(수입하다) pandas as(처럼) pd"로, pandas를 가지고 오는데 pd라는 문자로 가지고 온다는 의미이다.
Python은 특정 라이브러리 내 함수를 사용하려면 "라이브러리.함수()" 이런 식으로 코드를 짜게 되는데, pandas는 제법 긴 단어이므로 pd라는 간결한 단어로 라이브러리를 의미하겠다는 소리다.
일반적으로 pandas는 pd라 사용하니 pd로 쓰도록 하자.

2. 데이터 프레임 함수 설명

pandas에서 제공하는 DataFrame API에서 DataFrame이 가지고 있는 파라미터(Parameter)는 다음과 같다.
pd.DataFrame(data=None, index=None, columns=None, dtype=None, copy=False)
data: list나 numpy에서 제공하는 array, dictionary 등을 받는다. 간단하게 생각해서 행렬이나 벡터를 Data로 사용할 수 있다고 생각하면 된다.
index: 이전 포스트에서 말했듯, pandas의 데이터 프레임이나 시리즈의 특징은 index를 갖는다는 것이다. 그리고 사용자가 원하는 index를 부여할 수 있다. 지정하지 않은 경우, 자동으로 range(0, len(data))에 해당하는 index가 생성된다.
columns: 열, 즉 변수의 이름이다.
dtype: DataFrame 안에 들어갈 데이터의 type을 결정한다. DataFrame의 장점은 변수 별로 다른 dtype이 들어갈 수 있는 것이므로, 특수한 경우가 아닌 이상 지정 안 한다.
copy: DataFrame의 특징 중 하나인, Data의 종속성에 대한 부분인데, 이는 나중에 다루도록 하겠다. 크게 신경 쓰지 않아도 된다.

3. 행렬(2-d array)을 사용해서 데이터 프레임 만들기

2-d array는 2차원 배열을 의미하며, 우리에게 친숙한 행렬이 2-d array다.
머신러닝 라이브러리인 sklearn에서 제공하는 붓꽃 데이터를 이용해서 행렬을 보도록 하자.

import numpy as np
from sklearn.datasets import load_iris

numpy는 선형 대수학에 특화된 라이브러리로 다른 포스팅에서 자세히 다룰 테니 일단 넘어가자(당장 쓰지 않더라도 Pandas를 쓸 때는 꼭 numpy도 import 해놓는 습관을 들여놓자. 나중에 아주 많이 쓰게 될 것이다.)
from sklearn.datasets import load_iris는 sklearn의 dataset이라는 모듈에서 load_iris라는 함수만 가져오겠다는 뜻이다. 특정 라이브러리에서 한, 두 개의 함수만 필요한 경우에 사용하는 방법이다.

>>> iris = load_iris()
>>> iris
{'data': array([[5.1, 3.5, 1.4, 0.2],
        [4.9, 3. , 1.4, 0.2],
        [4.7, 3.2, 1.3, 0.2],
        [4.6, 3.1, 1.5, 0.2],
        [5. , 3.6, 1.4, 0.2],
        [5.4, 3.9, 1.7, 0.4],
        
...

lustering system finds 3 classes in the data.\n   - Many, many more ...',
 'feature_names': ['sepal length (cm)',
  'sepal width (cm)',
  'petal length (cm)',
  'petal width (cm)'],
 'filename': 'C:\\Users\\gooop\\anaconda3\\lib\\site-packages\\sklearn\\datasets\\data\\iris.csv'}

해당 블로그에서 >>> 는 코드 실행을 의미하며, 앞에 >>>가 없는 것은 출력된 결과를 의미한다. 한 셀 안에 >>>가 없는 경우, 출력된 결과가 없기 때문에 >>>를 쓰지 않은 것이다.
load_iris()를 실행 시, dictionary가 출력된다. dictionary는 여러 종류의 데이터를 key:value로 담을 수 있는 사전이다.
dictionary를 key로 조회 시, 원하는 value만 볼 수 있다.

# iris data에 있는 key를 보자
>>> iris.keys()
dict_keys(['data', 'target', 'frame', 'target_names', 'DESCR', 'feature_names', 'filename'])

iris 데이터가 가지고 있는 key를 보면, data, target, frame 등 여러 key가 존재하는 것을 알 수 있다.
여기서 "data"는 iris data를 의미한다.
"feature_names"는 변수의 이름이다.

>>> iris["data"]
array([[5.1, 3.5, 1.4, 0.2],
       [4.9, 3. , 1.4, 0.2],
       [4.7, 3.2, 1.3, 0.2],
       [4.6, 3.1, 1.5, 0.2],
       [5. , 3.6, 1.4, 0.2],
       
...

       [6.7, 3. , 5.2, 2.3],
       [6.3, 2.5, 5. , 1.9],
       [6.5, 3. , 5.2, 2. ],
       [6.2, 3.4, 5.4, 2.3],
       [5.9, 3. , 5.1, 1.8]])

데이터가 매우 크므로 중간을 생략하였다. 위 데이터 같이 행과 열로 2개의 차원(dimension)이 존재하는 데이터를 2차원 배열 2-d array라고 한다.

>>> iris["feature_names"]
['sepal length (cm)',
 'sepal width (cm)',
 'petal length (cm)',
 'petal width (cm)']

칼럼 이름은 list로 출력되었다.
위 두 데이터를 사용해서 데이터 프레임을 생성해보자.

>>> iris_DF = pd.DataFrame(data=iris["data"], columns=iris["feature_names"])

DataFrame은 주피터 노트북 기준 한 번에 60개의 행이 조회되며, 아래에 있는 150 rows x 4 columns는 150개의 행과 4개의 열을 가진 데이터라는 것을 의미한다.

>>> iris_DF.values
array([[5.1, 3.5, 1.4, 0.2],
       [4.9, 3. , 1.4, 0.2],
       [4.7, 3.2, 1.3, 0.2],
       [4.6, 3.1, 1.5, 0.2],
       [5. , 3.6, 1.4, 0.2],
       
...

       [6.7, 3. , 5.2, 2.3],
       [6.3, 2.5, 5. , 1.9],
       [6.5, 3. , 5.2, 2. ],
       [6.2, 3.4, 5.4, 2.3],
       [5.9, 3. , 5.1, 1.8]])

DataFrame.values 함수를 사용하면, DataFrame을 2-d array로 돌릴 수 있다. 꽤 중요한 기능이니 꼭 숙지하도록 하자.

4. list를 사용해서 데이터 프레임 만들기

이번엔 list를 이용해서 데이터 프레임을 만들어보자.
list는 Python에서 대표적인 Data를 담는 그릇이다.

>>> name_list = ["박명수", "유재석", "노홍철", "길", "정준하", "정형돈", "하하"]
>>> math_list = [65, 95, 70, 80, 100, 85, 60]
>>> english_list = [75, 80, 85, 90, 65, 75, 100]
>>> exam = pd.DataFrame({"name":name_list, "math":math_list, "english":english_list})
>>> exam

데이터 프레임은 위 결과처럼 각 변수(열) 별로 다른 dtype이 들어갈 수 있다.

5. Dictionary를 사용해서 데이터 프레임 만들기

Dictionary는 모든 형태의 데이터를 Key:value의 형태로 담을 수 있는 데이터 타입이다.
Dictionary의 형태는 조금만 편집해서 바로 Json으로 사용할 수 있을 정도로 Json과 굉장히 유사하다.
Dictionary의 value들이 모두 list 또는 array이고, 그 길이가 동일하다면, DataFrame으로 만들 수 있다.
(길이가 다르다면, 오류가 뜬다)

>>> Raw_dict = {
>>>     "name":["박명수", "유재석", "노홍철", "길", "정준하", "정형돈", "하하"],
>>>             "math":[65, 95, 70, 80, 100, 85, 60],
>>>             "english":[75, 80, 85, 90, 65, 75, 100],
>>>             "class":[1, 2, 1, 2, 2, 2, 1]
>>> }

>>> Raw_dict

{'name': ['박명수', '유재석', '노홍철', '길', '정준하', '정형돈', '하하'],
 'math': [65, 95, 70, 80, 100, 85, 60],
 'english': [75, 80, 85, 90, 65, 75, 100],
 'class': [1, 2, 1, 2, 2, 2, 1]}

DF = pd.DataFrame(Raw_dict)
DF

Dictionary는 key와 value로 이루어져 있으므로, 별도의 컬럼 이름을 지정해주지 않아도 DataFrame으로 쉽게 전환이 가능하다.
반대로 DataFrame을 Dictionary로 변환하는 것 역시 굉장히 간단하다.

>>> DF.to_dict()
{'name': {0: '박명수', 1: '유재석', 2: '노홍철', 3: '길', 4: '정준하', 5: '정형돈', 6: '하하'},
 'math': {0: 65, 1: 95, 2: 70, 3: 80, 4: 100, 5: 85, 6: 60},
 'english': {0: 75, 1: 80, 2: 85, 3: 90, 4: 65, 5: 75, 6: 100},
 'class': {0: 1, 1: 2, 2: 1, 3: 2, 4: 2, 5: 2, 6: 1}}

DataFrame.to_dict(): 해당 함수를 사용하면 DataFrame을 dictionary로 바로 전환할 수 있다.

지금까지 DataFrame을 만드는 방법에 대해 알아보았다. 다음 포스트에서는 데이터 프레임의 부위별 이름에 대해 알아보도록 하겠다.