Like Sherlock Data Scientist

실행 환경

• 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

문제

• 스택을 이용해 다음 연산을 지원하는 큐 자료구조를 구현하라
  • push(x) : 값 x를 큐 마지막에 삽입하라
  • pop() : 큐의 처음에 있는 값을 제거한다.
  • peek() : 큐의 처음에 있는 값을 조회한다.
  • empty() : 큐가 비어있는지 여부를 확인한다.
• 원본 url : https://leetcode.com/problems/implement-queue-using-stacks/

문제 풀이

• 스택의 연산만을 활용하기 위해서는 2개의 스택이 필요하다
• 이유는 맨 마지막 값만을 활용할 수 있기 때문에 스택의 연산으로 값을 추출하면 값이 곧 최신에 들어간 값(마지막 값)이다.
• 그런데 큐는 맨 처음에 들어간 값이 추출돼야 해서 스택의 연산으로 할 경우 이동이 필요하다.
• output 값이 아무것도 없기 전까지는 재입력하는 알고리즘이 돌아가지 않는다
• 시간복잡도는 O(1) 로 계산되게끔 구현한다
• 실행속도 : 18 ms

class MyQueue(object):

    def __init__(self):
        self.input = []
        self.output = []

    def push(self, x):
        """
        :type x: int
        :rtype: None
        """
        self.input.append(x)


    def pop(self):
        """
        :rtype: int
        """
        # input 값을 재정렬하는 과정 거친 후
        self.peek()
        # 제일 처음에 들어온 값을 추출
        return self.output.pop()

    def peek(self):
        """
        :rtype: int
        """
        # 출력값이 아무것도 없다면 입력값 확인해서 값 재정렬
        if not self.output:

            # 새로 들어온 값이 있다면
            # 해당 값은 output으로 queue 구조로 재입력 돼야 함
            while self.input:

                # 우선 input값에서 마지막 값을 빼고
                # 해당 값을 output에 집어 넣는다
                self.output.append(self.input.pop())

        # 결과값이 맨 마지막 위치한 값이 제일 처음 들어온 값으로 위에서 세팅했음
        return self.output[-1]


    def empty(self):
        """
        :rtype: bool
        """
        # 입력값과 결과값 stack을 모두 확인해야 함
        # 입력값에 값이 들어온 후 결과값에 재정령 안 돼 있을 수도 있기 때문
        return self.input == [] and self.output == []

문제

• 큐를 이용해 다음 연산을 지원하는 스택(Last-In-First-Out)을 구현
  • push(a) : 값 a를 스택에 삽입한다
  • pop() : 스택의 첫번째 요소를 삭제하고 반환한다. (제일 나중에 들어간 값이 첫번째 요소를 의미할 것이다)
  • top() : 스택의 첫번째 요소를 가져온다.
  • empty() : 스택이 비어 있는지 여부를 확인한다. (True / False)
• 원본 url : https://leetcode.com/problems/implement-stack-using-queues/

문제 풀이

