채용 공고 분석: 네이버 파이낸셜 AML 데이터 분석 및 모델링 인턴쉽

난 AML을 새로 배우기 막 시작했다. 그 첫 걸음을 채용 공고 분석으로 시작해보려 한다.

채용 직무

• AML 데이터 분석 및 모델링

  • 자금세탁 의심거래 탐지를 위한 Rule 기획 및 예측 모델링 개발/운영

  • 고객 위험평가 모델 운영 및 고객 행동 분석

  • 프로세스 자동화, 분석 자동화 기획/운영

  • 금융당국 대상 의심거래 보고 운영

우대사항

• 대용량 데이터 분석 Skill/Tool 사용 가능자 (Python, R, SAS 등)

• 데이터 모델링, 머신 러닝 등에 대한 통계적 지식 및 수학적인 이해가 있는 분

• AML 또는 RegTech 분야에 관심이 있는 분

실제로 하는 일

• AML 데이터 분석

• 고객 계좌와 이체 데이터 정제

• 고객 위험평가 모델 구축

• 자금세탁 의심거래 탐지를 위한 머신러닝 기법 실험

• 자금세탁 의심거래 Rule 기획, 예측 모델 설계

• 데이터 분석 전체 프로세스 코드 자동화

• STR 보고 시스템, 보고서 작성

사용 언어 및 툴

• 언어 : Python, R, SAS

왜 AML일까

• 안전성 있는 사회를 만들고, 우리 사회가 핀테크를 받아들이는 과정에서 먼저 완성되야 할 기술
• 사회 제도권에서 영역을 넓히기 위해서 소비자와의 신뢰 쌓기, 이것이 Next thing
• 나 스스로도 안전성, 신뢰가 중요, 나의 공백기에도 운동이나 뉴스 확인 같이 일상에 반복되는 일들을 하며 안전성을 유지하는 것을 가장 중요시
• 기준을 잡혀있고 정형화된 Reg programming에 강점
• 새로운 신용평가 시스템으로 다양한 팩터가 적용된 AML -> AML이 발전해야될 길이라 생각

왜 데이터 분석 및 모델링일까

• 데이터에서 패턴을 읽고 머신러닝 기법으로 정답에 맞추어 다가가도록 만드는 철학이 내 인생철학과 동일

• 빅데이터에 있는 진실을 프로그래밍 기술로 캐치하여 현실화하는 것이 멋지다고 느껴짐

• 데이터를 보고 과정을 자동화하는 일련의 과정이 평소에도 효율화를 꿈꾸는 나에게 매력적인 테스크

• 내가 분석력, 약간의 기획력, 프로그래밍, 수학을 기반으로 하는 구조 설계를 갖추었다고 믿는다.

전형 일정

• 6월 18일 지원자 모집 마감

• 서류전형 / 역량 면접

• 7월 12일 ~ 8월 27일 인턴쉽

• 정규직 면접

준비 사항

• 고객 위험평가 모델 / 고객 행동 분석

• 분석 자동화 MLOpS?

• 예측 모델링

• Anomaly Detection

• Python, SQL

• STR 매커니즘 알기

• AML/FDS 매커니즘 알기

• Regtech 알기

• 데이터 모델링과 머신러닝, 통계적 지식 및 수학적인 이해

• ncloud?

실제로 해보려 찾아볼 일

• AML 데이터 분석

• 고객 계좌와 이체 데이터 정제

• 고객 위험평가 모델 구축

• 자금세탁 의심거래 탐지를 위한 머신러닝 기법 실험

• 자금세탁 의심거래 Rule 기획, 예측 모델 설계

• 데이터 분석 전체 프로세스 코드 자동화

• STR 보고 시스템, 보고서 작성

참고

• 공식 사이트 : https://naverfincorp-career.com/

발전을 거듭하는 핀테크 기업: 네이버 파이낸셜

커머스와 트래픽을 토대로 사업을 확장하고 있는 핀테크 기업, 네이버 파이낸셜에 대해 알아보자

왜 네이버 파이낸셜일까

