Like Sherlock Data Scientist

Flask Error Handler 활용 배경

• Python 마이크로서비스 배포로 Flask 웹프레임워크 주로 사용
• Flask에서 제공하는 Error Handler 활용
• 클라이언트에 보내는 에러 메세지를 커스터마이징하여 출력 세팅
• 에러 발생 가능한 모든 4xx, 50x 에러 처리 필요
• flask에서 제공하는 _aborter 라이브러리 활용

코드 구현

• error_handler.py

from flask import Flask, jsonify
from werkzeug.exceptions import HTTPException, _aborter, default_exceptions

def error_app(app):
    """
    Error Handler 정의
    """
 
    def _error_handling(error):
        
        # HTTP Exception인 경우
        if isinstance(error, HTTPException):
            result = {
                "error_code" : error.code,
                "description" : error.description,
                "message" : str(error)
            }
        
        # 그 외 나머지 Exception인 경우
        else:
            # 500 에러로 mapping 돼 있는 error message를 추출
            description_500 = _aborter.mapping[500].description
            result = {
                "error_code" : 500,
                "description" : description_500,
                "message" : str(error)
            }
        
        # result dict 데이터를 json으로 변경
        res = jsonify(result)
        
        # response의 status_code를 result의 error_code 값으로 업데이트
        res.status_code = result['error_code']
        
        return res
    #####################################################################
    
    # error handler 등록
    for code in default_exceptions.keys():
        app.register_error_handler(code, _error_handling)
        
    return app

Flask app 소스코드

• app.py

# 위에서 작성한 코드 패키지 형식으로 활용
from error_handler import _error_handling

# Flask app을 _error_handling으로 감싸주기
app = _error_handling(Flask(__name__))

💡데크 기본 개념

• 스택(stack)과 큐(Queue)의 연산을 모두 가지고 있는 복합 자료형 자료구조
• 데크(Deque) : Double Ended Queue의 줄임말로서 양쪽 끝 데이터를 모두 추출할 수 있는 큐의 형태
• 데크 자료구조는 양쪽 끝에서 삽입 삭제 모두 가능하다
• 파이썬에서는 데크 자료구조를 collections 라이브러리를 활용하여 사용 가능하다
• 데크 자료구조는 이중 연결 리스트로 구현하는 것이 유용하다. 포인터를 2개 활용해서 앞뒤에서 삽입 삭제가 가능하다.

💡데크 자료구조 직접 구현

• 다음 연산을 지원하는 원형 데크를 디자인하라
  
  
  • MyCircularDeque(k: int) - k값으로 최대 원형 데크의 사이즈 초기화하기
  • insertFront(value: int) - 입력값(value)을 데크의 앞쪽에 삽입하고, 성공했다면 True, 실패했다면 False 반환하기
  • insertLast(vlaue: int) - 입력값(value)을 데크의 뒤쪽에 삽입하고, 성공했다면 True, 실패했다면 False 
  • deleteFront() - 데크 자료구조의 맨 앞의 값을 삭제하고, 성공했다면 True, 실패했다면 False 
  • deleteLast() - 데크 자료구조의 맨 뒤의 값을 삭제하고, 성공했다면 True, 실패했다면 False 
  • getFront() - 데크 자료구조의 맨 앞의 값을 반환하되 만약 값이 없다면 -1을 반환
  • getLast() - 데크 자료구조의 맨 뒤의 값을 반환하되 만약 값이 없다면 -1을 반환
  • isEmpty() - 데크 자료구조의 값이 비어있다면 True, 아니면 False
  • isFull() - 데크 자료구조의 값이 가득 차 있다면 True, 아니면 False
    
    
• 이중 연결 리스트를 활용하여 원형 데크 자료구조 구현

💻 원형 데크 초기화

class MyCircularDeque(object):

    def __init__(self, k):
        """
        :type k: int
        """
        # 왼쪽(head), 오른쪽(tail) index 역할을 할 연결리스트 정의
        self.head, self.tail = ListNode(None), ListNode(None)
        self.head.right, self.tail.left = self.tail, self.head
        
        # 최대 길이와 현재 길이 정보를 담을 변수 정의
        self.maxlen, self.length = k, 0

💻 원형 데크 데이터 추가 내장함수

