경기도권의 자율주행 관련 스타트업 회사였다. 잡코리아로 채용 진행을 하였고,

서류전형 -> 코딩테스트 -> 1차면접 -> 2차면접

의 전형으로 진행되었다.

서류전형

잡코리아의 무지성 서류 지원 중 한 곳이였다. 다만 인상깊었던 점은 설립된지 4~5년된 스타트업이였지만 돈을 상당히 많이 준다는.. 그래서 이력서와 포트폴리오 2가지의 서류를 첨부하여 지원을 했다.

코딩테스트

스타트업이였지만, 프로그래머스 환경에서 시험을 치뤘다. 총 3문제였고, 다른 기업의 시험과는 다르게 문제마다 점수를 바로 확인할 수 있었다.

1차 면접

면접관 3, 지원자 4의 대면 면접으로 1시간 30분동안 이루어졌다. 사실 이 면접은 준비 기간이 너무 짧았기 때문에 자기소개, 지원동기, 직무역량강점 이 3개만 준비해갔던 것 같다.

1. 자기소개
2. 프로젝트 가장 인상깊은 프로젝트와, 그것을 하면서 무엇이 힘들었는지
3. tdd가 무엇인지, 그리고 프로젝트 하면서 적용해본 적이 있는지.
4. 실력향상을 위해, 어떻게 학습을 하는지.
5. 학부수업들으면서 가장 흥미로웠던 수업, 가장 재미없었던 수업, 그리고 가장 도움이 됐던 수업
6. 만약 코드 컨벤션 맞출때, 팀원과 스타일이 다르다면 어떻게 하는지?
7. 유닛테스트가 뭔지 설명.
8. 통합테스트와 유닛테스트의 차이를 설명.
9. 서비스(MVC)가 무엇인가?
10. 궁금한점 + 마지막으로 할말

질문은 이렇게 물어봤다. 모두 공통 질문이였고, 답변에 대한 꼬리질문이 굉장히 디테일하게 들어왔다.

기억나는 것 중 하나는 어떤 분이 캐시얘기를 했는데 캐시 히트와 캐시 미스일때 각각 어떻게 처리했는지를 굉장히 자세하게 물어보셨다. 원하는 답변이 나오지않자 계속해서 집요하게 파고드셨다.

아마 해당 질문에서 가장 중요했던 것은 총 2개라 생각한다.

1. 개발에 있어 기본 지식이 있는가 하는가.
2. 관상

지금까지 봐왔던 면접과는 너무 다른 스타일로 진행이 되었던 것 같다. 이력서와 포트폴리오를 하나도 참고를 안했던 것 같고 그냥 이 회사에서 원하는 인재상이 있던 것 같은데 그게 무엇이였는지 도저히 감을 못잡겠단 것이였다.

나의 프로젝트에서 이 기술을 왜 썼는지, 어려운 점을 어떻게 타개했는지를 물어봐주었으면 좋았었을텐데 단순히 인성쪽? 으로만 물어봤던 것 같아 매우 아쉬웠다. 내 역량을 절반도 못보여준 것 같아 굉장히 아쉽고, 사실 준비도 안했고, 면접 분위기가 좋지 않아서 별 기대도 안했지만 1차 면접 합격 연락이 왔다.

엥 진짜 관상보고 뽑나

2차면접

1차 면접때는 정말 준비를 안해가서, 이번에는 직무와 인성 분야 두 개다 준비를 정말 열심히 해갔다. 단지 내가 예상한 질문들이 단 하나도 나오지 않아 하나도 사용을 못했다는

1차면접과 달리 2차면접은 다대일 면접으로 진행이 되었다. 진짜 이번 2차면접은 정말 뭘 대체 물어보고싶은건지, 어떤 것을 원하는지 감이 1도 안잡혔다..

1. OO대학교 왜 가셨나요? 답 못함.. 한번도 이거에 대해 생각을 해본 적이 없다. 아마 이것은 서울대학교 학생들도 답을 하지 못할 것이라 생각한다. 성적 맞춰서 가는 사람들이 99%일텐데

2. OO대학교만의 장점을 알려주세요 진짜 대체 왜물어보냐고 학교가 평지다.. 국립대학법인이라 연구비가 짱짱하다.. 이런 것만 말했다.

3. 대학교 다니면서 4년간 기숙사 살았다고 말씀하셨는데 몇인실이였나요?? 아! 룸메이트와 잘 지냈냐고 물어보려 하는구나! 트러블이 없었는지 물어보는구나!

   나: 2년간 4인실, 2년간 2인실 살았습니다~ 면접관: OO대학교엔 모집요강에는 4인실이 없는데요? 나: 아 7년전이라 아마 지금은 없어졌나 보네요~ 면접관: 여기서 끝나고 다른 질문함.

4. 팀원과 협력을 통해 문제를 해결한 경험을 말씀해주세요. 드디어 질문다운 질문..!! 이것은 어찌어찌 잘 말햇다.

5. 개발자에게 가장 필요한 역량이 무엇이라 생각하나요? 내가 준비한 질문이 드디어 나왔구나.

   개발자에게 가장 필요한 역량은 문제해결역량이라 생각합니다. 왜냐하면 개발 과정에서 수많은 에러 혹은 문제가 발생할텐데, 이 문제를 해결하기에 급급한 것이 아닌, 근본적인 원인을 분석하고 이에 맞는 해결책을 통해 ~ 하는 게 중요합니다. 실제로 저도 ~ 문제를 겪고 ~ .

??: 그게 중요한 역량이라고 한다면 신입사원보단 경력사원만 뽑는게 맞지 않겠어요??

당황해하니깐, 그래도 좀 힌트를 주셨다.

면접관: 저희 입장에서 경력보단 신입 개발자를 뽑는 이유가 있을거에요. 신입 개발자를 뽑는 이유가 뭐라고 생각하세요? 나: 연봉이 저렴하니깐. 잠재력이라 생각합니다! 저같은 경우엔, 다양한 개발환경에서 빠르게 적응해 실질적인 성과를 이끈 경험이 있습니다. 이처럼, 저희 신입개발자는 백지이므로, 회사에 빠르게 적응하여 성과를 내는 "잠재력"이 있다 생각합니다. 지금 쓰면서 보니깐 이상하네..

결국 면접관이 원하는 답변을 하지 못했다. 나중에 여쭤봤을때, 기본적인 CS지식, 그리고 이를 활용하는 능력이 중요하다 생각해요.

이것도 신입개발자보단 경력개발자 역량 아닌가..

6. 삼성청년SW아카데미를 수료하셨는데, 여기서 배운 것, 얻은 것이 있을까요??

답변: 우선, 다양한 직무의 사람들과 함께 하는 "협업 능력"에 대해 키울 수 있었습니다! 저는 ~

여기에서 면접관님이 답변을 끊으셨다.

면접관: 아시다시피, 실무에서의 협업과 교육 목적의 싸피에서의 협업 능력은 상당히 다르다 생각해요. 사실 Jira와 Git 등 이 회사에서 사용하지 않는다면 도루묵 아닌가요?

말고도 질문들은 이랬다.

• 스트레스를 해소하는 취미가 있는지.
• 당신이 싸피에서 배운 기술스택들은 우리 회사에서 전혀 사용하지 않는다. 어떻게 생각하는지?
• 일을 할 때, 도전하여 일을 벌이는 스타일인지 혹은 계획적으로 접근하는 스타일인지.
• 회사에 대해 궁금한 점.

그냥 전체적으로 분위기가 좋지 않았던 것 같다.열심히 준비했지만, 준비한 질문에 대해서는 하나도 나오지 않았고 나름 회사 자체에서 원하는 인재상이 있는 것 같고, 질문에도 의도가 있던 것 같지만 그 자리에서 의도를 파악하지 못했던 것이 패착이였던 것 같다. 사실 아직도 이런 질문들의 의도를 모르겠음.

1. 회사의 성향을 파악하여 질문의 의도를 파악하자.
2. 말할 때, 좀 두서있게 정리해서 말하자.
3. 면접은 운빨 + 관상

아직 결과는 나오지 않았다. 가고싶은 회사라 하늘에 기도해야겠다.

CPU

CPU(Central Processing Unit)은 인터럽트에 의해 단순히 메모리에 존재하는 명령어를 해석하여 실시하는 일꾼이다. CPU의 구성은 다음과 같다.

• 제어장치(Control Unit) 프로세스 조작을 지시하는 장치로, I/O장치 간 통신을 제어하고 명령어들을 읽고 해석하며 데이터 처리를 위한 순서를 결정한다.

• 레지스터(Register) 레지스터는 CPU안에 있는 매우 빠른 임시기억장치이다. CPU는 자체적으로 데이터를 저장할 방법이 없어, 레지스터를 거쳐 데이터를 전달한다. CPU와 직접 연결되어있어, 속도가 매우 빠르다.
• 산술논리연산장치(Arithmetic Logic Unit) 덧셈, 뺄셈 같은 두 숫자의 산술 연산과 배타적 논리합, 논리 곱과 같은 논리 연산을 계산하는 디지털 회로이다.

CPU의 연산 처리 과정

1. 제어장치가 계산할 값을 메모리에 로드한다 그리고 레지스터에도 로드한다
2. 제어장치가 레지스터에 있는 값을 계산하라고 산술논리연산장치에 명령한다.
3. 제어장치가 계산된 값을 다시 레지스터에 저장하고, 레지스터에서 해당 값을 다시 메모리에 저장한다.

인터럽트(Interrupt)

인터럽트는 CPU를 잠깐 정지시키는 것이다. 키보드, 마우스 등 I/O 디바이스로 인한 인터럽트, 0을 숫자로 나누는 산술연산에서의 인터럽트, 프로세스 오류 등으로 발생한다.

컴퓨터에 문제가 발생하거나, 중요한 일이 생기면 즉시 처리해야한다. 이 때 인터럽트는 컴퓨터가 현재 하고 있는 일을 잠시 멈추고 해당 일을 해결하는데 도움을 주는 역할을 한다.

인터럽트가 발생되면 인터럽트 핸들러 함수가 모여있는 인터럽트 벡터로 가서 인터럽트 핸들러 함수를 실행시킨다. 인터럽트는 총 2가지로 나뉜다.

• 하드웨어 인터럽트 하드웨어 인터럽트는 키보드를 연결하거나, 마우스를 연결할 때 I/O 디바이스에서 발생하는 인터럽트를 의미한다.

• 소프트웨어 인터럽트 소프트웨어 인터럽트는 트랩이라고도 한다. 프로세스 오류 등으로 프로세스가 시스템콜을 호출할 때 발생한다.

DMA 컨트롤러

DMA(Direct Memory Access) 컨트롤러는 I/O 디바이스가 메모리에 직접 접근할 수 있도록 도와주는 장치를 의미한다.

CPU에만 너무 많은 인터럽트 요청이 들어오기 때문에 CPU 부하를 막아주며, CPU의 일을 부담하는 보조 일꾼이라 생각하면 된다.

메모리

메모리(Memory)는 데이터나 상태, 명령어 등을 기록하는 장치를 말하며 보통 RAM(Random Access Memory)를 일컬어 메모리라고도 한다.

CPU는 계산을 담당하고, 메모리는 기억을 담당한다.

운영체제 (OS, Opreating System)은 사용자가 컴퓨터를 쉽게 다루게 해주는 인터페이스입니다.

즉, 운영체제(OS)에서의 인터페이스는 컴퓨터 사용자와 컴퓨터 하드웨어 사이의 매개체 역할을 합니다. 즉, 사용자가 복잡한 컴퓨터 명령어를 직접 입력하지 않고도 마우스 클릭, 키보드 입력 등 직관적인 방식으로 컴퓨터를 조작할 수 있도록 연결해 주는 중간다리라고 할 수 있습니다.