핀테크

• 개발자는 프로그래밍으로 문제를 해결하는 사람
• 금융, 돈은 삶에서 떼어낼 수 없고, 내 인생의 도메인으로 삼고 싶다
• 신뢰과 금융의 편의성이 높다. 인간의 시간을 아껴준다. IT는 금융의 메인 패러다임이 될 수 밖에 없다.
• 기술의 필요 : 네이버 쇼핑, 커머스 분야에서 놀라운 성장, 수많은 결제 데이터, 네이버 파이낸셜이 여러가지 실험을 할 수 있는 땔감

Zero Pay

• 소상공인의 결제 수수료 부담을 줄이기 위해 민관이 합작해 만든 모바일 간편결제 서비스
• 네이버, 정부, 서울시, 지자체가 함께 하는 QR 결제 서비스
• 네이버 앱으로 이용 가능
• 제로페이로 인해 네이버의 페이 시스템이 오프라인과의 교점을 만드는 지점 효과 기대

기업 장점

• 네이버 플랫폼을 기반으로 한 금융 서비스 연계성
• 결제 데이터량, 네이버 쇼핑
• 스마트 스토어의 사업자 고객들과 소비자 고객들
• 사용자의 규모가 받쳐주는 회사에서만 할 수 있는 새로운 시도
• 검색 회사, 탄탄한 데이터 기술력
  • 유연 근무제
  • 유연한 호칭 체계
  • 절차 중심 X 업무 중심 문화 O
  • 성과 중심
  • 평등한 기회
  • 실력 있는 동료들
• 기업 문화

기업 약점 및 단점

• 오프라인 결제 경쟁력, 앱 내 Zero pay로 보강
• 원앱 전략을 선택하여 아직 그 효과를 실험 중

기업 강점

• 네이버 파이낸셜 마이데이터
• 네이버 페이 신용관리 서비스 (ACSS)
  • 신용 분석 리포트 제공, 4영역 거래기간, 신용형태, 부채, 상환이력 난 916점
• 스마트스토어 사업자 대출 500억원 달성, 미래에셋캐피탈과 우리은행 함께 소외된 사람들 신용관리 서비스로 혜택
• 카카오페이, 토스와 달리 네이버 파이낸셜 흑자 전환, 매출 7000억원
• 오프라인 QR 결제 서비스, 빠른 정산 등 핀테크 서비스
• NF보험서비스 보험 준비
• 금융위로부터 후불결제 대상기업으로 선정되어 후불 결제 서비스
• 주식이나 채권, 외화 형태로 자산을 관리하는 경우 늘어남 네이버 증권는 투자 정보 제공 정도의 역할

경쟁사는

• 금융 결제량 KB
• 카카오페이, NHN 페이코, Toss
• 지역 상품권 -> 포용 전략
• 쿠팡 페이 -> 네이버 쇼핑 보강 및 금융 서비스 확장으로

참고

• 공식 사이트 : https://naverfincorp-career.com/
• 캐치업, annual Report 사이트 내 네이버 파이낸셜 컨텐츠 참고
• 네이버 파이낸셜 기사

이것이 코딩 테스트다 Ch04 실전 문제

4-3 게임 개발

문제 설명

게임 캐릭터가 맵 안에서 움직이는 시스템을 개발

• 맵은 N x M 크기의 직사각형으로 각각 칸이 육지 또는 바다
• 캐릭터는 상하좌우로 움직일 수 있고, 바다로 되어 있는 공간에는 갈 수 없다.

캐릭터 움직임 매뉴얼

1. 현재 위치에서 현재 방향을 기준으로 왼쪽 방향 (반시계 90도)부터 차례대로 갈 곳을 정한다.
2. 캐릭터의 바로 왼쪽방향에 가보지 않은 칸이 존재한다면 왼쪽 방향으로 회전한다음 왼쪽으로 한 칸 전진
   왼쪽 방향 칸이 가보았던 칸이면 왼쪽 방향으로 회전만 수행