def _add(self, node: ListNode, new: ListNode):
	
    # 삽입할 연결 리스트의 기존 오른쪽 값을 정의한다
    # 아마 None 값일 것으로 예상한다.
    # front : n --> self.head.right.right --> self.tail.right
    # last  n --> self.tail.left.right  --> self.head.right
    n = node.right 
    
    # 연결 리스트의 오른쪽 값을 새로운 값으로 업데이트한다.
    # front : self.head.right.right == ListNode(value)
    # last  : self.tail.left.right  == ListNode(value)
    node.right = new
    
    # 새로운 노드의 left 값은 기존 node의 값으로 정의하고 (즉, head 역할)
    # right 값은 위에서 따로 정의한 None 값으로 정의해준다
    # head - new - None
    new.left, new.right = node, n
    
    # 그리고 n의 left 값을 새로운 값으로 정의한다.
    # front : n = self.head.right.right
    # last  : n = self.tail.left.right
    n.left = new

💻 원형 데크 데이터 삭제 내장함수

def _del(self, node: ListNode):
        
    # ? None 값을 미리 정의하는건가?
    n = node.right.right

    # 업데이트
    node.right = n

    # ? n의 왼쪽 값을 입력한 포인터의 값으로 정의? 왜?
    n.left = node

💻 원형 데크 앞쪽, 뒤쪽 데이터 추가

def insertFront(self, value):
    """
    :type value: int
    :rtype: bool
    """
    
    # 현재 길이 정보를 확인한다
    # 현재 길이가 최대 길이와 같다면 더이상 삽입할 수 없기에 False를 return
    if self.length == self.maxlen:
    	return False
    
    # 현재 길이가 아직 최대 길이에 도달하지 않았다면 데이터를 삽입할 것이기에
    # 현재 길이를 업데이트 해준다
    self.length += 1
    
    # value값을 원형 데크 자료구조에 추가해준다.
    # 내장 함수 _add 메서드를 사용할 예정
    # value 값을 연결리스트 자료구조 형태에 담아서 추가한다.
    self._add(self.head, ListNode(value))
    
    
def insertLast(self, value):
    """
    :type value: int
    :rtype: bool
    """

    # 현재 길이 확인하여 최대 길이에 도달했다면 False return
    if self.length == self.maxlen:
        return False

    # 현재 길이 업데이트
    self.length += 1

    # 뒤쪽에 값을 삽입할 때는 self.tail 포인터를 활용
    # self.tail.left == 초기에 self.head로 지정했음
    # 업데이트 될 것으로 예상하면서 작업
    self._add(self.tail.left, ListNode(value))

💻 원형 데크 앞쪽, 뒤쪽 데이터 삭제

def deleteFront(self):
    # 삭제할 값이 없다면 False return
    if self.length == 0:
        return False

    # 현재 길이 업데이터
    self.length -= 1

    # 삭제 로직
    self._del(self.head)

    return True


def deleteLast(self):
    # 삭제할 값이 없다면 False return
    if self.length == 0:
        return False

    # 현재 길이 업데이터
    self.length -= 1

    # 삭제 로직
    # 뒷 부분을 삭제할 때는 tail 포인터를 활용하는데
    # 왜 left.left의 값을 넣어주는지 궁금함
    self._del(self.tail.left.left)

💻 원형 데크 데이터 상태 확인 및 판별

def getFront(self):
    """
    :rtype: int
    맨 앞의 값 반환
    """
    return self.head.right.val if self.length else -1


def getRear(self):
    """
    :rtype: int
    맨 뒤 값 반환
    """
    return self.tail.left.val if self.length else -1


def isEmpty(self):
    """
    :rtype: bool
    데크 자료구조의 값이 비어 있는지 판별
    """
    return self.length == 0


def isFull(self):
    """
    :rtype: bool
    데크 자료구조의 값이 가득 차 있는지 판별
    """
    return self.length == self.maxlen

Pytorch의 기본 연산 구현

import torch, math

# 2 X 3 짜리 랜덤값의 tensor 생성
x = torch.randn(2,3)

# 2를 곱한 후 -1
new_x = x * 2 - 1

# 연산 값 확인
print(new_x)
# 절대값 확인
print(torch.abs(new_x))
# 실수 값에서 올림하여 정수 반환
print(torch.ceil(new_x))
# 실수 값에서 내림하여 정수 반환
print(torch.floor(new_x))
# 특정 범위의 값 안에서만 값이 나올 수 있도록
# 최소값보다 낮으면 최소값으로, 최대값보다 높으면 최대값으로 변환
print(torch.clamp(new_x, -0.5, 0.5))

