EeS 의 연구실

항해 플러스 코육대 참여 회고

C.Moon — Tue, 3 Oct 2023 22:27:07 +0900

기능 구현 및 설명

이번 코육대를 참여하며, 기존에 한번도 해보지 않은 분야인 FE 로 도전해보기로 하였으며, 특히 React 학습에 중점을 두었다.
결코(ㅋㅋㅋ) 좋은 코드라 할 수 없는 부분도 많지만, 경력과 무관하게, 일주일만의 React 도전기 라는걸 감안하며 봐주면 감사드리겠다.

가장 중요시한 부분

개인적으로 FE 개발 결과물을 평가해야 할 때 가장 중요시 하는 부분은, 웹은 이용자가 어떤 사이즈로 볼지 알 수 없다는 부분이었다.
그러다보니, 반응형 웹 개발에 가장 많은 시간을 쏟게 되었다.

반응형 구현

아래는 일부 예시이다.

#HiddenWord{
    position: relative;
    width: 100%;
    text-align: center;
    font-size: 4vh;
    font-weight: bold;
    margin-top: 0.5em;
    margin-bottom: 0.5em;
}

예시와 같이, font-size 등도 모두 vh 또는 vw 를 사용하여 화면 크기에 따라 다른 크기로 변화하도록 설계하였다.
다양한 사이즈에서 동적으로 허용되는걸 확인하였다.

State 구현

  const [selectedWord, setSelectedWord] = useState("");
  const [hiddenWord, setHiddenWord] = useState([]);
  const [disabledAlphabets, setDisabledAlphabets] = useState([]);
  const [errorCount, setErrorCount] = useState(0);
  //gameStatus 0:start, 1:win, 2:lose
  const [gameStatus, setGameStatus] = useState(0);

위 예시에서와 같이, 각종 값들은 React의 State 를 사용하여 관리하였다. State 라는 개념이 처음엔 다소 어색했는데, 사용하다보니 익숙해지기는 개뿔 여전히 객체지향이 그립다.

Hanging Man

생각보다 공을 들인 부분이 HangingMan 의 구현이다.
이거 하드코딩아닌 하드코딩아닌 하드코딩으로 해놨다.

const renderHangingMan = () => {
    return (
      <svg height="100%" width="100%" viewBox="0 0 250 200">
        {/* Base */}
      <path d="M 50 200 Q 75 190 150 200" style={{stroke:"#000", strokeWidth:4, fill:"none"}} />
      {/* Vertical Pole */}
      {errorCount > 0 && <path d="M 100 200 Q 105 125 100 50" style={{stroke:"#000", strokeWidth:3, fill:"none"}} />}
      {/* Horizontal Pole */}
      {errorCount > 0 && <path d="M 100 50 Q 125 45 150 50" style={{stroke:"#000", strokeWidth:3, fill:"none"}} />}
      {/* Rope */}
      {errorCount > 1 && <path d="M 140 50 Q 142 60 140 70" style={{stroke:"#000", strokeWidth:3, fill:"none"}} />}
      {/* Head */}
      {errorCount > 2 && <circle cx="140" cy="80" r="10" style={{stroke:"#000", strokeWidth:2, fill:"#fff"}} />}
      {/* Arms */}
      {errorCount > 3 && <path d="M 140 90 Q 145 100 160 110" style={{stroke:"#000", strokeWidth:2, fill:"none"}} />}
      {errorCount > 3 && <path d="M 140 90 Q 135 100 120 110" style={{stroke:"#000", strokeWidth:2, fill:"none"}} />}
      {/* Hands */}
      {errorCount > 4 && <circle cx="162" cy="112" r="2" style={{stroke:"#000", strokeWidth:3, fill:"#fff"}} />}
      {errorCount > 4 && <circle cx="118" cy="112" r="2" style={{stroke:"#000", strokeWidth:3, fill:"#fff"}} />}   
      {/* Body */}
      {errorCount > 5 && <path d="M 140 90 Q 140 100 140 120" style={{stroke:"#000", strokeWidth:2, fill:"none"}} />}
      {/* Legs */}
      {errorCount > 6 && <path d="M 140 120 Q 145 130 160 140" style={{stroke:"#000", strokeWidth:2, fill:"none"}} />}
      {errorCount > 6 && <path d="M 140 120 Q 135 130 120 140" style={{stroke:"#000", strokeWidth:2, fill:"none"}} />}
      {/* Feet */}
      {errorCount > 7 && <ellipse cx="162" cy="142" rx="4" ry="2" style={{stroke:"#000", strokeWidth:3, fill:"#fff"}} />}
      {errorCount > 7 && <ellipse cx="118" cy="142" rx="4" ry="2" style={{stroke:"#000", strokeWidth:3, fill:"#fff"}} />}

        {/* Eyes */}
        {errorCount > 2 && errorCount <= 7 && (
          <>
            <circle cx="137" cy="78" r="1" style={{fill:"#000"}} />
            <circle cx="143" cy="78" r="1" style={{fill:"#000"}} />
          </>
        )}
        {/* Angry Eyebrows when 5 errors */}
        {errorCount > 4 && errorCount <= 7 && (
          <>
            <line x1="136" y1="76" x2="138" y2="74" style={{stroke:"#000", strokeWidth:1}} />
            <line x1="144" y1="76" x2="142" y2="74" style={{stroke:"#000", strokeWidth:1}} />
          </>
        )}
        {/* Mouth */}
        {errorCount > 2 && errorCount <= 7 && (
          <line x1="137" y1="83" x2="143" y2="83" style={{stroke:"#000", strokeWidth:1}} />
        )}
        {errorCount > 7 && (
          <>
            {/* Eyes turned into X */}
            <line x1="135" y1="76" x2="139" y2="80" style={{stroke:"#000", strokeWidth:1}} />
            <line x1="135" y1="80" x2="139" y2="76" style={{stroke:"#000", strokeWidth:1}} />
            <line x1="141" y1="76" x2="145" y2="80" style={{stroke:"#000", strokeWidth:1}} />
            <line x1="141" y1="80" x2="145" y2="76" style={{stroke:"#000", strokeWidth:1}} />
          </>
        )}
      </svg>
    );
  };

이거 맞냐구요?
아뇨 오답 같은데요... 근데 돌잖아요?

SVG로 그려낸 행맨인데, 여기에 React 잖아? 조건문을 박아버렸다.
CSS로 행맨을 State 에 따라 구워낸다. 이거 맞아? 아뇨 뚱인데요.

Game Status

처음엔 게임 상태를 찾아내는걸 매번 조건문으로 했었다. 그러다가 발견한 useEffect 님이 나를 구원하셨으니...

  //Check game status
  useEffect(() => {
    if (errorCount >= 8) {
      setGameStatus(2);
    } else if (!hiddenWord.includes("_")) {
      setGameStatus(1);
    } else {
      setGameStatus(0);
    }
  }, [errorCount, hiddenWord]);

이제 errorCount 와 hiddenWord 에 따라 알아서! GameStatus 가 변경된다.
이게 기적이지...

기타 제약조건들

행맨의 제약조건들은 아래와 같다.
출처 : 항해 플러스 : 제 1회 코육대

미션

가족들이 함께 볼 수 있도록 프론트도 구현해서 배포하세요.
문제를 선택할 수 있도록 영어 단어를 랜덤으로 3개 띄워주세요.
선택한 문제의 단어를 글자 단위로 숨깁니다. (e.g., "apple" -> "_ _ _ _ _")
화면에 26개 알파벳을 띄워주세요.
선택한 알파벳과 정답을 비교합니다.
일치하는 알파벳이 있을 경우 기존 UI에서 사라지고 해당 위치에 표시됩니다.
틀릴 경우 기존 위치에서 알파벳이 빨간색으로 바뀌고, 오류 횟수를 증가시킵니다.
오류 날 때마다 ‘교수대-밧줄-머리-팔-손-몸통-다리-발’ 순서로 그려서 그림이 완성되면 ‘실패’ 를 띄웁니다. (오류 횟수 8번 이상은 실패)

제약 사항

랜덤으로 띄워주기 위해 영어 단어는 30개 이상 등록되어 있어야 합니다.
등록된 영어 단어의 글자 수는 최대 10개입니다.
사용자가 모든 글자를 맞추거나 오류 횟수가 8번 이상일 경우 게임이 종료됩니다.
게임이 종료되면 정답을 표시하고 결과 메시지를 출력하세요.

이걸 맞춰나가는건 어렵지 않아서 딱히 할말이 없을 무 이시겠다.
하다가 막히면, 챗지피티 님이 도와주신다. 챗멘.

참여 소감

이렇게 누가 등 떠밀지 않으면, 새로운 기술스택은 쌓이질 않는다.
기회 만들어준 항해 플러스에게 감사를 드리며, 태어나서 처음 작성해본 FE 결과물 특히 React 는 진짜 머리털 나고 처음이니 이쁘게 봐주시길 바란다.

문제시 일단 머리털을 밀어보겠다.
그럼 머리털 나고 처음만큼은 실현(강제) 되지 않겠나?

조금 불평좀 하자면,

참여 링크

항해 플러스 : 제 1회 코육대

Bessel 타원의 변경 (localdata.go.kr 제공 데이터 오차 보정)

C.Moon — Sat, 20 Feb 2021 01:24:30 +0900

최근 회사에서 주로 다루는 데이터는 GIS(Geographic Information System) 데이터 이다.

국내 위치 데이터를 다루는 분들 이라면 다 아실, localdata.go.kr 에서 데이터를 내려받아 사용 중 인데...

x, y 좌표가 어떤 좌표계 인지 정보가 없다.

좌표계?

지구는 완벽한 원이 아닌 타원형 이다.
사실, 타원조차 아닌 감자 처럼 찌그러진 모양이다. 

따라서, 지구를 타원형인 타원체(Ellipsoid)로 정의하여 해당 타원에서의 위치를 표현하게 된다.
이 때, 어떤 타원체를 사용할지/어떤 기준점을 사용할지를 정의하게 되는데

이를 좌표계 라고 부른다.