운영체제의 구조

GUI, 시스템콜, 커널, 드라이버 부분이 바로 운영체제를 지칭합니다. 참고로 GUI가 없고, CUI만 있는 리눅스 서버도 있습니다.

• GUI 사용자가 장치와 상호작용할 수 있도록 하는 사용자 인터페이스의 한 형태. 단순 명령어가 아닌 아이콘을 마우스로 클릭하는 단순한 동작으로 컴퓨터와 상호작용할 수 있도록 해준다.
• *드라이버 (Driver) * 컴퓨터와 하드웨어를 연결하는 다리: 컴퓨터와 키보드, 마우스, 프린터 같은 하드웨어 기기들은 서로 다른 언어를 사용하는데. 드라이버는 이 두 가지 언어를 번역해 주는 역할을 하여 컴퓨터가 하드웨어를 제대로 인식하고 사용할 수 있도록 해주는 소프트웨어입니다. 예시: 새 프린터를 구매하면 드라이버를 설치해야 프린터를 사용할 수 있는 것처럼, 대부분의 하드웨어는 드라이버가 필요합니다.
• CUI (Character User Interface) 명령어를 입력해서 사용하는 방식: GUI와는 반대로, 텍스트로 된 명령어를 직접 입력하여 컴퓨터에게 명령을 내리는 방식입니다. 예시: DOS 창이나 리눅스 터미널에서 명령어를 입력하여 파일을 복사하거나 프로그램을 실행하는 것이 CUI의 예입니다.
• 커널(Kernel) 커널은 운영체제 중 항상 메모리에 올라가 있는 운영체제의 핵심 부분으로 컴퓨터의 모든 자원들(소프트웨어 + 하드웨어)을 관리하는 소프트웨어이다.

시스템콜(System Call)

시스템콜이란 운영 체제의 커널(Kernel)이 제공하는 서비스에 대해 유저의 프로그램이 운영체제의 서비스를 받기 위한 인터페이스입니다.

응용 프로그램이 무엇인가를 하고 싶을 때, 직접 하드웨어를 건드리지 못한다.그렇기 때문에 시스템 콜을 통해 커널에 접근해 작업을 한다.

ex) 유저 프로그램이 I/O 요청을 통해 파일을 읽기 위해 fs.readFile()이라는 함수가 실행되었을 때?

1. 파일을 읽기 위해 운영체제에 open()이라는 시스템콜(System Call)을 호출한다.
2. 운영체제는 시스템콜 요청을 받으면, 커널 모드로 전환된다.
3. 커널은 전달받은 파일 경로를 이용해, 파일 시스템에 접근하여 해당 파일을 찾는다.
4. 커널은 읽어온 파일을 유저 프로그램이 접근할 수 있는 버퍼로 복사한다.
5. 유저 프로그램은 커널로부터 받은 파일을 읽어올 수 있다.

modebit

시스템콜이 작동될 때, modebit을 통해 유저 모드와 커널 모드를 구분한다. modebit은 1 또는 0의 값을 가지는 Flag 변수이다. 만약 유저모드를 기반으로 카메라가 켜진다면, 사용자가 의도하지 않았음에도 공격자가 갑자기 카메라를 킬 수 있는 등의 위협때문에 카메라, 키보드 등 디바이스는 운영체제를 통해서만 제어할 수 있다.

1. 유저 프로그램이 카메라를 이용하려 할 때 => 시스템콜 호출
2. modebit을 1에서 0으로 바꾸어, 커널모드로 변경 후 카메라 자원을 이용한 로직 수행
3. modebit을 0에서 1로 바꾸어, 유저모드로 변경하고 이후 로직 실행

• 유저 모드 유저가 접근할 수 있는 영역을 제한적으로 두어, 컴퓨터 자원에 함부로 침범하지 못하는 모드

• 커널 모드 모든 컴퓨터 자원에 접근할 수 있는 모드

마이크로소프트에서 개발한 알고리즘으로, GoogleLeNet은 22개 층으로 구성됐지만, 7배 깊은 층, 152개를 사용하여 깊은 네트워크를 사용한 층을 갖는다.

단순히 네트워크 깊이만 깊어지면 성능이 좋아질까?

ResNet의 논문에는 56층의 네트워크가 20층의 네트워크보다 성능이 안좋은 것을 볼 수 있다.

Training 에서도, Test 에서도 성능이 좋지 않았기 때문에 우리는 이것이 Overfitting 때문이 아님을 알 수 있습니다.

무조건 네트워크가 깊다해서 성능이 좋아지는 것은 아니다. 그렇다면 어떻게 깊은 층을 구성하여 성능을 높였을까?

Residual block

위의 그림에서도 볼 수 있듯이, Plain Network가 단순히 Convolution 연산을 쌓는다면, ResNet은 Block이 쌓인 구조를 가지고 있고, Block 단위로(Residual Block이라고 부름) Parameter를 전달하기 전에 이전의 값을 더하는 방식을 취한다.

ResNet을 구성하는 Residual Block의 구조는 위와 같다. weight layer를 통과한 f(x)와 weight layer를 통과하지 않은 x의 합을 논문에서는 Residual Mapping이라고 한다.

Residual Block을 plain layer과 비교하여 설명하자면, plain layer는 동일한 연산 f(x)를 수행하고 난 뒤 Input x를 더해주지 않지만, residual block에서는 동일한 연산 f(x)를 수행하고 난 뒤 Input x를 더해준다.

즉, plain layer와는 다르게 residual block에는 skip connection이 존재한다. (그림의 곡선 화살표 부분 Skip connection은 하나의 layer의 output을 몇 개의 layer를 건너띄고 다음 layer의 input에 추가되는 것을 의미한다.)

skip connection을 사용하게 되면 각각의 layer가 작은 정보들을 추가적으로 학습하도록 한다.(= 각각의 layer가 배워야 하는 정보량을 축소시킴)

RDBMS가 Analytic SQL을 사용하게 됨으로써 다시 데이터 분석의 중심이 될 수 있던 기능이다. 기존 Group by 함수는 원본 데이터 집합의 레벨을 변경하여 적용함에 비해, Analytic SQL은 원본 데이터 집합의 레벨을 그대로 유지하면서 집계 함수를 적용함

• 일반 Aggregation Function은 원본 데이터의 레벨을 변경하여 적용
• Analytic SQL은 window를 사용하여 Row단위의 집합에 대한 연산이 가능하다.

Analytic SQL의 유형

원본 데이터의 레벨을 그대로 유지하면서 그룹핑 레벨에서 자유롭게 Window의 이동과 크기를 조절하면서 Analytic 수행.

순위 Analytic SQL

• 일반적인 순위: rank, dense_rank, row_number

• 0~1 사이 정규화 순위: cume_dist, percent_rank
• 분위: ntile

일반적인 순위

select a.empno, ename, job, sal 
    , rank() over(order by sal desc) as rank --rank
    , dense_rank() over(order by sal desc) as dense_rank --dense_rank
    , row_number() over (order by sal desc) as row_number from hr.emp a; --row_number

위의 코드는 partition을 정하지 않았기 때문에 전체 데이터에서 순위를 매긴다. 결과는 다음과 같다.

row_number는 모든 순위가 unique해야 하고, rank는 공통 부분을 제외한 갯수만큼 순위가 밀려나도록 계산. dense_rank는 공통 부분 바로 다음 순위로 계산한다.

select a.empno, ename, job, deptno, sal 
, rank() over(partition by deptno order by sal desc) as rank 
, dense_rank() over(partition by deptno order by sal desc) as dense_rank
, row_number() over (partition by deptno order by sal desc) as row_number from hr.emp a;

위의 코드는 deptno로 partition을 지정하였다. 그러면 deptno가 같은 데이터끼리 순위를 매기게 된다. 결과는 다음과 같다.

부서 별 가장 급여가 높은 직원 정보

--서브쿼리문 사용. row_number() 사용
select *
from ( 
select a.ename
        , a.deptno
        , b.dname
        , a.sal
        , row_number() over(partition by a.deptno order by a.sal desc) as sal_rank
from emp a 
    join dept b on a.deptno = b.deptno  ) as c 
    where sal_rank = 1

회사 내 커미션 높은 순위. (null 처리)

select *
    , rank() over (order by comm desc) as comm_rank
    , row_number() over (order by comm desc) as comm_rank
from emp

null값이 존재하는 comm에 rank()와 row_number()를 적용하면 다음가 같이 null값에 대한 row들이 우선 순위로 계산된다. 왜냐하면 order by를 적용할 때 nulls first 라는 파라미터가 default이기 때문이다. null값이 우선이 된다는 뜻이다. 즉 위의 코드는 다음 코드와 같다.

select *
    , rank() over (order by comm desc nulls first) as comm_rank
    , row_number() over (order by comm desc nulls first) as comm_rank
from emp

이러한 null들을 후순위로 사용하고 싶다면 nulls first가 아닌 nulls last를 적용하면 된다.

• nulls first: null을 최우선 순위로
• nulls last: null을 마지막 순위로

위의 문제를 nulls last로 적용해서 실행한 결과는 다음과 같다.

select *
    , rank() over (order by comm desc nulls last) as comm_rank
    , row_number() over (order by comm desc nulls last) as comm_rank
from emp

또는 coalesce를 사용하여 null값을 다른 값으로 대체해도 된다.

다음은 comm값이 null값이면 0으로 대체 후 순위를 매기는 함수이다.