"""
tensor([[-1.4341,  0.6692, -0.3575],
        [-0.6242, -1.3584,  0.3057]])
tensor([[1.4341, 0.6692, 0.3575],
        [0.6242, 1.3584, 0.3057]])
tensor([[-1.,  1., -0.],
        [-0., -1.,  1.]])
tensor([[-2.,  0., -1.],
        [-1., -2.,  0.]])
tensor([[-0.5000,  0.5000, -0.3575],
        [-0.5000, -0.5000,  0.3057]])
"""


print(new_x)
# torch 최소값
print(torch.min(new_x))
# torch 최대값
print(torch.max(new_x))
"""
tensor([[-1.4341,  0.6692, -0.3575],
        [-0.6242, -1.3584,  0.3057]])
tensor(-1.4341)
tensor(0.6692)
"""

실행 환경

• OS : Ubuntu20.04
• shell : bash or zsh
• Elasticsearch version : 7.17.4
• Java version 8

1. 패키지 update & https repository 접근 위한 패키지 설치

sudo apt update
sudo apt install apt-transport-https

2. Java 설치

sudo apt install openjdk-8-jdk

# java 버전 확인

java -version
# openjdk version "1.8.0_312"
# OpenJDK Runtime Environment (build 1.8.0_312-8u312-b07-0ubuntu1~20.04-b07)
# OpenJDK 64-Bit Server VM (build 25.312-b07, mixed mode)

# JAVA 변수 등록 (아래 command 추가) 
(~/.zshrc)
export JAVA_HOME=/usr/lib/jvm/java-1.8.0-openjdk-amd64
export PATH=$PATH:$JAVA_HOME/bin

# 변수 확인
echo JAVA_HOME # ==> JAVA_HOME 으로 출력됨

3. 엘라스틱서치 repository 추가

wget -qO - https://artifacts.elastic.co/GPG-KEY-elasticsearch | sudo apt-key add -

# 아래 명령어가 안 되서 새로운 명령어 대체
# sudo sh -c 'echo "deb https://artifacts.elastic.co/packages/7.x/apt stable main" > /etc/apt/source.list.d/elastic-7.x.list'
echo "deb https://artifacts.elastic.co/packages/7.x/apt stable main" | sudo tee –a /etc/apt/sources.list.d/elastic-7.x.list

sudo apt update

4. 엘라스틱서치 설치

sudo apt install elasticsearch

5. 엘라스틱서치 서비스 실행

sudo systemctl enable elasticsearch.service
sudo systemctl start elasticsearch.service

6. 엘라스틱서치 Test

# 엘라스틱서치 통신
curl -X GET "localhost:9200"

# process 확인
netstat -an | grep 9200

7. Nori 한글 형태소 분석기 설치

# plugin 설치 파일 경로 이동
cd /usr/share/elasticsearch/

# nori 설치
sudo bin/elasticsearch-plugin install analysis-nori

# elasicsearch 재시작
sudo systemctl stop elasticsearch.service
sudo systemctl start elasticsearch.service

8. 엘라스틱서치 config setting

(/etc/elasticsearch/elasticsearch.yml)

# root 계정으로 수정 가능
sudo vi /etc/elasticsearch/elasticsearch.yml

# cluster name 설정 시 사용
cluster.name: local-elasticsearch

# node name 설정
node.name: local-nlp

# host 및 port 설정 (실제 아래는 세팅 안해도 default로 돼 있는 듯)
network.host: localhost
http.port: 9201

9. 엘라스틱서치 index list 확인

curl -XGET "http://localhost:9200/_cat/indices?format=json&pretty"

# 맨 처음 인덱스만 확인할 때
[
  {
    "health" : "green",
    "status" : "open",
    "index" : ".geoip_databases",
    "uuid" : "FchspXH5QGmC0C8L0A_biQ",
    "pri" : "1",
    "rep" : "0",
    "docs.count" : "40",
    "docs.deleted" : "0",
    "store.size" : "37.6mb",
    "pri.store.size" : "37.6mb"
  }
]