우리가 많이 사용하는 위경도 도 좌표계의 일종으로 WGS84 라고 부른다.

따라서, 열심히 서치를 하다 보면, 이런 글을 발견하게 되는데,

중부원점TM...??

여기서 EPSG 란, 다양한 좌표계의 코드로 이해하면 된다! (ex. 위경도계, WGS84 는 epsg:4326 이다!)

중부원점TM은 Bessel 타원을 사용하는 좌표계이다.

그런데 말입니다

제공되는 데이터를 epsg:2097 기준으로 위경도계(epsg:4326) 으로 변경하면, 몇백미터 다른 위치에 있는 위치로 표기가 되는걸 확인 가능하다.

대체 무슨일이 벌어지고 있는걸까?

앞에서, 지구를 특정한 타원체로 정의해서 위치를 표기한다고 했는데, 타원체 끼리는 당연히 오차가 발생할 수 있다.

국제 표준 타원체는 Bessel 타원체(TM타원체)가 아닌 UTM타원체 이므로 차이가 발생하는 것 이다.

사실, 이는 미미한 차이이다. 그런데 왜 몇백미터나 되는 차이가 발생하게 될까?

좌표계는 정해진 원점으로부터 삼각측량을 통해 정해지게 되는데, 이 중 중부원점 이란, 경기도 연천에 있는 원점이다. 헌데, 과거 측량 당시 기술의 한계로 오차가 발생하였다고 한다.

https://linuxism.ustd.ip.or.kr/833

그럼, 오차를 보정하는 방법은 없을까?

사실 이미 보정하여, 새로운 epsg 코드를 부여한 상태이다.

EPSG:5174 가 그것이다.

중부원점 이외에도, 일본에 있는 동부원점, 제주에 있는 제주원점, 울릉도에 있는 울릉원점 등도 모두 보정된 좌표계가 존재한다.

*보정된 서부원점(Bessel) - KLIS에서 서부지역에 사용중

EPSG:5173

+proj=tmerc +lat_0=38 +lon_0=125.0028902777778 +k=1 +x_0=200000 +y_0=500000 +ellps=bessel +units=m +no_defs +towgs84=-115.80,474.99,674.11,1.16,-2.31,-1.63,6.43

*보정된 중부원점(Bessel): KLIS에서 중부지역에 사용중

EPSG:5174

+proj=tmerc +lat_0=38 +lon_0=127.0028902777778 +k=1 +x_0=200000 +y_0=500000 +ellps=bessel +units=m +no_defs +towgs84=-115.80,474.99,674.11,1.16,-2.31,-1.63,6.43

*보정된 제주원점(Bessel): KLIS에서 제주지역에 사용중

EPSG:5175

+proj=tmerc +lat_0=38 +lon_0=127.0028902777778 +k=1 +x_0=200000 +y_0=550000 +ellps=bessel +units=m +no_defs +towgs84=-115.80,474.99,674.11,1.16,-2.31,-1.63,6.43

*보정된 동부원점(Bessel): KLIS에서 동부지역에 사용중

EPSG:5176

+proj=tmerc +lat_0=38 +lon_0=129.0028902777778 +k=1 +x_0=200000 +y_0=500000 +ellps=bessel +units=m +no_defs +towgs84=-115.80,474.99,674.11,1.16,-2.31,-1.63,6.43

*보정된 동해(울릉)원점(Bessel): KLIS에서 울릉지역에 사용중

EPSG:5177

+proj=tmerc +lat_0=38 +lon_0=131.0028902777778 +k=1 +x_0=200000 +y_0=500000 +ellps=bessel +units=m +no_defs +towgs84=-115.80,474.99,674.11,1.16,-2.31,-1.63,6.43

출처: https://www.osgeo.kr/17 [OSGeo(Open Source GeoSpatial) 한국어 지부 - OSGeo Korean Chapter]

그럼 여기서 의문이 생긴다...

localdata.go.kr 에서는 왜... 보정 안된 좌표계로 안내해 줬을까...

그건 우리가 영원히 풀어야 할 숙제 일지도 모른다...

WGS84와 앞서 적은 Bassel 좌표계 만이 존재할까?

아니다.(왜?)
이번에 확인한 바와 같이, 기존 좌표계는 오차가 생기므로, 
국제적 표준 타원체인 GRS80(WGS84 타원체와 거의 같은 타원체)
를 사용하는 다른 표준을 많이 사용한다.

*서부원점(GRS80)-falseY:50000
EPSG:5180

+proj=tmerc +lat_0=38 +lon_0=125 +k=1 +x_0=200000 +y_0=500000 +ellps=GRS80 +units=m +no_defs



*중부원점(GRS80)-falseY:50000: 다음지도에서 사용중인 좌표계

EPSG:5181

+proj=tmerc +lat_0=38 +lon_0=127 +k=1 +x_0=200000 +y_0=500000 +ellps=GRS80 +units=m +no_defs



*제주원점(GRS80)-falseY:55000

EPSG:5182

+proj=tmerc +lat_0=38 +lon_0=127 +k=1 +x_0=200000 +y_0=550000 +ellps=GRS80 +units=m +no_defs



*동부원점(GRS80)-falseY:50000

EPSG:5183

+proj=tmerc +lat_0=38 +lon_0=129 +k=1 +x_0=200000 +y_0=500000 +ellps=GRS80 +units=m +no_defs



*동해(울릉)원점(GRS80)-falseY:50000

EPSG:5184

+proj=tmerc +lat_0=38 +lon_0=131 +k=1 +x_0=200000 +y_0=500000 +ellps=GRS80 +units=m +no_defs


그럼 위 좌표계가 전부일까?

아니다.(왜?)

한반도 전체를 하나의 좌표계로 나타낼 때 많이 사용하는 좌표계입니다.

*UTM-K (Bessel): 새주소지도에서 사용 중

EPSG:5178

+proj=tmerc +lat_0=38 +lon_0=127.5 +k=0.9996 +x_0=1000000 +y_0=2000000 +ellps=bessel +units=m +no_defs +towgs84=-115.80,474.99,674.11,1.16,-2.31,-1.63,6.43


*UTM-K (GRS80): 네이버지도에서 사용중인 좌표계

EPSG:5179

+proj=tmerc +lat_0=38 +lon_0=127.5 +k=0.9996 +x_0=1000000 +y_0=2000000 +ellps=GRS80 +units=m +no_defs 


출처: https://www.osgeo.kr/17 [OSGeo(Open Source GeoSpatial) 한국어 지부 - OSGeo Korean Chapter]

그럼 왜 이렇게 많은 좌표계가 존재할까?

이는 두가지 이유 때문이다.

먼저, GRS80 계열 좌표계와 Bassel 계열 좌표계 두가지가 존재한다.

다음으로, 앞서 지구는 감자 모양인데, 좌표계를 만들기 위해, 임의의 타원체를 정의했다고 적었다.

당연히 지역마다 고도 차로 인해, 같은 원점을 사용하면 오차가 크게 발생할 것 이다.

따라서 지역마다 다른 원점을 사용하여 측량의 정확성을 키우자 함 이다.

굳이 하나를 덧붙이자면,

새로운 (발전한) 좌표계를 국가 표준으로 삼더라도, 기존 좌표계를 활용하는 데이터를 모두 일괄 변환하는것이 어렵거나,
기존 데이터를 사용하던 시스템이 더이상 동작하지 않을 수 있기 때문에, 과거부터 제공해온 데이터들은 과거 좌표계를 사용하는 경우가 많은것이, 다양한 좌표계가 혼용되는 현상의 이유라 할 수 있겠다.

국내 제공되는 데이터를 사용한다면,

좌표계를 항상 주의하여 확인해보길 바라며 이만 마치도록 하겠다.

도메인이 만료되었었다...

C.Moon — Sun, 19 Jan 2020 15:00:55 +0900

한동안 블로그를 잊고 있었는데

알고보니 도메인이 만료되어있었다....

그저 눈물...

각종 검색엔진에서도 이제 검색이 잘 안되지 않을까 하는 걱정이 되는군...

EAL -Evaluation Assurance Level- 보증등급

C.Moon — Wed, 19 Dec 2018 18:08:25 +0900

서론

이 블로그를 보면, 또 WhoAmI 페이지를 보면 알 수 있겠지만, 나의 테크 스택은 독특한 편이다.

컴퓨터 공부의 시작은 Security(정보보안)으로 시작하였으며, 학부때는 서버 시스템을 열심히 공부하였고, 지금은 모바일 환경에서 저전력을 보고 있었다. 그리고 최근 몇개월 사이엔 딥러닝을 공부하고 있었다.

안타깝게도, 모바일 환경에서 저전력을 연구하던 내용은 빛을 보지 못하고 접게 되었다. 결과가(대부분 모바일 앱에서(특정 타겟 -게임, 웹브라우징 등-이 아닌) 5%정도의 전력 이득) 나오기는 했다. 하지만, 접게 되었으니까 논문은 없고... 내 머릿속에만 있으면서 누구한테 말도 못하는 그런 상황이다. 나같은 떠버리에겐 너무 가혹한 상황이다.

사실 이게 중요한게 아니다. 기존 석사 과정 2년간 하던 모바일 저전력 연구를 접은 지금 새로운 연구 주제가 결국 돌고 돌아 Secure OS 가 되었다. 그래서 오랜만에 보안 내용을 보게 된것이다. 이 무슨 수미쌍관적인 운명인지. 어쩌면 내 테크 트리는 이 연구를 위함이 아녔을까? Security-System-Mobile 이 합쳐진 Secure OS를 보기 위한...?

그럼, 이제 잡설은 줄이고, EAL에 대해 서술해 보도록 하겠다.

본론

감히 예측해 보건데, 이 글을 읽으시는 여러분은 EAL에 대해 처음 들어본 상황에서 열심히 구글링하고 계시지 않은가? 물론, Google은 내 블로그를 별로 안좋아 하니, 네이버 에서 보셨을 수도 있겠다. ~~(구글신님 저를 굽어 살피소서)~~

[네이버에서는 2번에 있지만, 구글에서는 첫 페이지에 보이지 않는다]