select *
    , rank() over (order by coalesce(comm, 0) as comm_rank
    , row_number() over (order by coalesce(comm, 0) as comm_rank
from emp

hiredate는 입사일의 데이터인 Date타입이다. 여기에서 입사년도. 즉 1981이란 년도만 추출하고 싶으면 다음과 같이 한다.

select *, to_char(hiredate, 'yyyy') as hire_year from emp

그렇다면 다음과 같이 문자열 형식으로 추출할 수 있다.

emp 테이블에서 입사년도 별 평균 급여 구하기.

select to_char(hiredate, 'yyyy') as hire_year, avg(sal), count(*) as cnt
from emp a
group by to_char(hiredate, 'yyyy')
order by 1

Case When

Cases When은 조건에 따라서 값을 지정해 주는 문법이다.

CASE 문의 형식은

CASE 컬럼  
WHEN 조건1 THEN 값1 

WHEN 조건2 THEN 값2 

ELSE 값3 

END 

job이 SALESMAN인 경우와 그렇지 않은 경우만 나누어서 평균/최소/최대 급여를 구하기.

-- job이 SALESMAN인 경우와 그렇지 않은 경우만 나누어서 평균/최소/최대 급여를 구하기. 
select case job
when 'SALESMAN' then 'SALESMAN'
else 'OTHERS'
end as job_category, min(sal), max(sal), round(avg(sal), 2)
from emp
group by job_category

Group by rollup

rollup은 group by로 나누어진 소그룹간의 계산을 하는 함수이다.

다음 코드와 같이 deptno, job으로 group by를 해보자.

select deptno, job, sum(sal)
from hr.emp
group by rollup(deptno, job)
order by 1, 2;

다음과 같이 deptno의 합계를 계산해준다. deptno가 10인 sum. deptno가 20인 sum, deptno가 30인 sum. 후에 전체 카테고리에 대한 Aggregation을 진행한다.

Group by Cube

Group by 시 Rollup을 함께 사용하면 Rollup에 적용된 컬럼의 순서대로 계층적인 Group by 를 추가적으로 수행.

위의 rollup과 달리 추가적으로 job 컬럼마다 Aggregation을 진행한다.

Rollup은 계층적으로, Cube는 가능한 경우의 수에 대한 Aggregation을 진행한다.

대표적인 집계함수 종류

• Count(): 정해진 집합 레벨에서 데이터 건수를 계산

• Sum(컬럼): 정해진 집합 레벨에서 지정된 컬럼값의 총합을 계산

• Min(컬럼): 정해진 집합 레벨에서 지정된 컬럼값의 최솟값을 계산

• Max(컬럼): 정해진 집합 레벨에서 지정된 컬럼값의 최댓값을 계산

• Avg(컬럼): 정해진 집합 레벨에서 지정된 컬럼값의 평균값을 계산

• 집계 함수는 NULL을 계산하지 않는다.

• Min, Max 함수의 경우에는 문자열, 날짜, 시간에 적용이 가능하다.

Group by count(distinct) 케이스

다음의 테이블이 있다.

다음은 user_id로 group by된 테이블의 개수를 세는 코드이다.

select user_id,  count(*) as cnt from orders group by user_id 
--결과: user_id: 1, cnt: 11

여기에서 distinct product_id를 추가하자. 중복을 제거한 unique한 product_id의 개수를 세는 것이다.

select user_id, count(distinct product_id) as cnt from orders group by user_id 
--결과: user_id: 1, cnt: 8

Count 함수에서 distinct를 사용하면 컬럼에서 중복된 값을 제외한 행의 개수를 세는 함수이다.

emp_test 테이블

현재 해당 테이블에는 deptno가 10이면 comm은 전부 null값이다. 20에는 comm값이 하나, 30에는 4개가 할당이 되어있다.

다음은 deptno별 comm의 최솟값, 최댓값, 평균, count를 구하는 코드이다.

select deptno, count(*) as cnt, sum(comm), min(comm), avg(comm)
from emp_test
group by deptno 

다음과 같이 deptno가 10인 행은 3개, 30은 6개, 20은 4개이다. 또한 deptno가 10인 경우에는 comm의 값이 전부 null값이므로, sum, min, avg는 다음과 같이 나온다

distinct를 사용하여 unique한 개수 계산

전체 행 개수 출력

select count(1) from hr.emp_test;
--출력: 13

job 컬럼에 unique한 개수 계산

select count(distinct job) from hr.emp_test;
--출력: 5

만약 다음과 같은 테이블이 있다 한다.

직원들의 부서별 급여의 합을 구하려면 Group by 기능을 사용한다.

select deptno, sum(sal) as sum_salary from hr.emp
group by deptno

• Group by 절에 기술된 컬럼 값(또는 가공 컬럼값)으로 그룹화 한 뒤 집계(Aggregation) 함수와 함께 사용되어 그룹화된 집계 정보를 제공한다.

• Group by 절에 기술된 컬럼 값으로 반드시 1의 집합을 가지게 됨. (중복된 value가 없음)
• Select 절에는 Group by 절에 기술된 컬럼(또는 가공 컬럼)과 집계 함수만 사용될 수 있음.

만약 그룹화한 결과에 조건을 걸고 싶다면 having을 사용한다.

SELECT job
     , SUM(sal) AS sum_sal
  FROM emp
 WHERE deptno IN (20, 30)
 GROUP BY job HAVING SUM(sal) > 5000

having이랑 where 둘 다 조건에 따른 필터링 기능을 가지고 있다. 하지만 둘의 차이점은 where는 그룹화 하기 전이고, having은 그룹화 후에 조건입니다.

emp 테이블

emp 테이블에서 부서별 최대 급여, 최소 급여, 평균 급여를 구할것.

select deptno, max(sal), min(sal), round(avg(sal), 2) as avg_sal 
from emp
group by deptno 
order by deptno asc

결과

emp 테이블에서 부서별 최대 급여, 최소 급여, 평균 급여를 구하되 평균 급여가 2000 이상인 경우만 추출.

select deptno, max(sal), min(sal), round(avg(sal), 2)
from emp
group by deptno
having avg(sal) >= 2000
order by deptno asc

부서명 SALES와 RESEARCH 소속 직원별로 과거부터 현재까지 모든 급여를 취합한 평균 급여

-- 부서명 SALES와 RESEARCH 소속 직원별로 과거부터 현재까지 모든 급여를 취합한 평균 급여

select a.empno, max(a.ename ), max(c.dname), round(avg(b.sal), 2) 
from emp a
    join emp_salary_hist b on a.empno = b.empno 
    join dept c on a.deptno = c.deptno
where c.dname in ('SALES', 'RESEARCH')
group by a.empno

위의 코드를 with 절로 사용하기.

with 
temp_01 as 
(
select a.empno, max(a.ename) ename, max(c.dname) dname, round(avg(b.sal), 2) avg_sal
from emp a
    join emp_salary_hist b on a.empno = b.empno 
    join dept c on a.deptno = c.deptno
where c.dname in ('SALES', 'RESEARCH')
group by a.empno
)
select * from temp_01

with 절은 서브 쿼리를 만드는 문법이다. 임시 테이블을 만들어 가독성을 더욱 높이는 기능이다.

• Date: 일자로서 년, 월, 일의 정보를 가짐. YYYY-MM-DD

• Timestamp: 일자를 시간 정보까지 같이 가짐. YYYY-MM-DD HH24:MI:SS
• Time: 오직 시간 정보만 가짐. HH24:MI:SS
• Interval: N days HH24:MI_SS => 시작부터 종료까지 며칠동안 혹은 몇달동안 걸렸느냐 표현하는 타입

문자열을 Date, Timestamp로 변환

• to_date('2022-01-01', 'yyyy-mm-dd') => 2022-01-01

• to_timestamp('2022-01=01 14:36:52', 'yyyy-mm-dd hh24:mi:ss') => 2022-01-01 14:36:52.000 +0900

Date, Timestamp를 문자열로 변환

• to_char(date_column, 'yyyy-mm-dd') => 1980-12-17 (문자열)

시간에 대한 Formatting

::date, ::timestamp, ::text를 사용한 형 변환(PostgreSQL 문법)

• Date를 Timestamp로 변환: select to_date('2022-01-01', 'yyyy-mm-dd')::timestamp;

• Timestamp를 Text 변환: select to_date('2022-01-01', 'yyyy-mm-dd')::text;
• Timestamp를 Date로 변환: select to_date('2022-01-01', 'yyyy-mm-dd')::date;

extract를 이용하여 년, 월, 일 추출

• extract(year from hiredate) as year

• extract(month from hiredate) as month
• extract(day from hiredate) as day

날짜와 시간의 연산

Date 타입에 숫자 연산을 하면 해당하는 일자에 대한 연산이 됨. Timestamp 타입에 숫자에 대한 연산을 하면 오류!! Timestamp는 interval 타입에 대한 연산을 수행해야 한다.

Date 타입 + 숫자

select to_date('2022-01-01', 'yyyy-mm-dd') +  2 
--출력값: =>     2022-01-03

Timestamp 타입 + Interval 타입

 select to_timestamp('2022-01-01 14:36:52', 'yyyy-mm-dd hh24:mi:ss') + interval '7 hour' 
 --출력값: => 2022-01-01 21:36:52.000

Date 타입 + Interval 타입 => 결과는 Timestamp 타입으로 변환됨.

select to_date('2022-01-01', 'yyyy-mm-dd') + interval '2 days' as date_01;
--결과: 2022-01-03 00:00:00.000

Date 타입간의 연산 => 결과는 정수형으로 나온다. (Date간의 연산에서 뺄셈만 가능하며, 덧셈은 불가능함.)

select to_date('2022-01-03', 'yyyy-mm-dd') - to_date('2022-01-01', 'yyyy-mm-dd')
--결과: 2(정수형)

Timestamp 타입 간의 연산 => 결과는 interval로 나온다.

select to_timestamp('2022-01-01 14:36:52', 'yyyy-mm-dd hh24:mi:ss') 
     - to_timestamp('2022-01-01 12:36:52', 'yyyy-mm-dd hh24:mi:ss')
-- 결과: 02:00:00 

현재 시간 구하기.

• now() => timestamp 타입
• current_timestamp => timestamp 타입
• current_date => date 타입
• current_time => time 타입

trunc

trunc(a, b)

python의 round 함수와 상이하다. 첫 번째 파라미터인 a 대하여 두 번째 파라미터 b자리 이후로부터는 자르겠다라는 함수이다.

ex)

select trunc(99.9999, 2);
--결과: 99.99

date_trunc

date_trunc는 trunc와는 다르게 첫 번째 인자로 들어온 기준으로 두 번째 인자(Date)를 자르는 함수이다. 입력에 Date 타입이든 Timestamp 타입이든 반환 타입은 Timestamp이다.

ex)

select date_trunc('day', '2022-03-03 14:05:32'::timestamp)
--결과: 2022-03-03 00:00:00.000

--Month 기준으로 자르면, day는 해당 month의 1일으로 지정된다.

select date_trunc('month', '2022-03-03'::date)::date as date_01;
--결과 => 2022-03-01

--Year 기준으로 자르면, month와 day는 해당 year의 1월 1일으로 지정된다.

select date_trunc('year', '2022-03-03'::date)::date as date_01;
--결과 => 2022-01-01

주(Week) 기준으로 할 수 있다. 해당 주의 월요일 기준으로 지정한다.

-- week의 시작 날짜 구하기. 월요일 기준.
select date_trunc('week', '2022-03-03'::date)::date as date_01;
-- 결과: 2022-02-28

Month의 마지막 날자를 구하는 코드

-- month의 마지막 날짜 
select (date_trunc('month', '2022-03-03'::date) + interval '1 month' - interval '1 day')::date;

인프런 강의

즉 on에 붙어있는 조건에 해당해야만 새로운 데이터로 추출하는 형식이다.

만약 다음과 같은 코드가 있다 하자.

select a.category_name, b.product_id, b.product_name, c.company_name 
from categories a 
    join products b on a.category_id = b.category_id 
     join suppliers c on b.supplier_id = c.supplier_id 
where a.category_name = 'Beverages'

다음은 categories 테이블의 category_id와 products 테이블의 category_id, 그리고 products 테이블의 supplier_id와가 같아야만 데이터로 추출이 된다.

Outer Join

• LEFT OUTER JOIN: 왼쪽 테이블의 모든 값이 출력되는 조인
• RIGHT OUTER JOIN: 오른쪽 테이블의 모든 값이 출력되는 조인
• FULL OUTER JOIN: 왼쪽 또는 오른쪽 테이블의 모든 값이 출력되는 조인

조건에 상관없이 어느 한 쪽의 테이블의 모든 값이 출력된다면, 조건에 해당하지 않는 다른 쪽 테이블의 값은 NULL로 대체된다.

--예시 코드
SELECT * FROM A
LEFT OUTER JOIN B
ON A.id = B.id

예제

다음과 같은 EDR이 있다 하자.

주문이 단 한번도 없는 고객 정보를 구해보자. 다양한 여러 방법이 있겠지만 Outer Join을 사용하면 간단하다.

-- 주문이 단 한번도 없는 고객 정보 구하기. 
select a.customer_id, a.contact_name, b.order_id, b.customer_id
from customers a
    left outer join orders b on a.customer_id = b.customer_id 
where b.order_id is null;

customers 테이블을 left로, orders 테이블을 right로 한 후, left join을 하면 주문을 하지 않은 고객에 대한 order_id는 null으로 설정될 것이다. 그래서 where에 is null을 사용하면 주문을 하지 않은 고객의 정보를 얻을 수 있을 것이다.