# 특정 인덱스(purpose) 추가 후 list
[
  {
    "health" : "green",
    "status" : "open",
    "index" : ".geoip_databases",
    "uuid" : "FchspXH5QGmC0C8L0A_biQ",
    "pri" : "1",
    "rep" : "0",
    "docs.count" : "40",
    "docs.deleted" : "0",
    "store.size" : "37.6mb",
    "pri.store.size" : "37.6mb"
  },
  {
    "health" : "green",
    "status" : "open",
    "index" : "purpose",
    "uuid" : "oTg6ut6IT7yZNt878Tpagw",
    "pri" : "1",
    "rep" : "0",
    "docs.count" : "0",
    "docs.deleted" : "0",
    "store.size" : "226b",
    "pri.store.size" : "226b"
  }
]

10. index 추가 전 synonym.txt (동의어사전) 등록 필요

• 아래 index_config.json 내용 확인해보면 filter > synonym > synonym_path 에 analysis/synonym.txt 로 등록 돼 있음
• elasticsearch의 default path 는 /etc/elasticsearch

(/etc/elasticsearch/analysis/synonym.txt)

TAX,tax,세금
상품 => 경품

다차원 Tensor

0차원 tensor

• scalar 로 표현
• 하나의 숫자로 표현돼 있고, dimention과 shape가 없는 tensor

t_zero = torch.tensor(0)
print(t_zero.ndim)
print(t_zero.shape)
print(t_zero)
"""
0
torch.Size([])
tensor(0)
"""

1차원 tensor

• 하나의 dimention이 존재하며, 리스트와 유사한 형태
• vector로 표현

t_one = torch.tensor([3,7,8,9])
print(t_one.ndim)
print(t_one.shape)
print(t_one)
"""
1                    ==> 1차원
torch.Size([4])        ==> 1축의 값이 몇개 있는지
tensor([3, 7, 8, 9])
"""

2차원 tensor

• 2개의 dimention을 가지며, 일반 행렬과 비슷한 자료구조 형태
• 수치, 통계 데이터셋에 주로 사용
• 주로 row는 sample을 의미하고, column 값은 feature를 의미함

t_matrix = torch.tensor([[2,34,6],
                        [6,3,46],
                        [16,38,73]])
print(t_matrix.ndim)
print(t_matrix.shape)
print(t_matrix)
"""
2
torch.Size([3, 3])
tensor([[ 2, 34,  6],
       [ 6,  3, 46],
       [16, 38, 73]])
"""

3차원 tensor

• 데이터가 연속된 시퀀스 데이터, 시계열 데이터의 차원으로 주로 사용됨
• 큐브 모양의 3개의 축으로 shape 구성
• 3차원 tensor의 예시 데이터
  • 자연어
  • 주식 데이터
  • 시간에 따른 질병 데이터
• 3차원의 특성은 주로, Sample, Timesteps, Feature 로 구성을 이룸

  t_cube = torch.tensor([[[2,34,6],
                     [6,3,46],
                     [16,38,73]],
                    [[2,34,6],
                     [6,3,46],
                     [16,9,6]],
                    [[2,1,6],
                     [6,3,4],
                     [16,2,7]]])
  print(t_cube.ndim)
  print(t_cube.shape)
  print(t_cube)

4차원 Tensor

• 4개의 shape로 구성
• 주로 컬러 이미지 데이터가 4차원으로 표현됨
• Sample(데이터 개수), Height(높이), Width(넓이), Color Channel(컬러 채널) 로 구성

5차원 Tensor

•  5개의 shape로 구성
• 주로 비디오 데이터가 5차원으로 구성됨
• Sample(데이터 개수), Frame(프레임), Height(높이), Width(넓이), Color Channel(컬러 채널) 로 구성돼 있음
• Frame의 의미는 이미지가 여러개 시퀀스 데이터로 구성될 때 비디오 영상 데이터로 되기 때문에 초당 몇개의 이미지를 출력할건지에 대한 정보

문제

• 원형 큐를 디자인하기
• 다음과 같은 함수가 실행되도록 구현

myCircularQueue = MyCircularQueue(3) 
myCircularQueue.enQueue(1) # return True 
myCircularQueue.enQueue(2) # return True 
myCircularQueue.enQueue(3) # return True 
myCircularQueue.enQueue(4) # return False 
myCircularQueue.Rear() # return 3 
myCircularQueue.isFull() # return True 
myCircularQueue.deQueue() # return True 
myCircularQueue.enQueue(4) # return True 
myCircularQueue.Rear() # return 4