3. 네 방향 모두 이미 가본 칸이거나 바다로 되어 있는 칸인 경우, 바라보는 방향을 유지한 채로 한 칸 뒤로 가고 1단계로 돌아간다.
   단, 이 때 뒤쪽 방향이 바다인 칸이라 뒤로 갈 수 없는 경우에는 움직임을 멈춘다.

Input

N -> int : row limit
M -> int : col limit
myloc -> list : 현재 위치 [x, y]
MAP -> 2d list : N x M MAP, 각 칸에 land(0)과 sea(1) 정보가 포함

Output

count -> int : visit한 valid한 타일의 개수

Limit

N >= 3
M <= 50
time : 1 second
memory : 128 MB

구현 코드

Analysis

시간복잡도 : O(NM)
공간복잡도 : O(NM)

def solve(N, M, myloc, mydi, MAP):  
    # 게임 개발  
    cnt = 1  
    land = 0  # sea = 1  
    direction = [[0, -1], [1, 0], [0, 1], [-1, 0]]  
    visited = [[False for x in range(M)] for y in range(N)]  
    get_left_di = lambda di: (di + 3) % 4  # turn left 90 degree  
    get_back_di = lambda di: (di + 2) % 4  # turn 180 degree  
    get_next_xy = lambda loc, di: [  
        loc[0] + direction[di][0],  
        loc[1] + direction[di][1],  
    ]  # get next loc through direction  
    check_loc_is_valid = (  
        lambda x, y: (0 <= x < M) and (0 <= y < N) and MAP[y][x] == land  
    )  # check loc in MAP and loc is land  

    visited[myloc[1]][myloc[0]] = True  
    while True:  
        next_x, next_y = get_next_xy(myloc, get_left_di(mydi))  # get loc to left direction  
        # 왼쪽 방향으로 전진한 칸이 valid하고 가보지 않은 칸이면 왼쪽으로 회전하고 한 칸을 전진  
        if check_loc_is_valid(next_x, next_y) and not visited[next_y][next_x]:  
            visited[next_y][next_x] = True  
            cnt += 1  # cnt += 1 when visit valid and not-visited loc  
            myloc = [next_x, next_y]  
            mydi = get_left_di(mydi)  

        # 그 외 경우 방향만 left 90 degree로  
        else:  
            mydi = get_left_di(mydi)  

        # 네 방향 중 가볼 수 있는 loc가 있으면 break  
        for di_idx in range(4):  
            next_x, next_y = get_next_xy(myloc, di_idx)  

            if check_loc_is_valid(next_x, next_y) and not visited[next_y][next_x]:  
                break  
        # 네 방향이 모두 가본 칸이거나 갈 수 없는 타일인 경우  
        else:  
            myloc = get_next_xy(myloc, get_back_di(mydi))  # 뒤로 한 칸, 방향은 유지  
            if not check_loc_is_valid(myloc[1], myloc[0]):  # 뒤로 간 칸이 갈 수 없는 타일이면  
                return cnt  
    return 0  

테스트 코드

class testSolve(unittest.TestCase):  
    def testcase(self):  
        N, M = 4, 4  
        myloc = [1, 1]  
        mydi = 0  
        MAP = [[1, 1, 1, 1], [1, 0, 0, 1], [1, 1, 0, 1], [1, 1, 1, 1]]  
        self.assertEqual(solve(N, M, myloc, mydi, MAP), 3)  


unittest.main()  

백준 2504번 괄호의 합 링크 : 

    https://www.acmicpc.net/problem/2504

괄호의 합은 두 가지 로직이 필요한 문제였다. 

    - 괄호가 잘 닫혀있는 지 확인

    - 괄호의 합을 계산