출력 결과

-- Madrid에 살고 있는 고객이 주문한 주문 정보를 구할것.고객명, 주문id, 주문일자, 주문접수 직원명, 배송업체명을 구하되, 만일 고객이 주문을 한번도 하지 않은 경우라도 고객정보는 빠지면 안됨. 이경우 주문 정보가 없으면 주문id를 0으로 나머지는 Null로 구할것.

select a.contact_name, coalesce(b.order_id, 1), c.last_name || ' ' || c.first_name, d.company_name 
from customers a
    left join orders b on a.customer_id = b.customer_id 
    left join employees c on b.employee_id = c.employee_id  
    left join shippers d on b.ship_via = d.shipper_id 
where a.city = 'Madrid'

outer join을 할 때 join 집합이 여러 개면 모든 join에 outer을 붙여줘야 한다.

Coalesce란?

두 개의 파라미터를 받는데, 첫 번째 컬럼이 NULL이 아니라면 해당 컬럼 값을 그대로 출력, 만약 NULL이라면 두 번째 value로 출력하는 것이다.

인프런 강의

Join

• join은 관계형 DB에서 기본이자 가장 중요한 기능이다.

• 두 개 이상의 테이블을 묶어 데이터를 추출하는 기능.
• 관계형 DB에서 join을 이용하여 서로 다른 테이블 간의 원하는 정보를 얻을 수 있음.

• emp 테이블: 직원의 이름, 직원 번호, 직무, 부서 넘버에 대한 정보가 담겨져 있는 테이블
• dept 테이블: 부서 넘버에 맞는 부서 이름, 위치가 담겨져 있는 테이블

emp 테이블에는 부서 넘버가 존재한다. 하지만 부서 이름과 부서 위치가 명시되어있지 않는다. 만약 emp 테이블에 있는 직원 정보를 포함한, 그에 맞는 부서의 이름과 위치까지 알고 싶다면 join을 이용하여 새로운 테이블을 생성한다.

*emp 테이블은 deptno 기준으로 value가 unique하지 않은 M집합이다. dept 테이블은 deptno 기준으로 value가 unique한 1집합이다. * deptno 기준으로 join시, 즉 1:M 조인 시 나오는 결과는 M집합이 된다.

예시

실습

실습은 DBeaver에서 ProgreSQL을 사용하여 진행한다.

현재 hr 스키마에 dept, emp, emp_dept_hist, emp_salaray_hist, salgrade 총 5개의 테이블가 있다.

스키마의 다이어그램 보기를 누르면 다음과 같이 ERD로 시각적으로 확인할 수 있다.

직원 정보와 직원이 속한 부서명을 가져오기

-- 직원 정보와직원이 속한 부서명을 가져오기.

select a.*, b.dname
from emp as a 
    join dept as b on a.deptno = b.deptno 

위 코드에서 hr이라는 스키마가 defalut로 설정했으므로 hr은 생략이 가능하다. emp as a라는 그룹과 dept as b 라는 그룹을 join할건데, a의 deptno와 b의 deptno를 기준으로 합친다. 합친 것 중, a의 모든 컬럼과 b의 dname을 추출한다는 의미이다.

실행 결과

job이 SALESMAN인 직원정보와 직원이 속한 부서명 가져오기.

select a.*, b.dname 
from emp as a join dept as b on a.deptno = b.deptno where a.job = 'SALESMAN'

실행 결과

부서명 SALES와 RESEARCH의 소속 직원들의 부서명, 직원번호, 직원명, JOB, 과거 급여 정보 추출

-- 부서명 SALES와 RESEARCH의 소속 직원들의 부서명, 직원번호, 직원명, JOB, 과거 급여 정보 추출

select b.dname, a.empno, a.ename, a.job, c.sal 
from emp as a
join dept as b on a.deptno = b.deptno 
join emp_salary_hist as c on a.empno = c.empno 
where b.dname in ('SALES', 'RESEARCH')

실행 결과

부서명 SALES와 RESEARCH의 소속 직원들의 부서명, 직원번호, 직원명, JOB 그리고 과거 급여 정보중 1983년 이전 데이터는 무시하고 데이터 추출

-- 부서명 SALES와 RESEARCH의 소속 직원들의 부서명, 직원번호, 직원명, JOB 그리고 과거 급여 정보중 1983년 이전 데이터는 무시하고 데이터 추출 

select b.dname, a.empno, a.ename, a.job, c.sal 
from emp as a
    join dept as b on a.deptno = b.deptno 
    join emp_salary_hist as c on a.empno = c.empno 
where b.dname in ('SALES', 'RESEARCH') 
and c.fromdate  >= to_date('1983-01-01', 'yyyy-mm-dd') 
order by c.fromdate ASC

실행 결과

인프런 강의

데이터베이스(영어: database, DB)는 여러 사람이 공유하여 사용할 목적으로 체계화해 통합, 관리하는 데이터의 집합이다. 작성된 목록으로써 여러 응용 시스템들의 통합된 정보들을 저장하여 운영할 수 있는 공용 데이터들의 묶음이다. - Wikidipia

한마디로 데이터를 저장하는 공간이다.

DBMS란?

데이터베이스를 ‘데이터의 집합’이라고 정의한다면, 이런 데이터베이스를 관리하고 운영하는 소프트웨어를 DBMS(Database Management System)라 한다. 다양한 데이터가 저장되어 있는 데이터베이스는 여러 명의 사용자나 응용 프로그램과 공유하고 동시에 접근이 가능해야 함.

DBMS의 종류

• RDBMS(Relational Database Management System): 관계형 데이터베이스는 데이터를 테이블 형식으로 구성하고, 테이블 간의 관계를 정의하는 데이터베이스. 예시로는 Oracle, MySQL, Microsoft SQL Server, PostgreSQL 등이 있다.

• 객체 지향 데이터베이스(Object-Oriented Database)

• 키-값 데이터베이스(Key-Value Database)

• 컬럼 패밀리 데이터베이스(Column Family Database)

• 그래프 데이터베이스(Graph Database)

SQL이란?

SQL(Structured Query Language)은 관계형 데이터베이스에서 사용되는 언어이다.

이 챕터는 RDBMS 중 PostgreSQL, 환경 도구는 DBeaver을 사용할 것이다.

인프런 강의

PostgreSQL DBeaver

*(에스터리스크, 별표)는 모든 항목을 다 출력할 때 사용함.

SELECT * FROM Customers;

여기서 원하는 컬럼만 출력하고 싶을 때에는 아래와 같이 사용함.

SELECT CustomerName, City FROM Customers;

DISTINCT는 중복값을 제거합니다. 넘파이의 Unique() 함수와 기능이 동일.

SELECT DISTINCT Country FROM Customers;

ORDER BY

출력 결과 정렬.

• 오름차순 : ASC(기본, 작은 수에서 큰 수로, Ascending)
• 내림차순 : DESC(큰 수에서 작은 수로, Descending)

SELECT * FROM Customers ORDER BY CustomerID DESC;

SELECT * FROM Customers ORDER BY CustomerName ASC;

AS

별칭을 정한다. 기존 Table의 값은 변하지 않음.

SELECT CustomerID AS 회원이름
FROM Customers;

SELECT CustomerID AS 회원이름, Country AS 나라
FROM Customers;

연결 연산자

SELECT Country || ' ' || City || ' ' || Address AS 주소 FROM Customers

실행결과

각 열의 데이터를 공백을 기준으로 합침. CONCAT과 상이함.

논리 연산

SELECT *
FROM Customers 
WHERE CustomerID LIKE '1%'
AND City = 'London';

SELECT *
FROM Customers 
WHERE CustomerID LIKE '1%'
AND (City = 'London' OR City = 'Berlin');

BETWEEN 연산

A AND B : A와 B를 포함한 사이의 값

SELECT CustomerID, CustomerName
FROM Customers 
WHERE CustomerID BETWEEN 30 AND 50;

실행결과: Customers 데이터에서 가져온 CutomerID가 30이상 50이하에 해당하는 CustomerID, CustomerName

IN 연산

IN A : A안에 값과 일치하는 값을 조회

SELECT CustomerID, CustomerName
FROM Customers 
WHERE CustomerID IN (10, 20, 30);

실행결과: Customers 데이터에서 가져온 CutomerID가 10, 20, 30에해당하는 CustomerID, CustomerName

LIKE 연산

대소문자를 안가림

만약 데이터가 Paullab, Paultest, Paulcode가 있다 하자.

SELECT CustomerID, CustomerName
FROM Customers 
WHERE CustomerName LIKE 'Paul___';

결과: Paullab만 검색. 언더바(_)는 모든 문자를 의미함.

SELECT CustomerID, CustomerName
FROM Customers 
WHERE CustomerName LIKE 'Paul%';

결과: Paullab, Paultest, Paulcode 전부 검색. %는 뒤에 어떤 문자열이 와도 되고, 문자 자체가 없어도 됨.

Paul이 들어가는 모든 값

SELECT CustomerID, CustomerName
FROM Customers 
WHERE CustomerName LIKE '%Paul%';

IS NULL

NULL 값을 갖는 값.

SELECT CustomerID, CustomerName
FROM Customers 
WHERE CustomerID IS NULL;

WHERE

• 조회하려는 데이터에 조건 부여
• 여러 연산자를 결합하여 사용 가능
• 결합 가능한 연산자의 종류 : 비교연산자(=, <, >, !=, >=, <=), SQL연산자(BETWEEN), 논리 연산자(AND, OR) 등

SELECT *
FROM Customers 
WHERE CustomerID > 80 AND Country='France';

결과: Customers에서 가져온 데이터 중, CustomerID가 80보다 크고, Country가 France인 모든 컬럼 검색.

INSERT

새로운 행을 추가함. 파이썬의 append 함수와 상이함. 만약 컬럼이 부족하다면 부족한 컬럼은 null로 추가됨.

INSERT INTO Customers (CustomerName, City, Country)
VALUES ('leehojun', 'jejusi', 'korea');

코드의 의미: Customers 테이블에 CustomerName, City, Country 열에 'leehojun', 'jejusi', 'korea'란 값을 넣는다. 다른 나머지 열은 null으로 추가됨.

UPDATE

값을 수정, 변경하는 함수. 한 번 바꾸면 다시 되돌릴 수 없으니 신중히 해야함.

UPDATE Customers
SET CustomerName='하르방', City='한라산', Country='선계'
WHERE CustomerID = 1;

코드의 의미: Customers 테이블에 CustomerID가 1인 행에 CustomerName란 열에 '하르방', City란 열에 '한라산', Country란 열에는 '선계'란 값으로 수정한다.

DELETE

WHERE 구문을 적지 않으면 모든 데이터가 삭제됨.

DELETE FROM Customers WHERE CustomerName='hojun';

코드의 의미: CustomerName이 hojun인 행 삭제.

실습 wschools 제주코딩베이스캠프 강의

패션 MNIST 데이터 불러온 후, 스케일링 후 Train, Validation Set으로 분할

from tensorflow import keras
from sklearn.model_selection import train_test_split

(train_input, train_target), (test_input, test_target) =\
keras.datasets.fashion_mnist.load_data()

train_scaled = train_input.reshape(-1, 28, 28, 1) #이미지에는 항상 깊이(채널)이 있어야 한다. 흑백의 이미지는 채널이 없는 2차원이지만, 다른 이미지는 채널이 RGB로 이루어짐.
train_scaled = train_input / 255.0
train_scaled, val_scaled, train_target, val_target = train_test_split(train_scaled, train_target, test_size=0.2, random_state=42)