• 원본 url : https://leetcode.com/problems/design-circular-queue/

원형 큐(Circular Queue) 개념

• 원형 큐(Queue)는 FIFO 구조를 가지고 있는 점에서 기존 큐(Queue)와 동일하다
• 마지막 위치가 시작 위치와 연결되는 점이 다른 점이다.
• 기존의 큐는 공간이 꽉 차게 되면 더 이상 요소를 채울 수 없다.
• 기존 큐는 앞쪽 값들이 빠져서 충분한 공간이 생기는 것처럼 보여도 해당 위치로 추가할 수 없다.
• 원형 큐는 앞쪽 요소들이 빠지더라도 원형으로 이뤄져 있기 때문에 앞쪽에 추가 할 수 있다.
• 즉, 재활용이 가능한 자료구조이다.

원형 큐 삽입 삭제 원리

• 마지막 위치와 시작 위치를 연결하도록 원형 구조를 세팅하고, 값의 시작점과 끝점을 따라 투 포인터가 움직인다.
• 위 그림을 참고하면, enQueue() 를 통해 rear 포인터를 이동시키고, deQueue 를 통해 front 포인터를 이동시킨다.
• 이 로직을 통해 투 포인터가 돌면서 이동하게 된다.
• 만약 rear 포인터와 front 포인터가 만나게 되면 해당 원형 큐 구조에 여유 공간이 없다는 의미이므로 공간 부족 에러를 발생해야 한다.

원형 큐 구현 풀이

• 배열을 사용하여 구현한다.
• rear 포인터와 front 포인터를 구분한다
• 현재 포인터의 위치를 전체 큐 값의 개수에 따라 제한한다.
• 속도 : 52ms

class MyCircularQueue(object):

    def __init__(self, k: int):
        self.q = [None] * k     # 원형 큐 정의 (배열 활용)
        self.maxlen = k         # 최대 길이 정의
        self.fp = 0             # front pointer
        self.rp = 0             # rear pointer


    def enQueue(self, value: int) -> bool:
        # 값을 추가할 때는 rear pointer 활용한다
        # rear 포인터 위치에 있는 큐 값이 없으면 입력된 value를 넣어준다
        
        if self.q[self.rp] is None:
            self.q[self.rp] = value
            # 입력해준 후 rear 포인터이 값을 업데이트 한다
            self.rp = (self.rp + 1) % self.maxlen
            return True
        else:
            return False


    def deQueue(self) -> bool:
        """
        원형 큐의 첫 번째 값이 제거되도록 기능 구현
        """
        # 값을 삭제할 때는 front pointer를 활용한다.
        # front pointer의 값이 아무것도 없으면 삭제할 값이 없다는 의미
        if self.q[self.fp] is None:
            return False
            
        # 값이 있으면, 그 값을 삭제하되 출력(반환)되지 않도록 세팅 필요
        else:
            self.q[self.fp] = None
            # front pointer를 업데이트한다.
            self.fp = (self.fp + 1) % self.maxlen
            return True
            
            
   def Front(self) -> int:
        """
        원형큐의 맨 앞에 있는 값을 반환
        값이 없을 경우 -1 반환
        """
         return -1 if self.q[self.fp] is None else self.q[self.fp]
        

    def Rear(self):
        """
        :rtype: int
        원형 큐의 맨 뒤에 있는 값을 반환
        값이 없을 경우 -1 반환
        """
        # rear pointer 에서 1을 빼준 위치에서 값을 가져와야 한다.
        return -1 if self.q[self.rp - 1] is None else self.q[self.rp - 1]
        

    def isEmpty(self):
        """
        :rtype: bool
        값이 비어 있을 경우 True, 아닐 경우 False
        포인터의 위치가 같은데 front pointer의 값이 없다면 해당 원형 큐의 값을 아무것도 없는 비어있는 상태라는 의미
        """
        return self.fp == self.rp and self.q[self.fp] is None
        

    def isFull(self):
        """
        :rtype: bool
        값이 모두 채워져 있는 경우를 아래와 같은 로직으로 판단
        우선 포인터의 위치가 같아야 하며, 그럴 때 front pointer의 값이 채워져 있어야 한다.
        """
        return self.fp == self.rp and self.q[self.fp] is not None