• 큐는 파이썬 자료구조 중 deque를 활용한다
• 큐의 연산(맨 앞에 있는 값을 제일 먼저 가져오는)만을 사용하기 위해 스택의 LIFO를 구현해줘야 한다
• 즉, 맨 나중에 들어오는 값이 맨 앞(맨 왼쪽에 위치하게끔 바꿔야 한다.
• 실행 속도 : 39ms

class MyStack(object):

    def __init__(self):
        self.q = collections.deque()

    def push(self, x):
        """
        :type x: int
        :rtype: None
        """
        # Step1. 값을 집어 넣는다
        self.q.append(x)

        # Step2. 데이터를 재정렬한다.
        # 현재 들어 있는 값중 맨 마지막 값은 가만히 있으면 되기 때문에
        # 전체 개수에서 1개 뺀만큼만 이동하면 된다.
        for _ in range(len(self.q)-1):
            # deque 자료구조의 연산중 popleft는 결국 que의 선입선출 연산구조를 의미한다.
            self.q.append(self.q.popleft())

    def pop(self):
        """
        :rtype: int
        """
        return self.q.popleft()

    def top(self):
        """
        :rtype: int
        """
        return self.q[0]


    def empty(self):
        """
        :rtype: bool
        """
        return len(self.q)==0

문제

• 매일 화씨 온도 리스트 temperature를 입력받을 때, 더 따뜻한 날씨을 위해서는 몇일을 기다려야 하는지 출력
• 더 따뜻한 날씨가 없다면 0으로 표기
• 원본 url : https://leetcode.com/problems/daily-temperatures/

예시

Example 1:

Input: temperatures = [73,74,75,71,69,72,76,73]
Output: [1,1,4,2,1,1,0,0]

Example 2:

Input: temperatures = [30,40,50,60]
Output: [1,1,1,0]

Example 3:

Input: temperatures = [30,60,90]
Output: [1,1,0]

문제 풀이 1

• 특별한 자료구조 형태를 적용하지 않고, 단순히 Brute Force 방식으로 풀이
• O(n) 속도로 예상됨. 기본적인 for문과 if문으로 구성

class Solution(object):
    def dailyTemperatures(self, temperatures):
        """
        :type temperatures: List[int]
        :rtype: List[int]
        """
        result=[]
        for i, t in enumerate(temperatures):
            # 다음 따뜻한 날을 체크하기 위한 변수
            day=0

            # 전체 온도의 개수에서 2개를 뺀 이유는 리스트의 index를 사용하는데
            # index에서 +1 하기 때문에 마지막 index 값에서 1을 더하면 out of range error 발생 
            length=len(temperatures)-2

            # 맨 마지막 값인지 아닌지 체크
            if length >= i:
                # 다음 온도가 현재 온도 보다 높은지 체크하고 만약 낮거나 같다면 day와 i가 +1 증가하여
                # 그 다음 온도를 체크하면서 day값을 측정
                while t >= temperatures[i+1] and i < length:
                    day += 1
                    i += 1

                # 특별한 예외 상황이 있는데
                # 만약 끝까지 확인했는데 더 높은 온도가 없으면 0으로 입력해야 함
                # 이 부분이 없으면 맨 끝까지 확인하면서 증가한 day가 입력될 것으로 예상
                if i==length and t >= temperatures[i+1]:
                    result.append(0)
                else:
                    result.append(day+1)

            # 맨 마지막 값이라면 무조건 0으로 입력
            else:
                result.append(0)

        return result

문제 풀이 2

• 현재 index를 stack 자료구로로 쌓아두다가, 이전보다 상승하는 지점에서 현재 온도와 stack에 쌓아둔 index 지점의 온도 차이 비교
• 만약 더 높다면, stack의 값을 꺼내 현재 index와 비교하여 그 차이를 정답으로 입력한다.
• 즉, 현재 온도가 이전 온도들과 비교할 때 stack에 쌓여 있는 index를 활용할 것이고, 이 index의 값이 현재 온도보다 작다면 해당 index는 추출되고 그 차이가 정답으로 옮겨져서 결국, stack에는 해당 index가 안 쌓여 있을 것이다.
• 속도 : 31ms

class Solution(object):
    def dailyTemperatures(self, temperatures):
        """
        :type temperatures: List[int]
        :rtype: List[int]
        """
        # 정답 리스트 세팅 (0으로 세팅해두면, 알아서 아래 로직이 거치지 않는 곳은 0으로 세팅 됨)
        answer=[0] * len(temperatures)

        # 위 온도 값의 index를 담을 자료 구조
        stack=[]

        for i, cur in enumerate(temperatures):
            # step1. stack 값이 있는지 확인
            # step2. 현재 온도가 stack의 쌓여 있는 index의 값보다 크다면
            while stack and cur > temperatures[stack[-1]]:
                # stack에서 해당 index 추출
                last = stack.pop()
                # 해당 index 위치에 정답 입력
                # 현재 i 와 차이값으로 세팅
                answer[last]=i-last

            # 현재 온도의 index가 추가 돼야 추후 온도들과 비교 가능
            stack.append(i)

        return answer