첫 번째 합성곱-풀링 층 신경망

model = keras.Sequential()

#32개의 kernel, Same Padding, kernel_size = (3, 3)
model.add(keras.layers.Conv2D(32, kernel_size=3, activation='relu', padding='same', input_shape=(28, 28, 1)))

#풀링 층 추가. 전형적인 (2, 2) 크기의 풀링
#Pooling Layer을 통과하면 데이터는 (28, 28, 32)에서 (14, 14, 32)가 된다.
model.add(keras.layers.MaxPooling2D(2))

두 번째 합성곱-풀링 층 신경망

#64개의 kernel, 3종류의 kernel
model.add(keras.layers.Conv2D(64, kernel_size=3, activation='relu', padding='same'))
model.add(keras.layers.MaxPooling2D(2))

최종적으로 만들어지는 피처맵의 크기는 (7, 7, 64)

Flatten Layer, Dense Layer, Dropout 추가

#Flatten layer, Dense layer 추가, hidden layer와 output layer 사이의 Dropout 추가. 
#패션 MNIST  데이터셋은 클래스 10개를 분류하는 다중 분류이므로 마지막층 뉴런은 10개, 활성화함수는 softmax
model.add(keras.layers.Flatten())
model.add(keras.layers.Dense(100, activation='relu'))
model.add(keras.layers.Dropout(0.4))
model.add(keras.layers.Dense(10, activation='softmax')) #output layer, activate function은 softmax 

model.summary()

keras.utils.plot_model(model)

모델 컴파일과 훈련

model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics='accuracy')
checkpoint_cb = keras.callbacks.ModelCheckpoint('best_cnn-model.h5', save_best_only=True)
early_stopping_cb = keras.callbacks.EarlyStopping(patience=2, restore_best_weights=True)
history = model.fit(train_scaled, train_target, epochs=20, validation_data=(val_scaled, val_target), callbacks=[checkpoint_cb, early_stopping_cb])

#출력
Epoch 1/20
1500/1500 [==============================] - 17s 11ms/step - loss: 0.5223 - accuracy: 0.8124 - val_loss: 0.3402 - val_accuracy: 0.8752
Epoch 2/20
1500/1500 [==============================] - 17s 11ms/step - loss: 0.3504 - accuracy: 0.8737 - val_loss: 0.3050 - val_accuracy: 0.8863
Epoch 3/20
1500/1500 [==============================] - 18s 12ms/step - loss: 0.2981 - accuracy: 0.8925 - val_loss: 0.2612 - val_accuracy: 0.9024
Epoch 4/20
1500/1500 [==============================] - 18s 12ms/step - loss: 0.2670 - accuracy: 0.9030 - val_loss: 0.2564 - val_accuracy: 0.9058
Epoch 5/20
1500/1500 [==============================] - 18s 12ms/step - loss: 0.2398 - accuracy: 0.9130 - val_loss: 0.2399 - val_accuracy: 0.9126
Epoch 6/20
1500/1500 [==============================] - 18s 12ms/step - loss: 0.2237 - accuracy: 0.9181 - val_loss: 0.2280 - val_accuracy: 0.9158
Epoch 7/20
1500/1500 [==============================] - 18s 12ms/step - loss: 0.2052 - accuracy: 0.9240 - val_loss: 0.2430 - val_accuracy: 0.9112
Epoch 8/20
1500/1500 [==============================] - 18s 12ms/step - loss: 0.1911 - accuracy: 0.9284 - val_loss: 0.2230 - val_accuracy: 0.9212
Epoch 9/20
1500/1500 [==============================] - 19s 13ms/step - loss: 0.1749 - accuracy: 0.9346 - val_loss: 0.2289 - val_accuracy: 0.9194
Epoch 10/20
1500/1500 [==============================] - 19s 12ms/step - loss: 0.1623 - accuracy: 0.9376 - val_loss: 0.2318 - val_accuracy: 0.9193

정확도는 90% 이상으로 상당히 높은 성능을 보여준다.

#검증
model.evaluate(val_scaled, val_target)

#출력
375/375 [==============================] - 2s 4ms/step - loss: 0.2230 - accuracy: 0.9212
[0.22298048436641693, 0.9212499856948853]

하나의 데이터 예측 후, 모든 케이스에 대한 확률 확인하기.

preds = model.predict(val_scaled[0:1])
print(preds)

#출력
1/1 [==============================] - 0s 45ms/step
[[2.8726700e-20 5.2744390e-30 1.1897561e-22 1.9612064e-25 1.8187563e-21
  2.3631663e-19 4.3168609e-22 1.1876107e-23 1.0000000e+00 1.5984584e-23]]

아홉 번째 확률은 1에 근사하지만, 나머지는 0에 근사한다. 시각화 후 확인하자.

import matplotlib.pyplot as plt

plt.bar(range(1, 11), preds[0])
plt.show()

완벽하게 아홉 번째 클래스로 예측했다는 것을 알 수 있다.

#테스트
test_scaled = test_input.reshape(-1, 28, 28, 1) / 255.0
model.evaluate(test_scaled, test_target)

#출력
test_scaled = test_input.reshape(-1, 28, 28, 1) / 255.0
model.evaluate(test_scaled, test_target)

성능은 대부분 90%가 넘는 것으로 보인다.

합성곱 신경망(CNN)은 Convolution Neural Networks의 줄임말로, 인간의 시신경을 모방하여 만든 딥러닝 구조 중 하나이다. 이미지 처리에 탁월하며, ANN, DNN과 다르게 이미지의 공간적인 정보를 유지한다.

Convolution Layer(신경망 층)

먼저 다음과 같은 3x3의 이미지가 있다고 하자.

우리가 일반적인 ANN, DNN 딥러닝 모델로 해당 이미지를 분석한다고 하면 Flatten 층을 거쳐 다음과 같이 1차원의 데이터로 평탄화가 될 것이다. 이 데이터에 각 가중치를 곱하여 은닉층으로 결과값이 전달되고, 최종적으로 출력층에서 Classfiy를 할 것이다. 하지만 이미지 특성상 각 픽셀간의 밀접한 상관관계가 있을텐데, 해당 알고리즘은 이러한 공간적인 구조를 무시한 채 분석을 한다는 것을 알 수 있다. 이러한 점을 방지하고자, 이미지 특성 상 공간적인 특성을 유지하고자 나온 딥러닝 모델이 Convolution Layer이다.

원래 밀집층의 뉴런은 다음과 같이 모든 뉴런에 가중치를 곱한 후 절편을 더한 하나의 출력값이다. 즉 뉴런의 개수와 출력값의 개수가 동일하다.

하지만 합성곱에서는 다음과 같이 가중치 w1w3과 처음 특성 3개를 곱한 후 절편을 더하여 한 개의 출력을 만든다. 그 다음은 이 전과 똑같은 가중치 w1w3와 24번째 특성을 곱한 후 절편을 더하여 또다른 한 개의 출력을 만든다. 여기에서 중요한 것은 첫 번째 합성곱에서 사용된 가중치 w1w3을 두 번째 합성곱의 계산에서도 사용했다는 것이다. 이렇게 한 칸씩 아래로 이동하면서 출력을 만들며, 이 과정을 끝까지 한다면 다음과 같이 된다.

물론 가중치의 개수는 w1~w3처럼 3개를 선택해도 되고, 더욱 많은 가중치를 선택해도 된다. 즉 하이퍼파라미터이다. 이를 합성곱 신경망에서는 뉴런이라고도 부르지만, 보통 filter 혹은 kernel이라고 부른다.

4x4의 입력이 있다하자. 커널의 크기를 2x2으로 지정한다 하면 다음과 같을 것이다.

입력이 2차원이라면 커널도 반드시 2차원이여야 한다. 처음은 입력값의 첫 부분에 해당 필터를 씌운다.

후에는 sliding을 하여 다음과 같은 입력값의 부분에 kernel을 계산할 것이다.

이 과정을 반복해가면 다음과 같은 출력값이 만들어질 것이다.

밀집층에서 여러 개의 뉴런을 사용하듯이, 합성곱 층에서도 다음과 같이 여러 개의 kernel을 사용할 수 있다. (4, 4)의 입력값에 (3, 3)의 커널을 사용한다면 (2, 2)의 feature map이 나온다. 이것이 3개로 겹치며 최종적으로 (2, 2, 3) 크기의 feature map이 된다.

입력값에 kernel을 씌운 후 나오는 결과를 feature map(특성 맵)이라고 부른다. 이 과정을 인공 신경망의 구조로 나타내면 다음과 같다,

Padding

(4, 4) 크기의 입력에 (3, 3) 크기의 커널을 적용하면 (2, 2) 크기의 피처맵이 만들어졌다. 하지만 만약 커널의 크기는 그대로 (3, 3)이지만, 출력의 크기. 즉 피처맵의 크기가 입력과 동일하게 (4, 4)로 만들려면 어떻게 해야 할까?

입력값과 동일한 크기의 출력을 만들고 싶다면 마치 더 큰 입력에 합성곱하는 척을 해야한다. 예를 들어 실제 입력 크기는 (4, 4)이지만, (6, 6)처럼 다룬다고 가정해보자. 다음과 같이 (6, 6) 크기의 입력에 (3, 3) 크기의 커널로 합성곱을 하였을 때 출력의 크기는 어떻게 될까??

실제 (4, 4) 크기의 입력값 주위에 0을 채워넣은 후, (6, 6) 크기로 만든 후 진행해보자.

다음과 같이 16번의 연산을 통하여 (4, 4) 크기의 feature map을 만들 수 있다.

이렇게 입력 주위를 가상의 원소로 채우는 것을 Padding이라고 한다. 실제 입력값이 아니기 때문에 패딩은 0으로 채운다. 그러면 (4, 4) 크기의 입력값은 위와 같이 (6, 6) 크기의 입력값으로 된다.

패딩의 역할은 순전히 커널이 씌워지는 횟수를 늘려주는 것밖에는 없다. 그렇기 때문에 계산에도 영향을 미치지 않는다

이렇게 입력과 피처맵의 크기를 동일하게 만들기 위해 주위를 0으로 패딩하는 것을 same padding이라고 한다. 일반적으로 합성곱 신경망에서는 새임 패딩이 가장 많이 사용된다.

이러한 패딩 없이 순수한 입력에서 피처맵을 만드는 경우를 Valid Padding이라 한다.

Padding의 사용 이유

만약 (4, 4) 크기의 입력에서 패딩 없이 합성곱을 한다면 다음과 같은 4번의 계산이 이루어진다.

왼쪽 위 모서리의 3을 포함한 양 끝 네 모서리는 커널이 단 한 번밖에 계산이 되지 않는다.하지만 가운데에 있는 4, 8, 5, 1은 4번의 계산에 포함된다. 즉 이미지 계산에 불균형이 이루어질 수 있다. 패딩을 진행하면 이러한 불균형을 감소할 수 있다.

Stride

스트라이드는 kernel의 이동 크기를 의미한다. 즉 현재까지 진행한 스트라이드의 크기는 1이였다. 스트라이드의 크기가 2인 경우는 다음과 같다.

대부분 스트라이드는 1로 설정하여, strides 매개변수는 잘 사용하지 않는다.

Pooling

풀링(Pooling)은 합성곱 층에서 만든 피처맵의 크기를 줄이는 역할이다. 하지만 피처맵의 개수는 줄이지 않는다. 예를 들어, (2, 2, 3)의 피처맵이 있다. 여기에 (2, 2) 크기로 풀링을 적용하면 (1, 1, 3)이 된다.