괄호가 잘 닫혀있는 지 확인 (불가능한 형태인지 확인)

    - Stack을 사용하여 연 괄호 '(', '['를 닫는 괄호 ')', ']'로 전부 잘 닫히는 지 확인한다.

        -> 연 괄호일 때 push, 닫는 괄호 일 때 stack top 괄호 모양 확인 후 pop

        -> 닫는 괄호와 연 괄호가 매칭되지 않으면 불가능한 형태이다. 중지하고 0을 출력한다.

        -> input string을 전부 탐색한 후에 stack이 비어있지 않으면 (잘 닫힌 것이 아니면) 불가능으로 판단

    - 여는 괄호의 갯수와 닫는 괄호의 갯수를 확인한다.

        -> 이 부분 때문에 조금 애먹었다.

        -> '(((((()))' 왼쪽과 같은 여는, 닫는 괄호의 수가 일치하지 않은 경우를 감지하기 위해,

             (), [] 형태마다 변수를 두어 괄호의 수를 체크한다. 여는 괄호일 때는 +1, 닫는 괄호일 땐 -1

괄호의 합을 계산

    - 괄호의 합을 계산하기 위해서는 분배 법칙을 적용된 식을 이해해야 한다. (a x (b + c) = a x b + a x c)

    - 괄호 안에 괄호가 정의되는 경우와 괄호가 끝나 괄호끼리 +하는 경우를 위해 몇 가지 규칙이 필요하다.

         -> 괄호가 열리는 순간 depth가 깊어진다고 가정한다.

              ( () 모양 괄호는 x2 depth, [] 모양 괄호는 x3 depth )

         -> 괄호가 열린 후 바로 닫힐 때는 +를 수행한다. ')' 모양일 때 바로 전 모양이 '(' 이면 +를 수행하는 식

         -> 괄호가 닫히는 순간 depth를 하나 벗어난다고 본다.

              ( (X), '()' 모양의 괄호를 벗어나면 /2, '[]' 모양의 괄호를 벗어나면 /3 )

    - 규칙에 따라 적용하면 문제의 예시 앞부분은 다음과 같이 풀이 될 수 있다.

         -> 예시 : "(()[[]])" , 초기 값 depth = 1, 초기 값 sum = 0

         -> 0번째 ( : depth x 2                      || depth = 2, sum = 0, 전체에 x2를 한 상태와 같음

         -> 1번째 ( : depth x 2                      || depth = 4,  sum = 0

         -> 2번째 ) : sum += depth, depth / 2  || depth = 2,  sum = 4

         -> 3번째 [ : depth x 3                      || depth = 6,  sum = 4

         -> 4번째 [ : depth x 3                      || depth = 18, sum = 4

         -> 5번째 ] : sum += depth, depth / 3  || depth = 6,  sum = 22

         -> 6번째 ] : depth / 3                      || depth = 2,  sum = 22

         -> 7번째 ) : depth / 2                      || depth = 1,  sum = 22

         -> 최종 값 : 22

         -> 손으로 계산해본 "(()[[]])" 값과 같음! =>> 2 x (2 + (3x3)) = 4 + 18 = 22

 * 구현 코드

input_data = input()
# input_data = "(()[[]])([])"

class Stack(list):
    push = list.append    
    def is_empty(self):   
        if not self:
            return True
        else:
            return False

    def peek(self): 
        if self.is_empty():
            return ""
        else :
            return self[-1]

stack = Stack()

mul_depth = 1
total_sum = 0
impossible = 0
s = 0
l = 0
leng = len(input_data)

for idx in range(leng):
    brk = input_data[idx]
    if brk.__eq__("("):
        s += 1
        mul_depth = mul_depth * 2
        stack.push(brk)

    elif brk.__eq__("["):
        l += 1
        mul_depth = mul_depth * 3
        stack.push(brk)

    elif brk.__eq__(")"):
        s -= 1
        if not stack.peek().__eq__("("):
            impossible = 1
            break

        if input_data[idx-1].__eq__('('):
            total_sum += mul_depth
        
        mul_depth = mul_depth / 2
        stack.pop()

    elif brk.__eq__("]"):
        l -= 1
        if not stack.peek().__eq__("["):
            impossible = 1
            break

        if input_data[idx-1].__eq__('['):
            total_sum += mul_depth
        
        mul_depth = mul_depth / 3
        stack.pop()

if (stack.is_empty == 0) or impossible or l or s:
    print(0)
else :
    print(int(total_sum))