각설하고, EAL을 나도 얼마전 까지 처음 들어봤었다. 앞서 서론에서 적은바와 같이, 최근에 연구 주제를 바꾸게 되어서 보기 시작한 내용이기도 하다. 그럼 EAL (Evaluation Assurance Level) 은 무엇일까?

EAL?

EAL은 CC(Common Criteria, 캠퍼스 커플이 아니다.) 에서 만든 소프트웨어의 평가 보증 을 위한 등급이다. 1999년 발효되었으며, 총 1에서 7까지 7단계로 나누어져 있다. 이는 같은 기관에서 만든 여러 규칙에 따라 작성된 문서를 통해 검증되며, 이 규정을 위한 설명과 문서들을 정의해 놓았다.

각 문서는 총 6가지의 클래스로 나누어 정리 가능하며 아래와 같다.

Development : 개발
Guidance docrument : 설명서
Life-cycle support : 생명주기 지원
Security Target evaluation : 보안목표 명세서 평가
Tests : 시험
Vulunerability assessment : 취약성 평가

-Common Criteria for Information Technology Security Evaluation 및 KISA의 한글 번역본 참조-

각 클래스는 다시 여러개의 패밀리로 분류되며, 각 EAL레벨 별로 클래스 마다 지켜야 하는 패밀리의 종류와 레벨이 다르게 지정되어 있다.

EAL 레벨 별 차이는 여러가지가 있지만 레벨 별 대표적인 특징만 정리한다면 아래와 같다.

[나름 EAL 버전 별 특성을 정리해 보았다]

아래 정리는, Common Criteria for Information Technology Security Evaluation 과 KISA의 한글 번역본을 참조하여 작성하였으며, KISA의 정보보호제품 평가제출물 작성 가이드 도 일부 참고 하였으나, 자의적으로 정리하였으므로 문서와 다른 내용/표현이 있을 수 있다.

EAL1 - 기능적인 시험

기능과 인터페이스에 대한 명세를 필요로 한다. 또한 제한적인 보안 명세서가 필요하다. 제한적인 보안 명세서라 함은, 단순히 프로그램(이하 TOE: Target Of Evaluation)이 만족해야 하는 보안 요구사항을 명확히 제시하는 것 만으로 충분하다. TOE의 기능이 설명서에 서술된대로 동작한다는 증거를 제공해야 한다.

EAL2 - 구조적인 시험

EAL1에 추가적으로 보안 아키텍쳐에 대한 구조 명세와 설계 명세가 추가된다. 이외에도 형상관리 시스템과 배포 절차에 대한 증거가 포함되는 등 구조적으로 안전함으로 보증한다. 또한 TOE명세에 기반한 독립적인 시험을 요구한다.

EAL2는 기존 시스템을 안전하게 하거나, 개발자와의 접촉이 어려울 경우, 즉 독립적으로 보증된 보안성을 필요로 할 경우 적용 가능하다.

EAL3 - 체계적인 시험 및 검사

EAL2에 추가적으로, TOE의 보안 구조 설계 명세가 필요하다. 또한 TOE의 형상괸리와 배포 절차 이외에도 개발환경 통제의 보증을 제공하여야 한다. 보다 완전한 범위의 보안 기증성 시험과 개발과정에서 TOE가 변경되지 않도록 하는 매커니즘과 절차를 요구한다.

EAL3는 설계 단계에서 기존 개발방법론의 많은 변화 없이 보안공학을 적용할수 있다. 실질적으로 소프트웨어 공학적인 재접근 없이, TOE및 TOE개발에 대한 조사를 필요로 할 경우 적용 가능하다.

EAL4 - 체계적인 설계, 시험 및 검토

EAL3에 추가적으로 완전한 인터페이스 명세와 TOE 모듈 설계 명세 그리고 TSF(TOE Security Functional, TOE 보안 기능)에 대한 구현의 표현의 일부를 필요로 한다. 구현의 표현은 소스코드 또는 하드웨어 다이어그램 등 실제 구현에 근접한 내용을 의미한다. 공격자의 침투 공격에 대한 내성을 제공된 기능명세, TOE 설계, 구현의 표현, 아티켁쳐 설계, 설명서 증거 등에 근거한 취약성 분석에 의해 뒷받힘 해야 한다.

EAL4는 상업적 개발 방법론에 기반한 시용적인 보안공학(Security engineering)으로 최대한의 보증을 얻을 수 있도록 한다. 전통적인 상용 TOE에 비교적 높은 수준의 보증된 보안성을 요구하며, 추가적인 비용을 지불할 용의가 있는 경우에 적용 가능하다.

여기까지 EAL 1~4 까지의 내용을 정리한 표는 아래와 같다.

[EAL1~4 등급별 구분 항목 표^[각주:1]]

EAL5 - 준정형화된 설계 및 시험

EAL4에 추가적으로 준정형화된 설계 명세와 보다 구조화된(분석 가능한)구조를 필요로 한다. 또한 모듈화된 TSF설계가 요구된다.

EAL5는 엄격한 상업적 개발 방법론에 기반한 보안공학으로부터 최대한의 보증을 얻을 수 있도록 한다. 엄격한 상업적 개발 방법론이란 전문적인 보안공학 기법을 완화시켜 응용하는 것을 말한다.

[EAL4와 5의 차이^[각주:2]]

EAL6 - 준정형화된 설계 검증 및 시험

EAL5에 추가적으로 정형화된 보안 정책 모델과, 기능과 TOE의 준정형화된 명세를 통해 보증을 제공한다. 이를 통해 준정형 검증을 하도록 한다. 보다 포괄적인 분석, 구조화된 구현의 표현, 보다 체계적인 구조(예: 계층화), 보다 포괄적이고 독립적인 취약성 분석, 개선된 형상관리와 개발환경 통제 등을 요구한다.

EAL6은 개발자가 심각한 위험으로부터 높은 가치의 자산을 보호하기 위한 최상의 TOE를 생산하기 위하여 엄격한 개발환경에서 보안 공학 기법을 응용하여 얻을 수 있는 높은 보증을 제공한다.

[EAL 5와 6의 차이 비교]

EAL7 - 정형화된 설계 검증 및 시험

EAL7은 정형화된 표현, 정형화된 일치성 입증, 포괄적인 시험을 이 용한 포괄적인 분석을 요구함으로써 EAL6보다 높은 보증을 제공한다.

마치며

EAL1 ~ 4 까지는 보안성의 증가가 이뤄지고, 5~7까지는 준정형 명세에서 정형 검증까지 정형화된 검증이 강해지는 구조를 가지고 있는것을 확인 가능하다. 여기까지로 이 글을 마치며, 각 기준 항목들과, 항목별 설명에 대하여 정리한 표를 아래에 첨부하며 마무리 짓도록 하겠다.

[EAL 패밀리 별 문서 설명, 클릭하여 확대]

국제공통평가기준(ISO 15408) 국제공통평가기준(ISO 15408) IT 보안성 평가 IT 보안성 평가․인증 가이드 (요약) - KISA [본문으로]
서동수. 공통평가기준에서의 EAL5 평가기준 분석. 정보과학회지, 2007, 25.5: 33-37. [본문으로]

ResNet - Deep Residual Learning for Image Recognition - Preview

C.Moon — Fri, 16 Nov 2018 18:35:38 +0900

Deep Residual Learning for Image Recognition (Kaiming He, Xiangyu Zhang, Shaoqing Ren, Jian Sun 저) Preview

때는 바야흐로 2015년, VGG Net과 GoogLeNet(Inception v1)의 활약 이후 CNN세상은 춘추 전국시대를 맞고 있었다. VGGNet이 던져놓은 화두는 "깊은 망이 학습이 잘 되지만, 너무 깊으면 안되더라" 라는 내용이었다. 이때 혜성 같이 등장한 딥-러닝의 기린아, ResNet이 등장하게 된다.

ResNet은, 기존 모델들에서 망이 너무 깊으면 학습이 되지 않던 문제를 "Vanishing-Gradient" 이슈 때문으로 해석하였다.

여기서 잠깐! Vanishing-Gradient가 무엇일까?

역전파 과정에서, 뒤로 갈수록 오류의 기울기(Gradient)가 줄어드는 현상이 발생한다.

왜 일까?