커널을 찍은 영역에서 가장 큰 값을 고르거나, 평균값을 계산한다. 이를 각각 최대 풀링과 평균 풀링이라 한다.

다음은 (4, 4) 크기의 피처맵에 (2, 2) 최대 풀링을 적용한 것이다.

최대 풀링은 가장 큰 값을 고르기 때문에 첫 번째 (2, 2) 영역에서 9를 고르고, 그 다음은 7, 8, 6을 고른 후 (2, 2)의 출력을 만든다. 피처맵이 여러 개라면 동일한 작업을 반복한다.

풀링에서는 영역을 겹치지 않고 이동을 한다. 풀링 크기가 (2, 2)라면 스트라이드가 2인 셈이다. 풀링의 크기는 보통 정방형의 크기로 설정한다.

Convolution Neural Networks의 구조

위와 같이 (4, 4)의 입력, (3, 3)의 커널이 있다.

1. Same Padding이므로, 입력의 크기를 (6, 6)으로 늘려준다.

2. 커널의 개수는 3개이므로, 각 커널을 계산한 (4, 4, 3)의 피처맵을 생성한다. 밀집층과 마찬가지로 합성곱 층에서도 활성화 함수를 적용한다. 합성곱 층은 보통 렐루 함수를 많이 사용한다.

3. (2, 2)의 최대 풀링을 진행한다. 풀링을 진행하면서 특성의 가로, 세로의 크기를 줄인다. 특성의 개수는 건들지 않는다. 즉 (4, 4, 3)의 피처맵에 (2, 2)의 최대 풀링을 진행하면 (2, 2, 3)의 피처맵이 생성된다.

4. (2, 2, 3)의 피처맵을 Flatting하면 12개의 특성을 가진 1차원 배열으로 된다. 이것이 출력층의 입력이 된다.

from tensorflow import keras
from sklearn.model_selection import train_test_split

(train_input, train_target), (test_input, test_target) =\
keras.datasets.fashion_mnist.load_data()
train_scaled = train_input / 255.0
train_scaled, val_scaled, train_target, val_target = train_test_split(train_scaled, train_target, test_size=0.2, random_state=42)

모델을 생성 후 반환하는 함수 만들기

#모델을 만드는 함수 정의

def model_fn(a_layer=None):
    model = keras.Sequential()
    model.add(keras.layers.Flatten(input_shape=(28, 28)))
    model.add(keras.layers.Dense(100, activation='relu'))

    if a_layer:
        model.add(a_layer)

    model.add(keras.layers.Dense(10, activation='softmax'))
    return model

모델 생성 후 학습시키기.

model = model_fn()
model.summary()
model.compile(loss='sparse_categorical_crossentropy', metrics='accuracy')
history = model.fit(train_scaled, train_target, epochs=5, verbose=0)

import matplotlib.pyplot as plt

plt.plot(history.history['loss'])
plt.xlabel('epoch')
plt.ylabel('loss')

plt.show()

다음 그래프와 같이 epoch가 증가할 수록 손실은 줄어들고 정확도는 높아진다. 그러면 epoch를 계속해서 증가하면 성능이 완전히 올라가지 않을까?

다음은 epoch를 20까지 늘려서 모델을 학습시킨 코드이다.

model = model_fn()
model.compile(loss='sparse_categorical_crossentropy', metrics='accuracy')

history = model.fit(train_scaled, train_target, epochs=20, verbose=0)

plt.plot(history.history['loss'])
plt.xlabel('epoch')
plt.ylabel('loss')

plt.show()

다음과 같이 손실이 감소한다. 이것이 더 나은 모델을 학습한 것일까? 반복 수를 늘리면 과대/과소적합의 가능성이 상당히 올라간다.

검증 손실

model = model_fn()
model.compile(loss='sparse_categorical_crossentropy', metrics='accuracy')
history = model.fit(train_scaled, train_target, epochs=20, verbose=0, validation_data=(val_scaled, val_target))

plt.plot(history.history['loss'])
plt.plot(history.history['val_loss'])
plt.xlabel('epoch')
plt.ylabel('loss')
plt.legend(['train', 'validate'])

plt.show()

초기 검증 손실이 감소하다가, 다섯번 째 에포크 만에 다시 상승하기 시작한다. 하지만 학습 손실은 꾸준히 감소하기 때문에 전형적인 과대적합 모델이다.

과대적합을 막기 위해 릿지, 라쏘 규제오 같은 것을 적용할 수 있다. 하지만 그 전에는 옵티마이저 하이어파라미터를 조정한다.

Adam 옵티마이저는 적응적 학습률을 사용하기 때문에 epoch가 진행되면서 학습률의 크기를 조정할 수 있다. Adam 옵티마이저를 적용 후, 다시 시각적 표현을 하자.

model = model_fn()
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics='accuracy')
history = model.fit(train_scaled, train_target, epochs=20, verbose=0, validation_data=(val_scaled, val_target))

plt.plot(history.history['loss'])
plt.plot(history.history['val_loss'])
plt.xlabel('epoch')
plt.ylabel('loss')
plt.legend(['train', 'validate'])

plt.show()

위의 그래프와 달리 과대적합이 감소한 모습을 보인다.

인공 신경망에서 사용하는 대표적인 규제 방법

드롭아웃

드롭아웃은 다음 그림처럼 훈련 과정에서 층에 있는 뉴런을 랜덤하게 꺼서(뉴런의 츌력을 0으로 만듬) 과대적합을 막는다.

어떤 샘플을 처리할 때는 은닉층의 두 번째 뉴런이 드롭아웃이 되어 h2의 출력이 없다. 다른 샘플을 처리할 때에는 은닉층의 첫 번째 뉴런이 드롭아웃이 되어 h1의 출력이 없다.

뉴런은 랜덤하게 드롭아웃 되고 얼마나 많은 뉴런을 드롭할 지는 우리가 정해야 할 또다른 하이퍼파라미터이다.

어떻게 드롭아웃이 과대적합을 막을까? 이전 층의 일부 뉴런이 랜덤하게 꺼지면 특정 뉴런에 과대하게 의존하는 것을 줄일 수 있다.

#30%정도를 드롭아웃 한다.
model = model_fn(keras.layers.Dropout(0.3))
model.summary()

model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics='accuracy')
history = model.fit(train_scaled, train_target, epochs=20, verbose=0, validation_data=(val_scaled, val_target))

plt.plot(history.history['loss'])
plt.plot(history.history['val_loss'])
plt.xlabel('epoch')
plt.ylabel('loss')
plt.legend(['train', 'validate'])

plt.show()

Keras 모델은 학습된 모델의 파라미터를 저장하는 save_weights() 메서드를 제공한다.

model.save_weights('model-weights.h5')

또한 모델의 구조와 모델 파라미터를 함께 저장하는 save() 메서드도 제공한다.

model.save('model-whole.h5')

1. 학습하지 않는 새로운 모델을 생성 후, 모델의 파라미터만 저장된 model-weights.h5 파일에서 학습된 모델 파라미터만 읽어서 사용해보자.

model = model_fn(keras.layers.Dropout(0.3))
model.load_weights('model-weights.h5')

2. 이번에는 모델 전체를 파일에서 불어온다.

model = keras.models.load_model('model-whole.h5')
model.evaluate(val_scaled, val_target)

Callback

콜백은 학습 과정 중간에 어떤 작업을 수행할 수 있게 하는 객체이다. 여기에서 사용할 ModelCheckPoint 콜백은 기본적으로 에포크마다 모델을 저장한다.

save_best_only=True 매개변수를 지정하여 가장 낮은 검증 점수를 만드는 모델을 저장할 수 있다.

#30%정도를 드롭아웃 한다.
model = model_fn(keras.layers.Dropout(0.3))
model.summary()

model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics='accuracy')
checkpoint_cb = keras.callbacks.ModelCheckpoint('best-model.h5', save_best_only=True)

model.fit(train_scaled, train_target, epochs=20, verbose=0, validation_data=(val_scaled, val_target), callbacks=[checkpoint_cb])

model = keras.models.load_model('best-model.h5')
model.evaluate(val_scaled, val_target)

#출력
375/375 [==============================] - 0s 611us/step - loss: 0.3146 - accuracy: 0.8867
[0.3145997226238251, 0.8867499828338623]

여전히 20번의 에포크 동안 학습을 진행한다. 사실 검증 점수가 상승하기 시작하면, 그 이후는 과대적합이 더 커지기 때문에 훈련을 계속할 필요가 없다. 과대적합이 시작되기 전에 훈련을 미리 중지하는 것을 조기종료라 한다.

조기종료는 훈련 에포크 횟수를 제한하는 역할이지만, 모델이 과대적합되는 것을 막아 주기 때문에 규제 방법 중 하나라고 생각할 수 있다.

파라미터 중 patience는 연속 검증 점수가 향상되지 않으면 훈련을 종료시키는 파라미터이다. 즉 patience=2로 지정하면 2번 연속 검증 점수가 향상되지 않으면 학습을 중지한다.

또한 restore_best_weights 파라미터를 True로 설정하면 가장 낮은 검증 손실을 낸 모델 파라미터로 되돌린다.

EarlyStopping 콜백을 ModelCheckpoint 콜백과 함께 사용하면 가장 낮은 검증 손싱릐 모델을 파일에 저장 후, 검증 손실이 다시 상승할 때 훈련을 중지할 수 있다. 또한 훈련을 중지한 다음 현재 모델의 파라미터를 최상의 파라미터로 되돌린다.

model = model_fn(keras.layers.Dropout(0.3))
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics='accuracy')
checkpoint_cb = keras.callbacks.ModelCheckpoint('best-model.h5', save_best_only=True)
early_stoppin_cb = keras.callbacks.EarlyStopping(patience=2, restore_best_weights=True)

history = model.fit(train_scaled, train_target, epochs=20, verbose=0, 
validation_data=(val_scaled, val_target), callbacks=[checkpoint_cb, early_stoppin_cb])

print(early_stoppin_cb.stopped_epoch)

#출력값 11
#12번째 epoch에서 학습이 종료되었다.

plt.plot(history.history['loss'])
plt.plot(history.history['val_loss'])
plt.xlabel('epoch')
plt.ylabel('loss')
plt.legend(['train', 'validate'])

plt.show()

model.evaluate(val_scaled, val_target)

#출력값: 
375/375 [==============================] - 0s 683us/step - loss: 0.3250 - accuracy: 0.8808
[0.32503339648246765, 0.8808333277702332]

from tensorflow import keras
(train_input, train_target), (test_input, test_target) =\
keras.datasets.fashion_mnist.load_data()

그 다음 이미지의 픽셀값을 0255범위에서 01로 변환 후, 28*28 크기의 이미지를 1차원 배열로 평탄화한다. 후에 sklearn의 train_test_split() 메서드를 사용해 train과 validate 세트로 나누자.

from sklearn.model_selection import train_test_split
train_scaled = train_input / 255.0
train_scaled = train_scaled.reshape(-1, 28*28)
train_scaled, val_scaled, train_target, val_target = train_test_split(train_scaled, train_target, test_size=0.2, random_state=42)

이제 인공 신경망 모델에 층을 2개 추가하겠다. 이 전의 신경망 모델과 다른 점은 입력층과 출력층 사이에 밀집층이 추가된 것이다. 이렇게 입력층과 출력층 사이에 있는 모든 층을 은닉층(Hidden Layer)이라고 부른다.

은닉층에는 활성화 함수가 항상 적용된다. 출력층에 적용하는 활성화 함수는 이진 분류일 경우에는 시그모이드, 다중 분류일 경우에는 소프트맥스 함수로 제한된다. 하지만 은닉층의 활성화 함수는 출력층에 비해 비교적 자유롭다. 대표적으로 시그모이드 함수와 렐루 함수 등을 사용한다.

다음은 밀집층을 구현하는 코드이다.

dense1 = keras.layers.Dense(100, activation='sigmoid', input_shape=(784,))
dense2 = keras.layers.Dense(10, activation='softmax')

dense1이 은닉층이며, 100개의 뉴런을 가진 밀집층이다. 활성화함수는 시그모이드이며, 입력의 크기는 (784,)로 지정하였다. 은닉층의 뉴런 개수를 정하는 데는 특별한 기준은 없다. 하지만 적어도 출력층의 뉴런보다는 많아야 한다.

dense2는 출력층이다. 10개의 클래스를 분류하므로 10개의 뉴런을 두었고, 활성화 함수는 소프트맥스로 지정하였다.

이제 앞에서 만든 dense1과 dense2 객체를 Sequential 클래스에 추가하여 심층 신경망(DNN)을 만들어 본다.

model = ([dense1, dense2])

여기에서 주의해야 할 것은 출력층(dense2)을 마지막에 두어야 한다.

층을 추가하는 다른 방법이다.

model = keras.Sequential([keras.layers.Dense(100, activation='sigmoid', input_shape=(784,), name='hidden'), keras.layers.Dense(10, activation='softmax', name='output')]
, name='패션 MNIST 모델')

dense1, dense2같은 밀집 층은 따로 사용할 일이 없기 때문에 이렇게 직접 Sequential 클래스 안에 전달한다.

또 다른 방법은 다음과 같다.

model = keras.Sequential()
model.add(keras.layers.Dense(100, activation='sigmoid', input_shape=(784,), name='hidden'))
model.add(keras.layers.Dense(10, activation='softmax', input_shape=(784,), name='output'))

이렇게 Sequential 클래스 객체를 생성 후, add 메서드를 이용하여 층을 추가하는 방법이 있다.

이 방법은 추가되는 방법을 한 눈으로 볼 수 있으며, 프로그램 실행 시 동적으로 층을 선택하여 추가할 수 있기 때문에 유용하다.

이제 모델을 학습시켜보자.

model.compile(loss='sparse_categorical_crossentropy', metrics='accuracy')
model.fit(train_scaled, train_target, epochs=5)

#출력
Epoch 1/5
1500/1500 [==============================] - 2s 985us/step - loss: 0.5661 - accuracy: 0.8088
Epoch 2/5
1500/1500 [==============================] - 1s 957us/step - loss: 0.4087 - accuracy: 0.8527
Epoch 3/5
1500/1500 [==============================] - 1s 905us/step - loss: 0.3746 - accuracy: 0.8648
Epoch 4/5
1500/1500 [==============================] - 1s 916us/step - loss: 0.3519 - accuracy: 0.8721
Epoch 5/5
1500/1500 [==============================] - 1s 916us/step - loss: 0.3346 - accuracy: 0.8790
<keras.callbacks.History at 0x7fe0b2e856d0>

이 전의 성능에 비해 이렇게 추가된 층이 성능을 향상시켰다는 것을 알 수 있다.

렐루 함수

인공 신경망의 은닉층에 많이 사용된 활성화 함수는 시그모이드 함수였다. 하지만 이 함수에도 단점이 있다. 시그모이드 함수는 입력이 매우 크거나, 매우 작을 때 기울기가 매우 작아질 수 있다. 이 문제는 가중치를 업데이트 하는데 상당한 문제를 일으킬 수 있다.

특히 층이 많은 심층 신경망일수록 그 효과가 누적되어 학습을 더 어렵게 만들 수 있다. 이를 개선하기 위해 나온 함수가 ReLU 함수이다. 렐루 함수는 입력이 양수일 경우 그냥 입력을 통과시키고, 음수일 경우에는 0을 만든다.

이 함수는 max(0, z)와 같이 쓸 수 있다. z가 0보다 크면 z를 출력하고, z가 0보다 작으면 0을 출력한다.

렐루 함순믄 특히 이미지 처리에서 좋은 성능을 낸다고 알려져 있다.

위에서 우리는 28*28을 reshape() 메서드를 사용하여 1차원 데이터로 평탄화하는 작업을 진행하였다. 하지만 케라스에서 더욱 유용한 기능을 제공한다.

Flatten 클래스는 입력 차원을 모두 일렬로 펼치는 역할을 한다. Flatten 클래스는 입력층과 은닉층 사이에 추가하기 때문에 이를 층이라고 부른다. Flatten 층은 다음 코드처럼 입력층 바로 뒤에 추가한다.

model = keras.Sequential()
model.add(keras.layers.Flatten(input_shape=(28, 28)))
model.add(keras.layers.Dense(100, activation='relu'))
model.add(keras.layers.Dense(10, activation='softmax'))

이런 식으로 Flatten 층을 추가하면 된다. 하지만 우리는 위에서 이미 평탄화 작업을 진행하였기 때문에 데이터를 다시 불러온 후 모델 학습을 진행시킨다.

(train_input, train_target), (test_input, test_target) =\
keras.datasets.fashion_mnist.load_data()
train_scaled = train_input / 255.0
train_scaled, val_scaled, train_target, val_target = train_test_split(train_scaled, train_target, test_size=0.2, random_state=42)

model.compile(loss='sparse_categorical_crossentropy', metrics='accuracy')
model.fit(train_scaled, train_target, epochs=5)

#출력
Epoch 1/5
1500/1500 [==============================] - 2s 914us/step - loss: 0.5370 - accuracy: 0.8106
Epoch 2/5
1500/1500 [==============================] - 1s 909us/step - loss: 0.3953 - accuracy: 0.8566
Epoch 3/5
1500/1500 [==============================] - 1s 913us/step - loss: 0.3571 - accuracy: 0.8707
Epoch 4/5
1500/1500 [==============================] - 1s 904us/step - loss: 0.3359 - accuracy: 0.8801
Epoch 5/5
1500/1500 [==============================] - 1s 936us/step - loss: 0.3197 - accuracy: 0.8849
<keras.callbacks.History at 0x7fe0b2f6cf10>

model.evaluate(val_scaled, val_target)

#출력 
375/375 [==============================] - 0s 688us/step - loss: 0.3731 - accuracy: 0.8787
[0.37310147285461426, 0.8786666393280029]

옵티마이저

딥러닝의 학습에서는 최대한 틀리지 않는 방향으로 학습해 나가야 한다.

여기서 얼마나 틀리는지(loss)를 알게 하는 함수가 loss function=손실함수이다. loss function의 최소값을 찾는 것을 학습의 목표로 한다.

여기서 최소값을 찾아가는 것을 최적화=Optimization 이라고 하고 이를 수행하는 알고리즘이 최적화 알고리즘=Optimizer 이다.

즉 최적의 경사 하강법 알고리즘을 선택하는 것이다.

다음은 옵티마이저의 종류이다.

어떤 옵티마이저를 사용해야 할 지 모를 때에는 Adam을 사용하라. 라는 말이 있다. Adam이 가장 일반적이며, 성능이 좋은 옵티마이저다. 다음은 옵티마이저를 adam으로 설정한 후 모델을 학습시키는 코드이다.

model = keras.Sequential()
model.add(keras.layers.Flatten(input_shape=(28, 28)))
model.add(keras.layers.Dense(100, activation='relu'))
model.add(keras.layers.Dense(10, activation='softmax'))

model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics='accuracy')
model.fit(train_scaled, train_target, epochs=5)

#출력값
Epoch 1/5
1500/1500 [==============================] - 1s 871us/step - loss: 0.5328 - accuracy: 0.8143
Epoch 2/5
1500/1500 [==============================] - 1s 932us/step - loss: 0.3991 - accuracy: 0.8581
Epoch 3/5
1500/1500 [==============================] - 1s 957us/step - loss: 0.3553 - accuracy: 0.8712
Epoch 4/5
1500/1500 [==============================] - 1s 901us/step - loss: 0.3258 - accuracy: 0.8807
Epoch 5/5
1500/1500 [==============================] - 1s 953us/step - loss: 0.3075 - accuracy: 0.8859
<keras.callbacks.History at 0x7fe0b2eebf70>

model.evaluate(val_scaled, val_target)

#출력값
375/375 [==============================] - 0s 686us/step - loss: 0.3435 - accuracy: 0.8780
[0.34353795647621155, 0.878000020980835]

from tensorflow import keras
(train_input, train_target), (test_input, test_target) =\
     keras.datasets.fashion_mnist.load_data()

데이터의 크기를 확인한다.

print(train_input.shape, train_target.shape)
#출력값: (60000, 28, 28) (60000,)

print(test_input.shape, test_target.shape)
#출력값: (10000, 28, 28) (10000,)

위의 train 데이터는 2828의 픽셀로 되어있는 이미지가 총 6만개가 있고, test 데이터는 2828 픽셀로 되어있는 이미지가 총 10000개가 있다는 뜻이다.

다음은 10개의 데이터만 이미지로 출력하는 코드이다.

import matplotlib.pyplot as plt
fig, axs = plt.subplots(1, 10, figsize=(10, 10))
for i in range(10):
    axs[i].imshow(train_input[i], cmap='gray_r')
    axs[i].axis('off')

plt.show()

출력결과

다음은 target에 대한 데이터이다.

print(train_target[:10])
#출력값: [9 0 0 3 0 2 7 2 5 5]

MNIST의 타깃은 0~9로 이루어진 레이블로 구성되어 있다. 각 숫자는 다음을 의미한다.

Tensorflow는 구글이 오픈소스로 공개한 딥러닝 라이브러리이다. 텐서플로에는 저수준 API와 고수준 API가 있다. 바로 Keras가 텐서플로의 고수준 API이다.

딥러닝 라이브러리가 다른 머신러닝 라이브러리와 다른 점 중 하나는 그래픽 처리 장치인 GPU를 사용하여 인공 신경망(ANN)을 학습한다는 것이다. GPU는 벡터와 행렬 연산에 매우 최적화되어 있기 때문에 곱셈과 덧셈이 많이 수행되는 인공 신경망에 큰 도움이 된다.

하지만 케라스 라이브러리는 직접 GPU 연산을 수행하지 않습니다. 대신 GPU 연산을 수행하는 다른 라이브러리를 백엔드로 사용한다. 예를 들면 텐서플로가 케라스의 백엔드 중 하나이다.

다른 머신러닝 모델에서는 교차 검증을 사용하여 모델을 평가했지만, 인공 신경망에서는 교차 검증을 잘 사용하지 않고, 검증 세트를 별도로 덜어내어 사용한다.

그 이유는 다음과 같다.

1. 딥러닝 분야의 데이터셋은 충분히 크기 때문에 검증 점수가 안정적이다.
2. 교차 검증을 수행하기에는 학습 시간이 너무 오래걸리기 때문이다.

따라서 검증 세트를 따로 나누기 위하여 sklearn의 train_test_split() 메서드를 사용한다

from sklearn.model_selection import train_test_split
train_scaled, val_scaled, train_target, val_target = train_test_split(train_scaled, train_target, test_size=0.2, random_state=42)

우리는 현재 10개의 클래스를 가지고 있는 데이터를 사용하기 때문에, 최종적으로 나오는 뉴런의 개수(출력층)은 10개의 뉴런으로 구성된다.

다음은 케라스의 Dense 클래스를 사용하여 밀집층을 생성한다.