(출처 : https://medium.com/machine-learning-world/how-to-debug-neural-networks-manual-dc2a200f10f2)

위 그림은, 다양한 Activation function들의 생긴 모양이다.

보면, Sigmoid의 경우, 일정 수치 이상의 x값에서는 1로 일정이하의 값 에서는 0 으로 값이 고정된다.

따라서, 누적되는 기울기 값들이 점점 흐려지게 된다.

그래서, 이를 해결하고자 나온 것이, ReLU이다. ReLU는 0부터는 일정 기울기로 값이 증가하게 된다.
f(x) = max(0,x)

하지만 역시, 값이 감소하는 상황에서는 0으로 고정 되므로, 기울기가 가려지게 된다.

(그렇다고, 기울기가 계속 일정하면, 딥러닝의 핵심인 Non-linearity가 깨어지게 됨)

그래서 다시 나온것이 Leaky ReLU이다.

이는 0 이하일때에도 일정량의 기울기를 유지해 준다.

하지만, 역시 과하게 깊은 경우에는 기울기가 잘 전달되지 않는 문제점이 남아있다.

ResNet은 이 문제를 해결하기 위해 독특한 방식을 제안하였다. 바로, 일정 노드 마다 앞의 결과를 뒤에 붙여 버려서, Gradient가 전달될 수 있는 지름길을 만들어 놓는 것 이다.

이를 통해 Gradient가 "더 빠르게/잘" 전달되게 되었다.

여기서, "더 빠르게" 도 상당히 집중해 볼 부분이다. 실제 논문에서도, ResNet 을 14층 쌓았을 때와, 일반 CNN을 14층 쌓았을 때, 최종 Accuracy의 차이는 없었지만, 더 빠르게 수렴하였음을 이야기 하고 있다. (Inception Net에서도 ResNet이 꼭 필요한가에 대해선 회의적이었지만, 수렴 속도가 빨라지는 것은 동의하였으며, Inception v4 가 제안된 논문에서 이를 적용한 Inception-ResNet 이라는 모델을 제안하였다.)

그리고, 맨 위 그림에서 처럼, 기존에는 일정 이상의 깊이의 모델이 학습이 되지 않는 현상이 발생하였지만(Over-fitting은 아님, Training set 에서도 오히려 Error가 높기 때문), 깊은 모델에서도 그런 문제가 생기지 않는것을 확인하였다.

결과적으로, 대회에 출품하는 버전에서는 152개의 레이어를 쌓은 모델을 사용하여, 3%의 오차로 우승을 거머쥐었다.

이 글을 통해, ResNet의 컨셉이 잘 이해되었길 바란다.

간단히 살펴보는 ResNet은 이만 마치며,

다음 편, ResNet 논문 리뷰 편 에서 다시 돌아오겠다.

오버워치 PPT 템플릿 블로그가 되어버렸다.

C.Moon — Fri, 16 Nov 2018 13:00:00 +0900

오버워치 PPT 템플릿 블로그가 되어버렸다.

뭐랄까... 손님을 끌기 위해 서비스로 빙수를 내놓았는데, 정신 차려보니, 가게가 빙수집이 되어버린 느낌이다.

원래는, 개발 블로그이고 싶었는데 개발 글은 올리지도 않았고...

연구실 일상 글은 나름 연재 중인데, 생각보다 어그로가 안끌린다.

역시 요즘 핫한건 "딥러닝" 인가보다.

딥러닝 글을 올린건 최근인데, 그래도 오버워치를 이기면서, 나름 블로그의 정체성을 지켜주었다.

뭐 그래서 결론은,

오버워치 PPT 템플릿 블로그가 되어버렸다.

※사족: 다른 템플릿도 올리고 싶은데, 공개 할만한 퀄리티의 작품이 더이상 나오지 않는다. 이제 더이상 학부생이 아니다 보니, 저런 톡톡튀는 템플릿을 쓸 일이 별로 안생기기도 하고, 개인적으로 템플릿을 쓰기 보단, 한 페이지 한 페이지를 깎아 만드는 편이라서.

※사족2: 결국 관종인거라, 오버워치 템플릿이 관심을 끈다면, 오케이! 땡큐! 다. 심지어 다른 템플릿을 못만들어서 슬프다니까?

※사족3: 최근 블로그 스킨을 바꾸고, 가독성이 확 떨어진 느낌이다. 아 어쩌지.. 폰트 못바꾸나.

CAM - Class Acvtivation Map 논문 (Learning deep features for discriminative localization) 리뷰

C.Moon — Thu, 15 Nov 2018 11:11:16 +0900

@markdown

# CAM - Class Activation Map

Learning deep features for discriminative localization, Zhou, B., Khosla, A., Lapedriza, A., Oliva, A., & Torralba, A (MIT, csail)[^1]

## 서론

서두에, 이 논문을 읽으며 YbigTa 강병규 님의 글[^참고] 을 다소 참고하였음을 밝힌다.

### CAM 이란?

CAM(Class Activation Map)은 CNN(Convolutional Neural Network)을 해석 하고자 하는 생각에서 시작했다. 일반적으로, CNN은 특정 지역의 정보를 알고 해석한다고 믿어져 왔지만 이 부분이 명확히 해석되지 못하고 있다. 이를 위해, 기존 연구들 에서는 각 Filter들에 대한 해석을 노력해왔다.

![enter image description here](https://lh3.googleusercontent.com/Tw-s-2fv1o9lB06NW-192XiKzILO7XlG2KaISynKGxHlLYir3ps6aW47AJvkY4ULhlbWmxNRcAk)

출처 : http://cs231n.github.io/convolutional-networks/

</center>

위 그림은 스탠포드 대학에서 온라인으로 제공하는 수업, cs231n[^2] 의 강의 자료중 일부 이다. 위 그림에서는 CNN이 동작하는 과정을 설명하기 위해 각 레이어를 지날때 마다의 값을 이미지로 표현하였다. 위 그림에서, 낮은 부분의 Layer에서는 엣지를 Detect하고, 깊은 레이어 일수록 특정 Feature를 찾아낸다는 점은 알 수 있지만, 왜 특정 Class로 분류 되는지는 보이지 않는다.

이 논문은 그러한 부분은 해결하기 위한 노력을 기하였다. 즉, 이미지가 분류될 때, 어느 부분이 해당 이미지 분류에 영향을 미쳤는지를 분석하기 위해 노력하였다.

### 논문의 특징

이 논문은 앞서 적은, 이미지의 어느 영역이 Class 분류에 큰 영향을 끼쳤는지를 분석하기 위하여 특징적인 구현을 하였다. 우선, 첫번째로는 기존의 분류 방법 대신 GAP라는 것을 사용하였다. GAP는 Global Average Pooling의 약자로, 기존 CNN분류기에서 사용하던 3층의 FC레이어(Fully connected Layer) 대신, 1층의 Average Pooling과 FC레이어를 사용하려는 아이디어 이다.

이는, NIN(Network In Network[^NIN])논문에서 처음 제안되었으며, 이후 이미지넷 첼린지에서 우승한 구글의 Inception Net(a.k.a GoogLeNet)[^GoogLeNet] 에도 적용되는 등 많은 참조가 되고 있는 구조 이다.

![GAP vs Ori](https://lh3.googleusercontent.com/Gc5xt-cXepMHzGrr1ThDhkGzcKzav6AmKI-OIdivbIJfhmilc2tuKqfyfnO-oBPw67iDMu6-Kx0)

저자들은 CAM을 제안하면서 기존에 잘 알려진 모델들을 GAP가 적용되도록 재구현 하여 사용하였으며, GAP를 사용하였을 때에도 사용하지 않은 모델과 유사한 성능이 나옴을 실험적으로 증명하였다.

## 특징

### GAP

논문은 CAM을 구현하기 위해 GAP를 사용하였다. 기존 FC방식은, 최종 Convolution layer 의 결과를 Flatten(최종 Conv레이어의 결과는, 최종 채널 수 x 최종 W x 최종 H 로 3차원이다. 이를 1차원 행렬로 늘어놓아 Fully connected layer(이하 FC)의 인풋으로 바꿔주는 것을 Flatten 이라고 한다) 한 이후, 해당 데이터를 3번 정도의 FC레이어를 거쳐 Class별로 분류하는 방식이다. 이 과정은 많은 레이어를 소모 하므로, Network 의 속도가 늘어나고, 소모 메모리가 늘어나고, Over-fitting에 불리한 등의 문제를 가지고 있다. 따라서, NIN[^NIN] 논문 에서는 GAP라는것을 제안하였다.

![NIN 구조](https://lh3.googleusercontent.com/WXfY72DC3cxec_Qzc24-sGYql30xwPe0rhVogqYnlMtJgFOsxr4F82ExXegTer06SNIfcscPjkg)

GAP는 이를 위해, 1x1 사이즈의 filter를 가진 Convolutional network를 기존 CNN모델 마지막에 추가하였다. 이 때 해당 Conv레이어의 Out channel 사이즈는 분류하기 원하는 Class의 갯수와 같게 하였다. 이후 각 채널을 평균낸 값을 기존에 FC로 얻은 값 대신에 SoftMax 계층에 넣도록 하였다. 이렇게 하면, FC레이어 없이 학습 하므로 계수가 없어서 Over-fitting에 보다 안전하다.

하지만, CAM논문의 구현은 위와 같은 NIN의 구현과 다소 다르게 보였다. 공개된 저자들의 CAM구현[^3]을 보면 마지막 레이어가, 3x3 filter를 쓰는 out channerl이 1024인 Conv레이어 이며, 마지막이 1024x1000 인 FC로 끝나는 것을 확인 가능하다.

따라서, 본 논문을 구현해 보는데 있어서는 저자들의 구현을 우선시 하여, 마지막 레이어에서average pooling --> channel x class FC 로 이어지는 구현을 GAP의 목적으로 사용하였다.

### Class Activation Map

CAM(Class Activation Map)은 CNN을 하는데 있어서, 이미지의 어느 부분이 결정에 큰 영향을 주었는지를 분석하고자 하는 목적에서 시작되었다. 이를 위해 저자들은 모델에 GAP을 적용시켰는데, 이는 GAP의 경우 마지막 판별 전 까지 데이터의 위치 정보가 훼손되지 않기 때문이다.(이전 까진, Flatten또는 FC등이 없기 때문)

![ "cam 구조"](https://lh3.googleusercontent.com/yesbxG9mqnP8uJ10y7zKJ4MRpKjtWuJbBwHzudTxuFW1rrXykjNQFF8GPHsyy74jLiZHrkq69WA)

즉, 마지막 판별 레이어에서 가지는 Weight값을 convolutional layers 와 pooling layers 를 거친 n x n 행렬 에 곱하면, 판별식에서 어느 부분이 큰 값을 가졌는지를 알 수 있다.

이는, 마지막 판별 레이어가 각 레이어의 Average 값을 입력으로 받는 노드라 이론적으로 옳은 표현이 되는데, 뉴런 네트워크에서 각 노드의 결과는 `입력 x Weight` 들을 모두 더한 값 이기 때문이다. 또한 위 구조에서, 마지막 FC레이어의 노드 갯수는 Class의 갯수와 같으므로, 각 노드의 `입력 x Weight` 값 들의 합을 비교해서, 가장 큰 값을 가지는 노드의 클래스로 분류되는 것이다.

![Neural의 구조](https://lh3.googleusercontent.com/6T9tzO3zShM6o5-ZT2CmLG_xztHe5hQCtUxwSYIf8GHR02P_FggmqeqhF1e-n0b88oLQT8DHZObV)

즉, 해당 값이 클수록 해당 클래스로 분류될 확율이 늘어난다. 따라서, `Weight` 값의 의미는 *분류를할 때 해당 채널의 중요도* 라고 볼 수 있을 것 이다. 이 때, 각 채널에서 높은 값을 가지는 부분은 해당 채널의 Average 값을 높히는데 가장 큰 역할을 하는 부분이다. 즉, 각 채널에서 가장 중요한 부분이라고 해석 가능하다.

따라서, CAM의 구현은, 해당 채널의 각 값에 Weight값을 곱한 수치를 중요도로 해석한다. 이후, 위와 같이 계산된 모든 채널을 더하여서 나온 n x n 행렬을 Heat-map 으로 그린다. 그려진 Heat-map은 이미지에서의 위치 정보를 여전히 포함하고 있으므로, 가장 높은 값을 가지는 위치가, 이미지에서 CNN의 Classification에 있어서 가장 영향력이 높은 부분이라 할 수 있다.

이를 수식으로 표현하면 아래와 같다.(M 은 CAM, x,y는 좌표 c 는 판별 클래스, k는 각 채널)

![enter image description here](https://lh3.googleusercontent.com/Q_ly_K8eX5IHXyYmyRKe0J9WmMXLTxTk6eIcRcNU9R36DmFaxbF7ZCGDcxbLKtawGmRmB4H6hTLg)

[VGG19 + CAM을 직접 구현한 글](http://blog.ees.guru/49)의 마지막에는 논문을 따라 구현하면서 얻은 결과를 포함하고 있지만, 여기에는 논문에서 나온 결과를 첨부하며 마무리 짓도록 하겠다.

![CAM result](https://lh3.googleusercontent.com/fsaJHcLNZrcDimwE9BwaDid6IWUicJgWBDD4P7yy8eA4xgDkfM4zBdsqpKf0BiPgSyFEts2VnDeB)

위 결과에서 보이듯, 이미지의 특징적인 부분에서 높은 값을 가지는 Class Activation Map(CAM)이 만들어진 것을 확인 가능하다.

특히 아래 dome으로 판별된 이미지의 top 5 결과를 보면, 각 판별 결과에 따라 중요하게 판별된 부분이 다른것 또한 확인 가능하다.

[^참고]: https://kangbk0120.github.io/articles/2018-02/cam

[^1]: ZHOU, Bolei, et al. Learning deep features for discriminative localization. In: _Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition_. 2016. p. 2921-2929.

[^2]: [Convolutional Neural Networks for Visual Recognition](http://cs231n.github.io/)

[^3]: https://github.com/metalbubble/CAM

[^NIN]:LIN, Min; CHEN, Qiang; YAN, Shuicheng. Network in network. _arXiv preprint arXiv:1312.4400_, 2013.

[^GoogLeNet]:SZEGEDY, Christian, et al. Going deeper with convolutions. In: _Proceedings of the IEEE conference on computer vision and pattern recognition_. 2015. p. 1-9.

Who Am I

C.Moon — Wed, 14 Nov 2018 22:51:06 +0900

Who Am I

저는 1993년생으로, 단국대학교 에서 2017년 소프트웨어 학과 학사 학위를 받았으며, 동년 연세대학교에서 컴퓨터과학과 석사과정을 시작하였습니다. 현재는 석박통합 과정으로 전환하여 휴학 후, 전문연구요원 으로 MOTOV에 근무 중 입니다.

학부 시절 주요 관심분야는 Hacking 과 System 분야였으며, Database lab 과 Embedded system lab 에서 인턴 연구원으로 활동하였습니다. White-hat contest 본선 진출과, 정보과학회 고신뢰컴퓨팅 부문 우수 논문상을 수상하였습니다.

제 대학원 과정 중 주요 관심분야는, System architecture와 Operating System 이며, 연구실에서는 이를 저전력(Low power/energy)이슈에 집중하여 보고 있습니다. 동 기간 중, YbigTa 에서 빅데이터/딥러닝 공부를 진행하였으며, 2018년도 교육부장으로 운영진 활동을 하였습니다.

현재는 Big-data/Machine learning/Deep learning 분야와, Bigdata Analyst 및 Data Scientist 로 근무 중 입니다.

주로 사용하는 언어는 C, Python이며 이외 PHP, JAVA, C#, C++등을 사용 가능합니다.

Career

2012 단국대학교 소프트웨어 학과 입학

* 2012 : 단국대 중앙 예술 동아리 NRSC 활동 - 힙합 동아리

* 2012 - 2016 : 단국대 중앙 학술 동아리 Aegis 활동 - 해킹 동아리 (https://dk-aegis.org)
2014 : Aegis 운영진 - 운영위원 및 서버 관리

* 2013 - 2015 : 단국대 Database Lab 인턴 및 랩 소속 동아리 D-Bears 활동

2015 휴학

* 2015 - 2016 : 단국대 Embedded system Lab 인턴 연구원 활동

* 2016 - 2016 : DGMIT 에서 3개월간 Android iOS 멀티 플랫폼 cordova 웹앱 fontend 작업

2017 졸업 및 연세대학교 컴퓨터과학과 석사과정 입학

* 2017 - 2020 : 연세대 Mobile Embedded system Lab 연구원

* 2017 - 2019 : 연세대 Big-data 동아리 YbigTa 활동 (http://www.ybigta.com)
2018-1 : YbigTa 운영진 - 교육부장

*2013 - 2018 : IamRoot Linux Kernel source code study 활동
(https://github.com/iamroot11B/linux_stable_3_14_4)
(http://www.iamroot.org/xe/)

2018 8월 석박사 통합 과정으로 전환

* 2018 - 2019 : Deeplearning 스터디 팀, "사조직" 조직 (Github, Study Site)

* 2020 년 대학원 수료

2020 MOTOV 입사

* 데이터 사이언티스트로 활동 중

Skill

상급 - 언어의 내부 구조와 Hack등을 이해 및 활용
C언어
Python

중급 - 구글과 함깨라면 대부분 작업을 할 수 있음
C#
Java
PHP

중하급 - 중급과 같으나 자주 사용되는 내장 자료구조 중 모르는 것이 있을 수 있음
JavaScript(Node.js)
HTML
ASM

하급 - 구글링 을 통해 많은 작업을 할 수 있으나, 숙련자에 비해 많은 시간이 걸릴 수 있음
Ruby
Perl

무급 - toy example 정도만 수행해봄, 코드를 읽는데 다소 어려움이 있을 수 있음
Haskell
Kotlin
Lisp(방언)

Projects

In the MOTOV.
인천시 야간 안전 골목길 프로젝트(with 인천시)
인천시 및 인천경찰청과 협업하여, 인천시 내 조도/유동인구 등 데이터에 따른 범죄율 예측 및 이를 통한
순찰 경로 추천 및 지역 별 안심 지수 산정 프로젝트

수집 데이터의 전처리 및 분석, Deeplearning 모델 모델링 및 분석 업무를 담당(자문 Yonsei UNIV BigDyL)

(www.incheontoday.com/news/articleView.html?idxno=201737)

In the Labs
안전한 업무단말 구현을 위한 보안강화기술 선행 연구(@Dankook)
  SeLinux 와 AppArmor 분석 및 적용 시스템 구축, TPM을 활용한 LKM인증 시스템 구축
마이크로아키텍처 간섭인지 기반 통합자원관리를 위한 운영체 제 및 하이퍼바이저연구(@Dankook)
  NUMA 환경에서 마이크로아키텍쳐 기반 공유 자원 간섭 최소화를 위한 코디네이션 기법 연구
OPEL 커널 수준 최적화(@Dankook)
  OPEL프로젝트를 위한 커널 수준 최적화 진행. 이를 위하여, 해당 보드에 커널 포팅 작업 진행
IoT단말을 위한 저전력 커널 프로젝트(@Yonsei)
RTOS 분석 및 저전력 기술 추가 연구

In the Circles
각종 CTF 대회 출전 및 10등 안밖에 순위(@Aegis)
2014-2016년 Python 및 C 언어 교육 진행(@Aegis)
스타트업 모의 해킹 진행(@Aegis)
  카이퍼넷 : 웹 방화벽 모의 해킹 (ASTSOFT)
꿀단지 : 소셜 모임 플랫폼 웹 사이트 및 결제 모듈 모의 해킹
FITT : 개인별 맞춤 트레이닝 시스템(웹) 모의 해킹
E.T Europe Traveler Manager.(@YbigTa)
  위키 정보를 활용한 빅데이터 기반 유럽 여행지 추천 시스템
  Word2Vec 과 문서 요약 시스템을 적용하여, 각 관광지에 대한 위키 데이터를 Vectorize
각 Vector 값 간의 오일러 거리를 계산하여 가장 가까운 vector 평면 상 거리에 있는 관광지를 추천
CatchTone(@YbigTa, Github)
Objective
Individual personal color analysis and custom color palette through frontal face image
Process
Classify worm tone and cool tone by ensemble model with skin color data.
Diagnose 4 season types of personal color by Clustering the eye brightness extracted from 1770 face photographs.
Conclusion
Improvement of accuracy and usability with a quantitative approach to the traditionally qualitative personal color diagnosis

In the Univ.
교과목 튜터링 멘토 활동 - OS 과목 (2015 @Dankook)
운영체제 수업의 튜터로서, 주 1회 수업 이외의 간단한 수업 내용 정리 강의를 진행함
단국대학교의 튜터링 지원을 받아, 지원금을 받으며 한 활동
GoldRush(졸업작품@Dankook)
위치 정보를 활용, IoT 곡괭이 장비를 통해 곡괭이질을 하여 일정 지역의 광산을 개발하는 소셜 게임
RESTful api 와 Bluetooh IoT/Smartphone 통신, Arduino 3축 센서와 진동 센서를 통한 행동 인식
기술을 활용, 학부 동안 배운 대부분 기술을 실 적용 시켜보는것을 목적으로 함

Awards

WhiteHatContest 9th finalist (2014)
국방부/국정원 주최 국군사이버사령부 주관 해킹방어대회 본선 진출(상위 8개팀 본선 진출)
EEEegis 팀. 예선 7위
2016 한국컴퓨터종합학술대회 고신뢰컴퓨팅 부분 우수논문상
NUMA 환경에서 프로세스 코디네이터, 송치영, 최종무

Papers

TKI: 심볼테이블을 이용한 TPM 기반 커널 무결성 검증 기법
발표·출판일2015년 6월 한국정보과학회 KCC 학부생 논문 부문
NUMA 환경에서 프로세스 코디네이터
발표·출판일2016년 6월 한국정보과학회 KCC 고신뢰 컴퓨팅 부문

VGG Net 과 CAM (Class Activation Map) 구현

C.Moon — Wed, 14 Nov 2018 20:25:57 +0900

VGG Net 과 CAM 구현

몇 팀원과 같이 스터디 중인 리포지토리 홍보 : https://poddeeplearning.readthedocs.io/ko/latest/CNN/VGG19%20+%20GAP%20+%20CAM/

Initial

import torch
import torchvision
import torchvision.transforms as transforms

torch libary init

torch.cuda.is_available()

True

torch.cuda.is_available 값이 True 면, 현재 GPU를 사용한 학습이 가능하다는 뜻, False면 불가능

import torch
import torchvision
import torchvision.transforms as transforms

import torch.nn as nn
import torch.nn.functional as F

transform = transforms.Compose([
    transforms.Resize(224),
    transforms.ToTensor(),
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),
])

trainset = torchvision.datasets.STL10(root='./data', split='train', download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=64, shuffle=True)

testset = torchvision.datasets.STL10(root='./data', split='test', download=True, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=64, shuffle=False)

Files already downloaded and verified
Files already downloaded and verified

Pytorch tutorial 을 참고하여 구현하였다.

STL10 데이터셋을 가져오도록 했다.(원본 출처)

STL10 데이터셋은 Stanford 대학에서 만든 데이터 셋 으로, 다양한 이미지들을 미리 10개의 클래스로 나누어 놓고, 이미지 별 정답 데이터를 같이 제공해주는 데이터셋 이다.

이미지 학습에 자주 사용되는 데이터셋 이며,(이외에도, Cifar10/100: 10개/100개 의 클래스로 나눠놓은 데이터 셋, MNIST: 0~9 까지의 숫자 손글씨 데이터 셋 등이 자주 사용된다.) pytorch에서는 torchvision이라는 라이브러리에서 쉬운 사용을 위한 방법을 제공한다.

torchbision.datasets.원하는 데이터 셋 이름 과 같은 명명 방식으로 가져오는 함수가 구성되어 있으며, 기본적으로는 각 함수별로 유사하지만 직접 수행해본 결과, STL10과 Cifar10/100 은 train set과 test set을 나누는 방법이 다르다.

STL10 의 경우는 위와 같이, argument 에 split='train' or split='test' 로 작성하여 나누게 되고, Cifar10/100 의 경우에는 argument에 train=True or train=False 와 같이 작성하여 나누는 방식을 취한다.

batch_size=64 는 미니배치(한번에 모델에 동시에 돌려 학습시킬 사이즈) 이다.

많은 pythonic 한 라이브러리 들이, 같은 형태를 취한다면, 이용법을 최대한 맞추게 되어 있는데, 그렇지 못해서 이 부분이 다소 아쉬웠다.

transform = transforms.Compose([ transforms.Resize(224), transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)), ])

이 부분은, 데이터셋을 가져올 때, 형태를 변환해주는 코드로, 위 부터 설명하면 아래와 같다. ToTensor의 위치에 따라, Resize와 Normalize의 순서는 입력한 순서와 같아야 한다.

transforms.Resize(224) : 이미지의 크기를 224x224로 변환, 이는 VGG Net에서 대상으로 하는 이미지의 크기가 244x244 이기 때문
transforms.ToTensor() : 받아오는 데이터를 pytorch에서 사용하기 위한 Tensor 자료 구조로 변환
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) : 받아오는 데이터를 노말라이징, 입력 전에 노말라이징이 필요한가 여부는 아직 논의가 되고있는 것으로 보이지만, 노말라이징을 하는 경우, 특정 부분이 너무 밝거나 어둡다거나 해서 데이터가 튀는 현상을 막아줌

import matplotlib.pyplot as plt
import numpy as np

# functions to show an image


def imshow(img):
    img = img / 2 + 0.5     # unnormalize
    npimg = img.numpy()
    plt.imshow(np.transpose(npimg, (1, 2, 0)))


# get some random training images
dataiter = iter(trainloader)
images, labels = dataiter.next()

# show images
imshow(torchvision.utils.make_grid(images))
# print labels
print(' '.join('%5s' % classes[labels[j]] for j in range(4)))

 deer  deer plane  frog

imshow는 다른 사람이 구현한 내용을 가져왔다. (Pytorch tutorial 참조)

간단하게 말하면, matplotlib에 있는 pyplot 을 써서 데이터 셋에 있는 이미지를 읽으면, 비교적 어두운 색으로 보이는 이미지가 출력된다. (이는 학습을 위한 데이터 셋 이므로, 미리 정규화가 되어있기 때문)

이를 다시 정상적인 이미지로 만들기 위해, 이미지를 unnormalize 하고 plt.imshow에 넣어 출력해 주는 함수이다.

VGG 모델 구현

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv = nn.Sequential(
            #3 224 128
            nn.Conv2d(3, 64, 3, padding=1),nn.LeakyReLU(0.2),
            nn.Conv2d(64, 64, 3, padding=1),nn.LeakyReLU(0.2),
            nn.MaxPool2d(2, 2),
            #64 112 64
            nn.Conv2d(64, 128, 3, padding=1),nn.LeakyReLU(0.2),
            nn.Conv2d(128, 128, 3, padding=1),nn.LeakyReLU(0.2),
            nn.MaxPool2d(2, 2),
            #128 56 32
            nn.Conv2d(128, 256, 3, padding=1),nn.LeakyReLU(0.2),
            nn.Conv2d(256, 256, 3, padding=1),nn.LeakyReLU(0.2),
            nn.Conv2d(256, 256, 3, padding=1),nn.LeakyReLU(0.2),
            nn.MaxPool2d(2, 2),
            #256 28 16
            nn.Conv2d(256, 512, 3, padding=1),nn.LeakyReLU(0.2),
            nn.Conv2d(512, 512, 3, padding=1),nn.LeakyReLU(0.2),
            nn.Conv2d(512, 512, 3, padding=1),nn.LeakyReLU(0.2),
            nn.MaxPool2d(2, 2),
            #512 14 8
            nn.Conv2d(512, 512, 3, padding=1),nn.LeakyReLU(0.2),
            nn.Conv2d(512, 512, 3, padding=1),nn.LeakyReLU(0.2),
            nn.Conv2d(512, 512, 3, padding=1),nn.LeakyReLU(0.2),
            nn.MaxPool2d(2, 2)
        )
        #512 7 4

        self.avg_pool = nn.AvgPool2d(7)
        #512 1 1
        self.classifier = nn.Linear(512, 10)
        """
        self.fc1 = nn.Linear(512*2*2,4096)
        self.fc2 = nn.Linear(4096,4096)
        self.fc3 = nn.Linear(4096,10)
        """

    def forward(self, x):
        
        #print(x.size())
        features = self.conv(x)
        #print(features.size())
        x = self.avg_pool(features)
        #print(avg_pool.size())
        x = x.view(features.size(0), -1)
        #print(flatten.size())
        x = self.classifier(x)
        #x = self.softmax(x)
        return x, features

device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

net = Net()
net = net.to(device)
param = list(net.parameters())
print(len(param))
for i in param:
    print(i.shape)
#print(param[0].shape)

28
torch.Size([64, 3, 3, 3])
torch.Size([64])
torch.Size([64, 64, 3, 3])
torch.Size([64])
torch.Size([128, 64, 3, 3])
torch.Size([128])
torch.Size([128, 128, 3, 3])
torch.Size([128])
torch.Size([256, 128, 3, 3])
torch.Size([256])
torch.Size([256, 256, 3, 3])
torch.Size([256])
torch.Size([256, 256, 3, 3])
torch.Size([256])
torch.Size([512, 256, 3, 3])
torch.Size([512])
torch.Size([512, 512, 3, 3])
torch.Size([512])
torch.Size([512, 512, 3, 3])
torch.Size([512])
torch.Size([512, 512, 3, 3])
torch.Size([512])
torch.Size([512, 512, 3, 3])
torch.Size([512])
torch.Size([512, 512, 3, 3])
torch.Size([512])
torch.Size([10, 512])
torch.Size([10])

VGG Net 논문 본문을 확인하여, VGG19 모델의 구조를 참고 하였다.

Sequential 을 활용하여 구현하였다. Sequential을 이용할 경우, forward에서 각 레이어를 하나 하나 부르는 대신, 해당 Sequence의 이름을 불러서 한번에 이용 가능하다.

features = self.conv(x)

이후 기존 VGG19 모델과 달리 마지막에는 Average pooling을 하고, Fully Connected Layer를 사용하여 Classification을 하였다.

이는 NIN논문에서 구현된 GAP(NIN논문에서는 Class의 갯수와 같은 채널 수 를 가지는 Conv모델을 마지막에 사용하였으며, 각 채널의 Average 값을 SoftMax에 입력하였다. 즉,FC레이어를 사용하지 않았다.)와 다소 다르지만, 논문의 caffe 버전 구현을 중심으로 하여 구현하였다.

모델에서 Pytorch는 filter의 크기에 맞춰서 적절한 패딩 값을 직접 입력해 주어야 한다. 일반적으로 패딩의 크기는 stride 값을 1을 사용할때, 필터의 크기의 절반을 사용한다. 이는 필터의 크기가 절반이 되어야 모든 픽셀이 한번 씩 중앙에 오게 되기 때문(:= 모든 픽셀을 체크하는 것이 되기 때문)이다.

self.avg_pool = nn.AvgPool2d(7)

AvgPool2d 의 필터 크기가 7x7인 이유는, MaxPooling 레이어를 거칠때 마다 이미지의 각 면의 길이는 절반이 된다.(nn.MaxPool2d(2, 2)) VGG19 에서 요구하는 이미지의 크기는 244x244 이고, 122,56,28,14,7 의 순서로 크기가 줄어들게 되기 때문이다.

device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

마지막으로 해당 코드는, GPU를 사용하기 위한 코드이다. device라는 변수명에 GPU 디바이스를 지정/저장 해 준다. 이후

net = Net() net = net.to(device)

위와 같이, 만든 Net을 초기화 해 주고, net.to(device) 구문을 통해 해당 네트워크를 GPU에서 돌아가는 네트워크로 지정하게 된다.

classes =  ('airplance', 'bird', 'car', 'cat', 'deer', 'dog', 'horse', 'monkey', 'ship', 'truck')
import torch.optim as optim

criterion = nn.CrossEntropyLoss().cuda()
optimizer = optim.Adam(net.parameters(),lr=0.00001)

criterion 과 optimizer를 정의한다. 기본적인 구조는 역시 Pytorch tutorial을 참고 하였다.

criterion 은 일반적으로 loss 라고도 부르며, 이를 통해 학습을 위한 loss값을 계산하게 된다. 현재 많은 경우에 CrossEntropyLoss가 winner로 취급받고 있으며, pytorch의 CrossEntropyLoss의 경우 내부에서 SoftMax를 내장하고 있으므로, 모델 구조에서 SoftMax를 할 필요가 없다.(SoftMax가 없는 CrossEntropyLoss를 사용하고 싶을 경우 NLLLoss를 사용하면 된다.

Adam optimizer는 역시 현재 자주 상요되는 옵티마이저로, 학습 시 현재의 미분값 뿐만이 아니라, 이전 결과에 따른 관성 모멘트를 가지고 있는것이 특징이다. 이는 paddle point(안장점)에 도달하더라도 빠져나갈 수 있으므로, adam optimizer뿐만이 아니라, 현재 자주사용되는 옵티마이저들 에서는 대부분 사용되는 개념이다. 아래 그림은 관성모멘트에 따라 paddle point를 빠져나가는 방법에 따른 도식도 이다. 이 그림은 자주 인용되는 그림인데, 나는 최초 출처를 찾지 못하고 있다. 내가 가져온 곳은 이곳이다. 이외에도 옵티마이저에 대한 설명이 잘 되어있어 다른 사람한테 optimizer를 설명할때 자주 참고하고 있다.

VGG 모델 실행

for epoch in range(100):  # loop over the dataset multiple times
    running_loss = 0.0
    for i, data in enumerate(trainloader, 0):
        # get the inputs
        inputs, labels = data
        inputs, labels = inputs.to(device), labels.to(device)
        # zero the parameter gradients
        optimizer.zero_grad()

        #print(inputs.shape)
        #print(inputs.shape)  
        # forward + backward + optimize
        outputs,f = net(inputs)
        #print(outputs.shape)
        #print(labels.shape)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

        if(loss.item() > 1000):
            print(loss.item())
            for param in net.parameters():
                print(param.data)
        # print statistics
        running_loss += loss.item()
        if i % 50 == 49:    # print every 2000 mini-batches
            print('[%d, %5d] loss: %.3f' %
                  (epoch + 1, i + 1, running_loss / 50))
            running_loss = 0.0

print('Finished Training')

class_correct = list(0. for i in range(10))
class_total = list(0. for i in range(10))
with torch.no_grad():
    for data in testloader:
        images, labels = data
        images = images.cuda()
        labels = labels.cuda()
        outputs,_ = net(images)
        _, predicted = torch.max(outputs, 1)
        c = (predicted == labels).squeeze()
        for i in range(4):
            label = labels[i]
            class_correct[label] += c[i].item()
            class_total[label] += 1


for i in range(10):
    print('Accuracy of %5s : %2d %%' % (
        classes[i], 100 * class_correct[i] / class_total[i]))

[1,    50] loss: 0.001
[2,    50] loss: 0.001
[3,    50] loss: 0.001
[4,    50] loss: 0.000
[5,    50] loss: 0.000
[6,    50] loss: 0.000
[7,    50] loss: 0.000
[8,    50] loss: 0.000
[9,    50] loss: 0.000
[10,    50] loss: 0.000

학습을 하고 있는 과정이다.

[이터레이션 횟수, 미니배치 횟수] 의 구성이며, 실제로는 10회 보다 많은 횟수의 이터레이션을 돌렸지만, 다시 수행하면서 이전 정보가 지워졌다... 실제로는 약 100회의 이터레이션을 돌리고, loss 값이 0.000이 되었을 때 강제로 멈춰 버렸다.(조급증 때문에...)

학습 과정은 계속 참고 하고있는 pytorch tutorial을 참고하였으며,

inputs, labels = data inputs, labels = inputs.to(device), labels.to(device)

을 통해 데이터 들을 GPU들을 복사하는것 이외엔 사실 자세히 보지 않고 그냥 사용하였다.

class_correct = list(0. for i in range(10))
class_total = list(0. for i in range(10))
with torch.no_grad():
    for data in testloader:
        images, labels = data
        images = images.cuda()
        labels = labels.cuda()
        outputs, f = net(images)
        _, predicted = torch.max(outputs, 1)
        c = (predicted == labels).squeeze()
        for i in range(4):
            label = labels[i]
            class_correct[label] += c[i].item()
            class_total[label] += 1


for i in range(10):
    print('Accuracy of %5s : %2d %%' % (
        classes[i], 100 * class_correct[i] / class_total[i]))

Accuracy of airplance : 55 %
Accuracy of  bird : 54 %
Accuracy of   car : 84 %
Accuracy of   cat : 52 %
Accuracy of  deer : 59 %
Accuracy of   dog : 49 %
Accuracy of horse : 66 %
Accuracy of monkey : 66 %
Accuracy of  ship : 84 %
Accuracy of truck : 65 %

역시, 튜토리얼에서 참고한 코드이며, Test셋을 이용하여 정답율을 보았다.

생각보다 높지 않은 정답율이 나와 아쉬웠다.

CAM

torch.save(net, 'vgg19.pt')

/lvmdata/ees/anaconda3/envs/tensorflow35/lib/python3.5/site-packages/torch/serialization.py:241: UserWarning: Couldn't retrieve source code for container of type Net. It won't be checked for correctness upon loading.
  "type " + obj.__name__ + ". It won't be checked "

net2 = torch.load('vgg19.pt')

net2 = net2.to(device)

CAM을 하기에 앞서, GPU 메모리를 비우는 등의 작업을 위해 일단 저장하고 커널을 종료 후 다시 불러서 사용하였다. 역시 GPU를 사용하기 위해서, .to(device) 를 사용하였다.

class_correct = list(0. for i in range(10))
class_total = list(0. for i in range(10))
with torch.no_grad():
    for data in testloader:
        images, labels = data
        images = images.cuda()
        labels = labels.cuda()
        outputs, f = net2(images)
        _, predicted = torch.max(outputs, 1)
        c = (predicted == labels).squeeze()
        for i in range(4):
            label = labels[i]
            class_correct[label] += c[i].item()
            class_total[label] += 1


for i in range(10):
    print('Accuracy of %5s : %2d %%' % (
        classes[i], 100 * class_correct[i] / class_total[i]))

CAM 을 위해 다시 Prediction을 계산하였다. 만, 이 문서를 작성하다가 실수로 실행 결과 화면을 지워버렸다. 위의 정확도와 실행 결과는 동일.

params = list(net.parameters())

파라미터들을 가져오도록 한다. 역시 CAM의 구현을 위함이다.

CAM?

CAM에 대해서는 다른 게시물로 작성하고 있지만, 지금 간단하게 설명하자면, 마지막 FC layer에서 사용하는 각 채널의 weight값과 각 채널을 Average하기 전의 7x7 데이터를 곱한 값 들을 더한 값을 이용하여, 해당 수치가 가장 높은 부분이 모델에서 가장 중요하게 판단하는 부분일 것 이라고 판단하는 논문 이다.

ZHOU, Bolei, et al. Learning deep features for discriminative localization. In: _Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition_. 2016. p. 2921-2929.

import torch
import torchvision
import torchvision.transforms as transforms

import torch.nn as nn
import torch.nn.functional as F

import matplotlib.pyplot as plt

net = torch.load('vgg19.pt')
net = net.to(device)

import numpy as np
def imshow(img):
    img = img / 2 + 0.5     # unnormalize
    npimg = img.numpy()
    plt.imshow(np.transpose(npimg, (1, 2, 0)))
    
for data in testloader:    
    images, labels = data
    images = images.cuda()
    labels = labels.cuda()
    outputs, f = net(images)
    _, predicted = torch.max(outputs, 1)
    break

imshow를 다시 구현하였으며, predicted 1회 만 다시 하는 코드를 작성하였다.

사실 이 부분에서 이슈가 있는것 같다... testloader에서 1회만 하고 하고 싶었는데, 이 이후 Memory leak 이 생기는 듯 하다.

import skimage.transform
classes =  ('airplance', 'bird', 'car', 'cat', 'deer', 'dog', 'horse', 'monkey', 'ship', 'truck')
params = list(net.parameters())
num = 0
for num in range(64):
    print("ANS :",classes[int(predicted[num])]," REAL :",classes[int(labels[num])],num)
    
    #print(outputs[0])
    
    overlay = params[-2][int(predicted[num])].matmul(f[num].reshape(512,49)).reshape(7,7).cpu().data.numpy()

    overlay = overlay - np.min(overlay)
    overlay = overlay / np.max(overlay)

    imshow(images[num].cpu())
    skimage.transform.resize(overlay, [224,224])
    plt.imshow(skimage.transform.resize(overlay, [224,224]), alpha=0.4,cmap='jet')
    plt.show()
    imshow(images[num].cpu())
    plt.show()
    
#plt.imshow(params[-2][int(predicted[num])].matmul(f[num].reshape(512,49)).reshape(7,7).cpu().data.numpy(), alpha=0.5,cmap='jet');

ANS : horse  REAL : horse 0


/lvmdata/ees/anaconda3/envs/tensorflow35/lib/python3.5/site-packages/skimage/transform/_warps.py:105: UserWarning: The default mode, 'constant', will be changed to 'reflect' in skimage 0.15.
  warn("The default mode, 'constant', will be changed to 'reflect' in "
/lvmdata/ees/anaconda3/envs/tensorflow35/lib/python3.5/site-packages/skimage/transform/_warps.py:110: UserWarning: Anti-aliasing will be enabled by default in skimage 0.15 to avoid aliasing artifacts when down-sampling images.
  warn("Anti-aliasing will be enabled by default in skimage 0.15 to "

ANS : monkey  REAL : monkey 1

ANS : dog  REAL : dog 2

ANS : ship  REAL : airplance 3

ANS : cat  REAL : cat 4

ANS : bird  REAL : bird 5

ANS : horse  REAL : bird 6

ANS : bird  REAL : bird 7

ANS : deer  REAL : deer 8

ANS : horse  REAL : deer 9

ANS : bird  REAL : airplance 10

ANS : airplance  REAL : airplance 11

ANS : deer  REAL : deer 12

ANS : airplance  REAL : airplance 13

ANS : cat  REAL : bird 14

ANS : cat  REAL : dog 15

ANS : deer  REAL : deer 16

ANS : truck  REAL : truck 17

ANS : airplance  REAL : airplance 18

ANS : horse  REAL : horse 19

ANS : horse  REAL : dog 20

ANS : cat  REAL : cat 21

ANS : dog  REAL : bird 22

ANS : cat  REAL : cat 23

ANS : car  REAL : car 24

ANS : horse  REAL : horse 25

ANS : bird  REAL : dog 26

ANS : cat  REAL : dog 27

ANS : truck  REAL : car 28

ANS : dog  REAL : monkey 29

ANS : truck  REAL : bird 30

ANS : horse  REAL : horse 31

ANS : dog  REAL : cat 32

ANS : monkey  REAL : monkey 33

ANS : truck  REAL : truck 34

ANS : truck  REAL : car 35

ANS : deer  REAL : deer 36

ANS : monkey  REAL : monkey 37

ANS : truck  REAL : truck 38

ANS : horse  REAL : dog 39

ANS : bird  REAL : bird 40

ANS : airplance  REAL : truck 41

ANS : airplance  REAL : airplance 42

ANS : horse  REAL : horse 43

ANS : deer  REAL : deer 44

ANS : truck  REAL : truck 45

ANS : bird  REAL : bird 46

ANS : bird  REAL : bird 47

ANS : cat  REAL : cat 48

ANS : car  REAL : car 49

ANS : cat  REAL : dog 50

ANS : cat  REAL : deer 51

ANS : airplance  REAL : airplance 52

ANS : airplance  REAL : airplance 53

ANS : car  REAL : truck 54

ANS : ship  REAL : ship 55

ANS : horse  REAL : horse 56

ANS : monkey  REAL : monkey 57

ANS : car  REAL : car 58

ANS : ship  REAL : airplance 59

ANS : airplance  REAL : airplance 60

ANS : dog  REAL : bird 61

ANS : bird  REAL : bird 62

ANS : monkey  REAL : monkey 63

CAM을 구현하였다.

CAM의 구현은 앞에서 적은 저자들의 코드를 참고하였다. (CAM의 구현은 Pytorch로 구현되어있음)

overlay = params[-2][int(predicted[num])].matmul(f[num].reshape(512,49)).reshape(7,7).cpu().data.numpy()

이 부분 위와 아래는, 정규화 나 이미지 출력을 위한 부분이며, 해당 부분이 핵심이다.

params[-2] 는 뒤에서 부터 두번째 레이어 이다. 이는, 512x1 input을 받는 FC레이어의 weight값들 이다. 즉 512x1 의 크기를 가진다. 이것과 matmul(행렬곱)을 하는 f[num]은 512개의 채널을 가지는 7x7 행렬들 이다. 이를 512x49로 리쉐잎을 하는 이유는 행렬곱이 2차원 행렬 끼리의 곱만 지원하기 때문이다.

마지막으로 이것을 cpu로 바꿔주고 넘파이로 바꿔주며 끝을 낸다. cpu로 바꿔주지 않고 numpy로 바꿀 경우 오류가 나게 된다.

imshow(images[num].cpu()) skimage.transform.resize(overlay, [224,224]) plt.imshow(skimage.transform.resize(overlay, [224,224]), alpha=0.4,cmap='jet') plt.show()

이 부분을 통해 이미지를 출력하게 된다.

먼저, imshow로 원본 이미지를 출력해 주고, 같은 팔레트에 위에서 계산한 overlay(cam 값)을 그려준다.

이를 위해, 이미지와 같은 크기(224x224)로 리사이징을 하고, imshow의 argument 값에 alpha 값을 0.4로 설정해 주어 반투명 하게 덮어씌워주도록 한다.

위 출력에서 아래에 원본 이미지가 출력되는 것은 아랫줄에서 원본 이미지만 다시 한번 출력하기 때문이다.

여기서 주의하여야 하는 점은, plt.show()를 해야 현재 팔래트를 화면에 출력하고 새로운 팔래트를 준비한다는 점 이다.

결과를 통해, 해당 모델(VGG19)에서 어느 부분을 통해 해당 클래스로 판별한 것 인지 확인 가능했다.(일부 결과의 경우 특이한 결과를 보여주는데, 사슴(deer)의 경우 사슴본체 보단 주변 풀숲에서 높은 값이 보이는 것이 한 예 이다.)

디아블로 이모탈을 본 단상

C.Moon — Thu, 8 Nov 2018 20:44:56 +0900

디아블로 이모탈(Diablo immortal) 을 본 단상

2018년 11월 3일.

온라인 세상은 블리즈컨의 열기로 가득했다.^[각주:1] 이전부터 새로운 무언가를 보여준다며, 팬들의 기대를 가득 불러일으킨 디아블로의 발표 시간이 첫날과 마지막에 잡혀있었던 것이다.

첫날과 마지막날 이면, 당연히 중요한 발표일거야.

멍청한 생각이었다. 하지만, 이 시점 까지는 아무도 모르고 있었기에, 나도 새벽같이 일어나 발표를 보기 위해 자리를 잡았다.

사실은, 침대에 누운 그대로 핸드폰만 들었다.

짖궂은 사람들은, "너의 디아블로 모바일로 대체되었다^[각주:2]" 라며 GIF까지 만들어대고 있었다.

말도 안되는 얘기였다.

아니, 말도 안되는 얘기여야만 했다.

그리고, 대망의 발표.

와이엇 쳉분의 등장과 함께 장내는 환호로 가득찼다. 스마트폰의 유리 화면 뒤 나의 마음속도 환호로 가득찼다. 비록 방음이 못미더운 자취방 한 구석이라 소리는 못냈지만.

그리고 그는 말했다.

"새로운 디아블로"

환호를 지르려는 순간, 부족한 내 영어 청음으로도 듣고 말았다. "모바일"

환호가 야유로 바뀌는건 순식간 이었다.

그리고 나는, 내 자취방의 방음 성능을 확인하고 말았다.

"X발"

아마 믿어도 좋은 방음 이리라, 아직 자취방 주인 아주머니의 퇴거명령이나, 문 앞에 조용히 해달라는 쪽지가 생기지 않은걸로 보아선 말이다.

"X씨X"

사실 두번 소리질렀다.

아니 사실 셀수 없이. 그래도 소리 지른건 단 두번이고, 나머지는 혼자 씹어뱉은 욕지거리였으니, 이 글을 보는 독자분들은 나를 용서해주길 바란다.

나는 최대한 노력했다.

그래도 애써 마음을 다잡았다.

"그래. 그래도 블리자드 잖아. 하스스톤도 모바일로 나왔다고? 어떤 새로운 경험을 줄지 몰라"

이건 상상도 못했었다.

블리자드 게임 발표 트레일러에서 외주 제작사 로고라니? 그것도 중국 양산형 모바일 게임을 만드는 회사라니?

넷이즈라는 이름이 생소하시다면, 혹시 올해 논란이 되었던 DIA M 을 기억하시는가?

디아블로와 유사하게 생긴 양산형 모바일 RPG. 그 회사가 넷이즈다.

회장은 야유로 가득찼다.

무대에 토마토가 날아들지 않는것을 보며, 선진국 국민들의 높은 시민의식에 감탄을 하기도 잠시, 미려한 트레일러는 오히려 마음을 심란하게 하였다.

이게, PC RPG 였더라면...

그리고 트레일러에 공개된 UI는 새로운 조작법이나 무언가를 보여주지 않을까 했던 내 마지막 기대마저 찬찬히 부수어 갔다.

차라리 잠이나 더 잘껄.

그리고 이후 QnA 세션.

여기서 전설로 남은 그 질의가 나온다.

Q: PC나 다른 콘솔로는 안나오나요?

A: 네, 어쩌구 저쩌구... 여러분은 스마트폰도 없나요?

오... 하나님.

블리즈컨 : 블리자드에서 매년 여는 행사로, 새로운 게임/확장팩 등을 공개하는 행사 [본문으로]
인터넷에서 유행하는 번역체 드립. 너의 OOO OOO로 대체되었다. [본문으로]

EeS 의 연구실

항해 플러스 코육대 참여 회고

목차

기능 구현 및 설명

가장 중요시한 부분

반응형 구현

State 구현

Hanging Man

Game Status

기타 제약조건들

참여 소감

참여 링크

Bessel 타원의 변경 (localdata.go.kr 제공 데이터 오차 보정)

도메인이 만료되었었다...

EAL -Evaluation Assurance Level- 보증등급

ResNet - Deep Residual Learning for Image Recognition - Preview

오버워치 PPT 템플릿 블로그가 되어버렸다.

CAM - Class Acvtivation Map 논문 (Learning deep features for discriminative localization) 리뷰

Who Am I

Who Am I

Career

Skill

Projects

Awards

Papers

VGG Net 과 CAM (Class Activation Map) 구현

VGG Net 과 CAM 구현

Initial

VGG 모델 구현

VGG 모델 실행

CAM

CAM?

디아블로 이모탈을 본 단상