#밀집층 클래스인 Dense 클래스를 사용하여 밀집층을 생성.
#뉴런의 개수: 10개, 누련의 출력에 적용할 함수: softmax, 데이터 입력의 크기: 784*1
dense = keras.layers.Dense(10, activation='softmax', input_shape=(784,))

첫 번째 매개변수로는 뉴런의 개수를 10개로 지정한다. 10개의 패션 아이템으로 분류하기 때문이다. 10개의 뉴런에서 출력된 값을 확률로 바꾸기 위해서는 Softmax함수를 사용한다. 만약 2개의 클래스를 분류하는 이진 분류라면 Sigmoid함수를 사용해야 한다. 마지막으로 세 번째 매개변수는 입력값의 크기이다.

위의 코드를 실행시키면 인공 신경망의 밀집층을 구현한 것이다. 이제 이 밀집층을 가진 신경망 모델을 만들어야 한다. 케라스의 Sequential 클래스를 사용한다.

#Sequential 클래스에 밀집층의 객체 dense를 전달하여 신경망 모델인 model 객체 생성.
model = keras.Sequential(dense)

Sequential 클래스의 객채에 밀집층의 객체 dense를 전달했다. 여기에서 만든 model 객체가 바로 신경망 모델이다. 다음 그림에 지금까지 만든 신경망을 나타냈다. 마지막에 소프트맥스 함수를 적용한 것을 주목해라.

소프트맥스와 같이 뉴런의 선형 방정식 계산 결과에 적용되는 함수를 활성화 함수라 부른다.

지금까지 신경망 모델을 생성하였다. 이제 우리가 가지고 있는 학습용 데이터로 학습을 시키면 된다. 하지만 케라스 모델은 학습을 하기 전, 설정 단계가 필요하다. 이런 설정을 model 객체의 compile() 메서드에서 수행한다. 꼭 지정해야 할 것은 손실 함수의 종류이다. 다음은 compile()메서드를 이용하여 설정하는 코드이다.

model.compile(loss='sparse_categorical_crossentropy', metrics='accuracy')

• 이진 분류에서는 binary_crossentropy(이진 크로스 엔트로피 손실함수)를 사용한다.
• 다중 분류에서는 categorical_crossentropy(크로스 엔트로피 손실 함수)를 사용한다.

케라스에서는 위의 두 손실 함수를 사용한다.

케라스 모델의 다중 분류는 다음과 같이 확률을 계산한다.

출력층은 10개의 뉴런이 있고, 10개의 클래스에 대한 확률을 출력한다. 첫 번째 뉴런은 티셔츠일 확률이고, 두 번째 뉴런은 바지일 확률을 출력한다. 이진 분류와 달리 각 클래스에 대한 모든 확률이 모두 출력되기 때문에 타깃에 해당하는 확률만 남겨 놓기 위해서 나머지 확률에는 모두 0을 곱한다.

예를 들어, 첫 번째 뉴런으로 분류가 되었다면, 첫 번째 뉴런의 활성화 함수 출력인 a1에 크로스 엔트로피 손실 함수를 적용하고, 나머지 활성화 함수 출력 a2~a10까지는 전부 0으로 만든다.

이와 같이 타깃값을 1로, 나머지는 모두 0으로 만드는 것을 One-Hot Encoding이라 한다.

다중 분류에서 크로스 엔트로피 손실 함수를 사용하려면 0,1,2와 같은 정수로 되어야 한다. 이러한 정수로된 타깃값을 사용해 크로스 엔트로피 손실을 계산하는 것이 바로 sparse_categorical_crossentropy이다.

케라스는 모델이 훈련할 때마다 기본으로 에포크마다 손실 값을 출력해준다. 손실이 줄어드는 것을 보고 훈련이 잘되었다는 것을 알 수 있지만, 정확도와 함께 출력이 된다면 더욱 더 좋을 것이다.

이를 위해 metrics 파라미터에 정확도 지표를 의미하는 accuracy를 지정한다.

이제 모델을 학습시켜야 한다. 다음은 케라스 모델을 학습시키는 코드이다.

#model 학습, epoch는 5로 설정.
model.fit(train_scaled, train_target, epochs=5)

#출력
Epoch 1/5
1500/1500 [==============================] - 1s 529us/step - loss: 0.4792 - accuracy: 0.8395
Epoch 2/5
1500/1500 [==============================] - 1s 524us/step - loss: 0.4570 - accuracy: 0.8481
Epoch 3/5
1500/1500 [==============================] - 1s 528us/step - loss: 0.4444 - accuracy: 0.8515
Epoch 4/5
1500/1500 [==============================] - 1s 525us/step - loss: 0.4372 - accuracy: 0.8557
Epoch 5/5
1500/1500 [==============================] - 1s 527us/step - loss: 0.4316 - accuracy: 0.8576

이제 앞에서 분리한 검증 세트에서 모델의 성능을 확인해보겠다. 다음은 케라스 모델의 성능을 평가하는 코드이다.

#학습된 model의 검증.
model.evaluate(val_scaled, val_target)

#출력
375/375 [==============================] - 0s 468us/step - loss: 0.4468 - accuracy: 0.8524
[0.4468023180961609, 0.8524166941642761]

Support Vector Machie(SVM)은 결정 경계(Decision Boundary)를 정의하는 모델이다.

다음 군집을 이루고 있는 데이터의 결정 경계는 다음과 같은 간단한 일차선 형태가 될 것이다.

하지만 차원이 3차원으로 늘어난다면 결정 경계는 다음과 같이 평면의 평태가 될 것이다.

우리는 시각적으로 인지할 수 있는 범위는 딱 3차원까지이다. 차원, 즉 속성의 개수가 늘어나면 늘어날수록 복잡해질 것이다. 결정 경계도 단순한 평면이 아닌 고차원의 형태가 될 것인데 이를 초평면(Hyperplane)이라 한다.

위의 사진은 똑같은 데이터에 각자 다른 결정 경계를 표시한 사진이다. 어떤 선이 최적의 결정 경계일까?. Graph F가 될 것이다. 두 클래스 사이의 거리가 가장 멀기 때문이다. 이처럼 결정 경계는 군집으로부터 최대한 멀리 떨어지는 것이 좋다. 이 거리를 Margin이라 한다.

즉 최적의 결정 경계는 마진을 최대화하는 것이다. 마진의 크기를 최대화하려면 이상치(Outlier)을 잘 다루는 것이 중요하다. 다음 사진들을 확인해보자.

위의 그림은 이상치를 허용하지 않은 상태이다. 이것을 Hard Margin이라 부른다. 그리고 해당 경우는 마진이 매우 작아진다. 이러한 Hard Margin은 Margin이 작아지는 것 뿐만 아니라, 학습 데이터에 대한 Overfitting 문제가 발생할 수 있다.

아래의 그림은 이상치를 어느정도 허용한 상태이다. 이것을 Soft Margin이라 부른다. 그리고 해당 경우는 마진이 커진다.. 이러한 Soft Margin은 Margin이 증가하지만, 학습 데이터에 대한 Underfitting 문제가 발생할 수 있다.

지금까지는 Linear의 결정 경계에 대한 데이터셋으로 예시를 들었다. 하지만 일상생활에서 Linear한 데이터는 거의 없을 것이다. 만약 이러한 데이터셋이 있다면 어떨까?

해당 데이터셋은 직선이 아닌, 원으로 그려야 할 것이다. 이러한 데이터셋을 위하여, SVM 모델은 Kernel을 선택할 수 있다.

1. 다항식 (Polynomial)

2. 방사 기저 함수 (Radial Bias Function: RBF)

RBF Kernel 혹은 Gaussian Kernel이라 부른다. 이 커널은 sciklit-learn의 SVC모델의 Default에 해당된다. RBF 커널은 2차원의 점을 무한한 차원의 점으로 변환하는 알고리즘이다.

SVM에서 마진을 최대화하기 위해서는 이상치를 허용하는 방법도 있지만, gamma라는 파라미터를 사용하는 방법이 있다. gamma는 결정 경계를 얼마나 유연하게 그리는가를 정해주는 것이다.

• gamma 값을 높이면 학습 데이터에 많이 의존을 하여, 결정 경계가 구불구불 해진다. 이는 Overfitting을 초래할 수 있다.

• gamma 값을 낮추면 학습 데이터에 별로 의존을 하지 않아, 결정 경계가 직선에 가깝게 된다. 이는 Underfitting을 초래할 수 있다.

gamma가 높은 경우

gamma가 낮은 경우

사람은 음성을 인식할 때 달팽이관에서 각기 다른 주ㅜ파수를 감지한다. 하지만 사람의 달팽이관은 주파수가 낮은 대역에서의 변화는 잘 감지하지만, 주파수가 높은 대역에서는 그렇지 못하다. 이러한 사람의 달팽이관의 특성을 고려하여 음성데이터에서 특징을 추출한 값이 Mel-Scale이다.

또한 사람은 똑같은 문장을 말해도 각자 다른 속도로 말하기 때문에 이러한 각기 다른 음성데이터를 학습시키기에는 어려움이 있다. 이러한 특징에 의하여, 음성 데이터를 전부 20ms40ms로 분할한다. 여러 연구에 의하면 사람은 20ms40ms 사이에서는 음소가 바뀔 수 없다는 연구결과가 있다. 이러한 특징점을 이용하여 음성 데이터를 분석하는 알고리즘이 바로 Mel Frequency Cepstral Coefficients이다.

그렇다면 MFCC는 어떻게 할까? 다음 단계와 같이 진행을 한다.

1. Pre-Emphasis 사람은 발성 시 신체적 구조때문에 실제로 낸 소리에서 고주파 성분이 많이 줄어들어서 나온다고 한다. 그래서 먼저 줄어든 고주파 성분을 강조하기 위하여 고주파 신호는 더 강조하며, 저주파 신호는 약화하는, 즉 High-Pass Filter이다.

2. Sampling and Windowing 아까 언급했다시피 음성 신호를 20ms40ms단위로 분할한다고 하였다. 이 단계에서 음성 신호를 20ms40ms 단위의 Frame으로 분할한다. 여기에서 Frame을 일부러 겹치게 분할을 해야 한다. 그 이유는 이 과정을 안하고 샘플링시, 프레임과 프레임의 접합 부분에서 순간 변화율이 무한대로 나올 수 있다. 이러한 부분을 방지하기 위한 것이다.

후에 이 프레임에 대해 Windowing을 각각 적용한다. 여러 Window가 존재하지만 보통 Hamming Window를 많이 사용하곤 한다.

3. Fast Fourier Transform (FFT) 푸리에 변환은 주파수를 추출할 때 대표적으로 사용하는 알고리즘이다. 해당 알고리즘을 사용해 음성 데이터에 대한 주파수 성분을 얻어낸다.

4. Mel Filter Bank 각각 프레임에 대해 얻어낸 주파수들에 대한 Mel값을 얻기 위하여 해당 FIlter을 사용한다. 해당 주파수에 따른 Filter의 차이가 있는데, 고주파 대역으로 갈수록 넓은 삼각형의 Filter을 사용하게 된다. 그래서 모든 Frame이 삼각형 Filter을 통과하게 된다면, Mel-Spectrogram이라는 Feature가 뽑히게 된다.

5. Discrete Cosine Transform (DCT) 연산 4번에서 나온 결과물인 Mel-Spectrogram이라는 feature에 대해 행렬을 압축해서 표현하는 DCT연산을 진행한다. 그러면 Output으로 우리가 구하고자 하는 Mel-Frequency Cepstral Coefficients가 나오게 된다.

이 MFCC값을 이용하여 여러 가지 머신러닝, 딥러닝 모델에 학습시킬 수 있다.