1. 인접 행렬

# 변수 선언 및 입력
n, m = tuple(map(int, input().split()))

#index를 1번 부터 사용하기 위해 n+1만큼 할당합니다.
graph = [
    [0 for _ in range(n + 1)]
    for _ in range(n + 1)
]

visited = [False for _ in range(n + 1)]
vertex_cnt = 0

def dfs(vertex):
    global vertex_cnt

    # 해당 정점에서 이어져있는 모든 정점을 탐색해줍니다.
    for curr_v in range(1, n + 1):
        # 아직 간선이 존재하고 방문한 적이 없는 정점에 대해서만 탐색을 진행합니다.
        if graph[vertex][curr_v] and not visited[curr_v]:
            visited[curr_v] = True
            vertex_cnt += 1
            dfs(curr_v)


for i in range(m):
    v1, v2 = tuple(map(int, input().split()))

    # 각 정점이 서로 이동이 가능한 양방향 그래프이기 때문에
    # 각 정점에 대한 간선을 각각 저장해줍니다.
    graph[v1][v2] = 1
    graph[v2][v1] = 1

visited[1] = True
dfs(1)

print(vertex_cnt)

2. 인접 리스트

# 변수 선언 및 입력
n, m = tuple(map(int, input().split()))

#index를 1번 부터 사용하기 위해 m+1만큼 할당합니다.
graph = [[] for _ in range(n + 1)]

visited = [False for _ in range(n + 1)]
vertex_cnt = 0

def dfs(vertex):
    global vertex_cnt

    # 해당 정점에서 이어져있는 모든 정점을 탐색해줍니다.
    for curr_v in graph[vertex]:
        # 아직 간선이 존재하고 방문한 적이 없는 정점에 대해서만 탐색을 진행합니다.
        if not visited[curr_v]:
            visited[curr_v] = True
            vertex_cnt += 1
            dfs(curr_v)


for i in range(m):
    v1, v2 = tuple(map(int, input().split()))

    # 각 정점이 서로 이동이 가능한 양방향 그래프이기 때문에
    # 각 정점에 대한 간선을 각각 저장해줍니다.
    graph[v1].append(v2)
    graph[v2].append(v1)

visited[1] = True
dfs(1)

print(vertex_cnt)

인접 리스트와 인접 행렬의 차이점

for curr_v in graph[vertex]:
    if not visited[curr_v]:
        visited[curr_v] = True
        vertex_cnt += 1
        dfs(curr_v)

인접 리스트

for curr_v in range(1, n + 1):
    if graph[vertex][curr_v] and 
        not visited[curr_v]:
            visited[curr_v] = True
            vertex_cnt += 1
            dfs(curr_

인접 행렬

도달할 수 있는 정점의 수 구하기

import sys
import copy

## sys.exit() 디버깅 아예종료
## sys.maxsize = 정수 최대값

n,m = map(int,input().split())
graph = [
    list(map(int,input().split()))
    for i in range(n)
]

visited=[[0 for i in range(n)] for l in range(m)]

dxs, dys = [1,0], [0,1]

def can_go(x,y):
    print(x,y)
    if x<m and x>=0 and y<n and y>=0:
        return True
    if visited[x][y]==0:
        return False
    return False

cnt=0

def dfs(x,y):
        # dx, dy로 이동할 수 있는 방법 경우의 수 작성
    for dx, dy in zip(dxs,dys):
        dx, dy = x + dx, y + dy
        if dx<n and dx>=0 and dy<m and dy>=0:
            if graph[dx][dy]==1:
                graph[dx][dy]=0
                visited[dx][dy]=1
                dfs(dx,dy)

visited[0][0]=1
dfs(0,0)
if visited[-1][-1]==1:
    print(1)
else:
    print(0)

DFS (Stack)

• 최대한 깊게 탐색한 후 더이상 도달할 수 없는 상황이라면 이전으로 돌아가는 방식 따라서 , 방문할 수 있는 지점이 있다면 방문하는 함수를 재귀호출. 더 이상 없다면 함수를 종료

→ 유의점은 방문했던 지점을 또 방문하면 효율이 떨어지므로 visited라는 배열을 만들어 이전에 방문 여부를 확인해야함

반드시 재귀함수를 이용하여 작성함

Heapq

• 가장 작은 두 숫자를 계속 빠르게 구해주기 위해 사용

import heapq

# 변수 선언 및 입력:
n = int(input())
arr = list(map(int, input().split()))

pq = []
ans = 0

# 우선순위 큐에 원소들을 전부 넣어줍니다.
# 작은 숫자 2개를 골라 합치는 것이 항상 유리함을 이용해야 하므로
# 작은 숫자가 먼저 골라질 수 있도록 해야합니다.
for elem in arr:
    heapq.heappush(pq, elem)

# 원소가 2개 이상이면 계속
# 가장 작은 숫자 2개를 골라
# 합치는 것을 반복합니다.
while len(pq) > 1:
    x1 = heapq.heappop(pq)
    x2 = heapq.heappop(pq)

    # 가장 작은 숫자 2개를 더하기 위한 비용을 답에 더해주고,
    # 두 숫자를 합친 결과를 우선순위 큐에 다시 넣어줍니다.
    ans += (x1 + x2)
    heapq.heappush(pq, x1 + x2)

print(ans)

묶음 내 특정 원소를 기준으로 정렬하는 방법

lst = [~~]
# N번째 원소 기준으로 오름차순 정렬시
lst.sort(key=lambda x:x[n-1]

# N번째 원소 기준으로 내림차순 정렬시
lst.sort(key=lambda x:x[n-1], reverse=True)

Lambda 란?

lambda a : b

• a : 입력 인자
• b: 입력 인자를 사용하여 계산할 값 즉, 계산하고 반환되는 값을 의미

특정 기준을 만족하는 배열 만들기

cmp_to_key(compare)

def compare(x, y):
    if x+y > y+x:
        return -1
    elif x+y == y+x:
        return 0
    else:
        return 1

1. 양수 return → 두 input의 자리를 변경
2. 음수 return → 두 input의 자리 유지

두 가지 방안으로 사용 가능

arr.sort(key=cmp_to_key(compare))

arr = sorted(l, key=cmp_to_key(compare))

• Key란 정렬 조건을 의미함
  • 따라서 compare조건에 따른 정렬 조건을 임의로 만드는

동전 개수 최소로 구하기

$O(N)$

5원 동전 개수를 정하고 차액을 2로 나눌 수 있는지

MAX_NUM = n//5

for i in range(0, MAX_NUM + 1):
    remainder = n - 5 * i
    if remainder >= 0 and remainder % 2 == 0:
        ans = min(ans, i + (remainder // 2))

$O(N^2)$

5원 개수 최대치와 2원 개수 최대치를 모두 탐색

M = n//2
m = n//5

for i in range(m,0,-1):
    for l in range(M):
        if (i*5+l*2)==n:
            lst.append(l+i)

XOR

• arr[i] ^= 1은 arr[i]의 값이 0이면 1로, 1이면 0으로 바꾸는 작업을 수행

  • 두 비트가 같으면 0을 반환 (0 ^ 0 = 0, 1 ^ 1 = 0)

  • 두 비트가 다르면 1을 반환 (1 ^ 0 = 1, 0 ^ 1 = 1)

    1. sys

• sys.exit()

  • 함수 바로 종료

• sys.maxsize

  • 정수형 값중 최대값

2. 깔끔한 코드

• 최소값 리턴

if current > sub:
    current = sub

---------------------------------------------

current = min(current,sub)

• 배열에서 n개 원소 제외한 값의 경우의 수

# 총 합을 계산하고, 2중 for문을 통해 해당하는 원소만 골라서 합에서 빼주는 방

a = sum(list)
for i in range(len(list)):
    for l in range(i+1, n):
        del_2_param = a - list[i] - list[l]

---------------------------------------------        

# 나는 원소 한개 빼고 딥카피를 반복함 

for i in range(n):
    sub = copy.deepcopy(lst)
    del sub[i]
    for l in range(len(sub)):
        sub_2 = copy.deepcopy(sub)
        del sub_2[l]

Authorization

• 클라이언트 인증 정보를 서버에 전달

WWW-Authenticate

• 리소스 접근시 필요한 인증 방법 정의
• 보통 401 Unauthorized 응답과 함께 사용한다
  • WWW-Authenticate : Newauth realm="apps", type=1, title="Login to "apps"",Basic realm="simple"

Newauth realm="apps", type=1, title="Login to "apps""

• Newauth라는 사용자 정의 인증 방식을 설명

** realm="apps"**

• 인증이 적용되는 영역, 자원을 의미하며 클라이언트에게 어떤 영역에 대한 인증이 필요한지 알려주는 역할

type=1, title="Login to "apps""

• 추가적인 인증 정보를 의미하며 구체적인 방법은 서버, app의 문서를 참조해야함

Basic realm="simple"

• HTTP 기본 인증을 의미하며, 사용자의 이름과 비밀번호를 :로 연결 후 Base64로 인코딩하여 전송함

Stateless (무상태)

1. HTTP는 무상태 프로토콜
2. 요청과 응답을 주고받으면 연결이 끊어짐
3. 재 요청시 서버는 이전 요청을 기억하지 못함
4. 서로 상태를 유지하지 않음

위 특징을 해결하기 위해 착안한 방안

1. 쿠키

Set-Cookie

• 서버에서 클라이언트로 쿠키 전달

  Cookie

• 클라이언트가 서버에서 받은 쿠키를 저장 후, HTTP 요청시 서버로 전달

  생명 주기

• 영속 쿠키

1. Set-Cookie : expires=sat, OO-DEC-OOOO 00:00:00 GMT

   만료일 지날경우 삭제

2. Set-Cookie : max-age=3600

   0이나 음수 지정시 쿠키 삭제

• 세션 쿠키

  만료 날짜 생략시 브라우저 종료시 까지만 유지

  도메인

domain=example.org

1. 명시 - 명시한 문서 기준 도메인 + 서브 도메인 포함

• domain=example.org 쿠키 생성시

  • example.org, dev.example.org도 쿠키 접근 가능

2. 생략 - 현재 문서 기준 도메인만 적용

• example.org에서 쿠키 생성 후 domain 지정을 생략

  • example.org 에서만 쿠키 접근, dev.example.org는 쿠키 미접근

경로

경로를 포함한 하위 경로 페이지만 쿠키 접근

ex)

• path=/home 지정 시,
• /home, /home/level1/~ 가능
• /hello 불가능

보안

1. Secure

• 쿠키는 http,https 구분하지 않고 전송
• Secure 적용시 https인 경우에만 전송한다

  2. HttpOnly

• JS에서 접근 불가능함
• HTTP 전송에만 사용함

  3. SameSite

• 요청 도메인과 쿠키에 설정된 도메인이 같은 경우만 쿠키를 전송한다

사용처

1. 사용자 로그인 세션 관리
2. 광고 정보 트래킹

주의 사항

• 보안에 민감한 데이터 저장 지양

생명 주기

1.1 쿠키 미사용시

• 모든 요청과 링크에 사용자 정보를 포함시킨다

-> 브라우저 완전히 종료하고 다시 열면 동일한 문제 발생 -> 요청마다 데이터 낭비가 생길 가능성이 높음

2. 캐시

캐시가 없을 때의 특징

1. 데이터 변경이 없어도 계속 네트워크를 통해 데이터를 다운받아야함
2. 브라우저 로딩 속도가 느림

캐시 사용시 특징

1. 캐시 유효 시간동안 네트워크를 사용하지 않아도 됨
2. 브라우저 로딩 속도가 빨라짐

HTTP/1.1 200 OK
Content-Type: image/jpeg
cache-control: max-age=60 //브라우저 내의 캐시에서의 유효시간 60초를 의미
Content-Length: 34012

--message body--

캐시 시간 초과

• 캐시 유효 시간 만료시 서버에서 데이터를 다시 조회, 캐시를 갱신함

이때, 서버에서 기존 데이터를 변경 혹은 유지 두 가지 상황이 나타남

1. 데이터를 변경하지 않았을 경우

• 클라이언트의 데이터와 서버의 데이터가 같다는 사실을 확인할 수 있음

ex)

HTTP/1.1 200 OK
Content-Type: image/jpeg
cache-control: max-age=60의미
Last-Modified : 0000년 00월 00일 00:00:00 // 데이터의 수정 시간을 의미
Content-Length: 34012

--message body--

Last-Modified를 기준으로 데이터의 수정 여부를 확인할 수 있음

위처럼 Last-Modified를 검증 헤더라고 하는데, 검증 헤더는 조건부 요청과 함께 쓰는 경우가 많음

검증 헤더와 조건부 요청

• 304 Not Modified + 헤더 메타 정보만 응답
• 응답 헤더 정보로 캐시의 메타 정보를 갱신함, 만약 미갱신시 캐시에 저장돼있는 데이터를 재활용함
• 이 과정에서 네트워크 다운로드가 발생하긴 하지만 용량이 적은 헤더 정보만을 다운받으므로 매우 실용적인 해결책임

검증 헤더

• 캐시 데이터와 서버 데이터가 같은지 검증하는 데이터

ex) Last-Modified, ETag

1. Last-Modified

• 데이터가 수정 됐다면 200 OK, 미변경시 304 Not Modified

2. ETag

• 데이터를 변경시 이름을 바꾸기 때문에 단순히 ETag를 보내서 같으면 유지, 다르면 다시 다운 받기를 선택할 수 있음 ex) ETag : "v1.0" -> ETag: "v2.0"

조건부 요청 헤더

• 검증 헤더로 조건에 따른 분기

ex) If-Modified-Since: Last-Moidified 사용

If-None-Match : ETag 사용 조건 만족시 200 OK, 불만족시 304 Not Modified

캐시 제어 헤더

1. Cache-Control - 캐시 제어

하위 호환

2. Pragma - 캐시 제어
3. Expires - 캐시 유효 기간

Cache Control

1. max-age

• 캐시 유효 시간 단위

2. no-cache

• 데이터는 캐시해도 되지만, 사용할때마다 본 서버에서 검증하기

3. no-store

• 저장하면 안됨 (개인정보 등)

Pragma

하위 호환으로, no-cache만을 사용함

Expires

하위호환으로 캐시 만료일을 지정한다

• 캐시 만료일을 정확한 날짜로 지정함

ex) Mon, 01 Jan 1990 00:00:00 GMT

하지만, 현재는 cahce-control의 max-age가 더 유연하므로 사용하지 않음

특정 지역에 위치한 서비스 제공하는 데이터 센터의 집합을 의미한다

AWS에서 다수의 컴퓨팅 서비스를 제공하기 위해서 대규모 서버 컴퓨터가 필요한데, 한 곳에 전부 몰아서 만들게 된다면 2가지 단점이 부각됨

1. 재해 발생시 모든 서비스 마비 ex) 카카오톡 데이터센터 화재
2. 글로벌 서비스의 경우 모든 서버 컴퓨터가 한 대륙에만 위치 할 경우 다른 대륙은 비교적 느린 서비스를 제공 받음

가용영역

특정 지역에 위치한 서비스를 제공하는 데이터 센터의 집합에서 그 중 하나를 의미

VPC

Virtual Private Cloud의 약자로 가상의 네트워크 영역을 의미한다

AWS 리전 하나 당 최대 5개의 VPC가 가능하며, 각 리전에는 한 개의 default VPC가 존재함

유의점

1. VPC는 사설 리소스이기에 사설 IPv4만 할당이 가능하다

2. 총 5개의 아이피 주소를 호스트에 할당 할 수 없음 2.1 서브넷의 네트워크 대역

   • 서브넷 네트워크 자체를 식별하는데 사용하기 때문

   2.2 VPC 라우터에 할당

   • VPC 라우터에 할당함으로써 서브넷 내의 인스턴스가 동일한 VPC 내의 다른 네트워크, 리소스, 인터넷과 통신 가능

   2.3 Amazon이 제공하는 DNS에 할당

   • 각 VPC에 대한 DNS 서비스를 제공함과 동시에 서브넷 범위 내의 미리 정해진 IP 주소에 서비스를 할당

   2.4 추후를 대비한 예약

   • 현재 사용하지 않지만, 향후 AWS가 새로운 기능을 추가함을 대비

   2.5 브로드 캐스트 주소

   * 전통적으로 IP 주소 범위의 마지막 주소는 사용하지 않음

VPC 실 사용시 내부에서도 서브넷을 나눠서 사용한다

• VPC에서 나눠진 서브넷은 다시 나눌 수 없음

VPC와 외부 네트워크 통신

일반적으로 사설 IP 대역은 공용 IP 대역과 통신이 불가한데 어떻게 통신을 할 수 있을까?

Public Subnet

외부와 통신이 원활한 VPC 서브넷

AWS에서는 Internet Gateway를 지정함으로써 서브넷을 퍼블릭 서브넷으로 사용할 수 있음

• 네트워크 패킷이 특정 방향으로 이동하게 만드는 방법을 라우팅이라고 한다 따라서 Internet Gateway를 지정한다고 해서 외부 네트워크가 통신이 가능한게 아닌, 라우팅 테이블을 설정해줘야 정상적으로 통신이 가능하다

Destination, Target

Destination : VPC 주소, VPC로 들어올 때의 주소 Target : Local, 내부VPC 라우터가 보낼 곳

ex) Destination : 10.0.0.0/16

• 라우팅 테이블 내 규칙이 적용될 대상 네트워크의 IP 주소 범위를 ㅡ이미하며, VPC 내의 어떤 주소로 향하는 트래픽에 적용된다

Target : Local

• 어떤 주소로 향하던 트래픽을 어디로 전달할 것인지에 대한 정보이다

Private Subnet

외부와 통신되지 않는 VPC 서브넷

사설 아이피 대역의 장점

1. 부족한 아이피 주소 문제 완화
2. 높은 보안성

높은 보안성

포트포워딩 :하나의 공용 아이피 주소를 가진 공유기가 자신의 포트를 통해 자신의 사설 아이피 주소를 가진 디바이스에게 데이터를 주는 것

사설 아이피를 가진 디바이스에게 데이터를 직접 줄 수 없고 공유기를 거쳐야 하므로 보안성 측면에서 강점을 가지낟

예를 들어 데이터베이스의 사용을 생각해보자

1. Private Subnet은 외부와 통신이 안되면 데이터베이스를 사용할 수 없지 않나

-> DB를 사용하는 컴퓨팅 자원을 같은 VPC에 배치

2. 데이터베이스에 원격으로 접속하는 방법은 뭔가

->Mysql Workbench, DataGrip으로 원격 접속하기

• Database가 Private Subnet에 존재할경우 DataGrip으로 원격 접속이 불가

• Bastion host를 사용함으로써 Private Subnet의 자원에 접속할 수 있도록 하기

• OS가 다루는 프로세스를 서버라고 칭할 수 있다.

• 서버와 클라이언트간의 연결을 하는 매개체 역할로 소켓이 있는데, 이를 통해 IPC를 수행할 수 있다

IPC(Inter-Process Communication) 란?

• 프로세스들간에 서로 데이터를 주고 받는 행위, 방법 또는 경로를 의미한다

누구에게 어디로 보낼 것 인가

IP, Port

데이터를 주고 받기 위해서는 어디로에 해당하는 주소가 매우 중요하다 누구에게를 식별하기 위해 사용되는 것이 IP주소와 포트번호이다

원래는 IP주소만으로 사용했지만, 컴퓨터 보급량의 증가로 IP 개수의 한계로 이를 해결하기 위해 포트번호를 도입하게 됐다

현실에 비유를 해보자면, 기존에 한국은 단독주택(IP)으로 잘 생활하고 있었다 하지만 한국의 땅 크기는 고정돼있고, 인구의 증가로 단독주택에서 아파트를 짓고 아파트 내에서 호수(포트번호)를 나누게 되었다

어떤걸 어떻게 보낼 것 인가

위에서 어디로와 누구에게를 해결했다면, 다음으로는 어떤걸,어떻게를 정해야한다

데이터의 송수신 절차

송신

Application -> Sockets -> 네트워크 스택 -> NIC(랜카드) -> 외부

      write()
    데이터 전송

수신

Application <- Sockets <- 네트워크 스택 <- NIC(랜카드) <- 외부

                                      Interrupt
                                     데이터 수신

소켓 Socket

송수신 절차 중간에 껴있는 소켓은 무엇이냐

그림만 봐도 알 수 있듯이, 다양한 시스템 콜이 일어나는 곳으로 os의 제어를 받는다

소켓의 시스템 콜

1. socket()

• 소켓의 형태를 만드는 시스템 콜

  Input

• domain* - 도메인 선택
  • IPv4, Ipv6

    ---

• type* - 소켓의 종류 선택
  • stream, datagram

    ---

• protocol* - 프로토콜 선택
  • tcp, udp

    ---

• Output* 파일 디스크립터

파일 디스크립터

• OS가 파일 디스크립터를 받았을 때, 데이터를 송수신 하기 위한 소켓을 알려주는 역할을 한다

※ 파일 디스크립터를 소켓을 특정해주는 '키'라고 한다면, 그에 대한 '벨류'는 리소스(소켓, 파일)등 에 대한 메타데이터라고 비유할 수 있다

2. bind()

• 생성한 소켓에 IP주소와 Port를 부여하는 시스템 콜

  Input

• sockfd* - 바인딩 할 소켓의 파일 디스크립터
• sockaddr* - 바인딩 할 IP, port를 담은 구조체
• socklen_t* - 구조체의 메모리 크기

3. listen()

• 연결지향 네트워크인 TCP에서만 사용하는 시스템 콜

  Input

• sockfd* - 소켓의 파일 디스크립터
• backlog* - TCP 백로그 큐의 크기

4. accept()

• 클라이언트의 요청을 보관해둔 백로그 큐에서 연결을 매칭시켜줌

  Input

• sockfd* - 클라이언트의 요청을 받을 소켓의 파일 디스크립터
• sockaddr* - 백로그 큐에서 빼온 클라이언트의 주소 정보
• socklen_t* - 구조체의 메모리 크기

• Output* 소켓

queue의 자료구조 형태를 가진 백로그 큐에서 저장된 다수의 클라이언트 요청을 순차적으로 처리하면 어쩔 수 없이 병목현상이 발생하게됨

이를 해결하기 위해 accept() 시스템 콜을 사용한다

기존에 socket()으로 서버 소켓(클라이언트의 요청을 받을 메인 소켓)을 생성했다면, accept()를 사용해 클라이언트 소켓(서버 소켓의 백 로그 큐에 있는 요청을 처리하는 보조 소켓)을 생성한다.

보조 소켓을 병렬 처리에 사용하기 위해서 fork()라는 시스템 콜을 사용하여 프로세스를 추가로 생성한다

fork를 통해 추가로 생성한 프로세스와, accept를 통해 생성한 소켓을 매칭시켜줘서 병렬처리할 수 있도록한다.

fork와 accept를 통해 병렬 처리를 함으로써 병목 현상을 해결함 하지만 병렬 처리를 함으로써 발생하는 오류인 동시성은 아직 문제이다

소켓의 시스템 콜 정리

1. socket()

• 소켓의 틀을 결정하고, 파일 디스크립터를 결과값으로 반환

2. bind()

• 생성된 소켓에 IP와 Port번호를 부여

3. listen()

• 클라이언트의 요청을 보관해둘 백로그 큐를 생성

4. accept()

• 소켓이 통신할 준비가 됐다는 것을 알리기 위한 시스템 콜

1999년 RFC2616 -> 2014년 RFC7230~7235 엔티티 ( 헤더 + 본문) -> 표현 ( 데이터 + 메타데이터)

서버가 응답 메시지를 보냈을 때를 예시로 들어보자

HTTP/1.1 200 OK
---표현 헤더
Content-Type
Content-Length
---표현 데이터
<html>
  <body>...</body>
</html>

표현 헤더의 종류

표현 헤더의 경우 전송(클라이언트)과 응답(서버) 둘다 사용한다

1. Content-Type : 메시지 바디 형식
2. Content-Encoding : 표현 데이터의 압축 방식
3. Content-Language : 표현 데이터의 자연 언어
4. Content-Length : 표현 데이터의 길이

표현 데이터 형식

1. Content-Type : html, json, png
2. Content-Encoding : gzip, deflate, identity
3. Content-Language : ko, en, en-US
4. Content-Length : 바이트 단위를 의미

협상

클라이언트가 선호하는 표현 요청으로, Content-Negotiation을 의미

협상 적용 전

GET /event

-> Content-Language: en hello

협상 적용 후

GET / event Accept-Language: ko -> Content-Language: ko 안녕하세요

만약, 원하는 요청이 서버에서 지원하지 않을 경우 디폴트 값으로 서버는 응답 서버에서 지원하지 않을 경우를 대비해 우선순위를 줄 수 있음

ex) Accept-Language: ko-KR, ko;q=0.9, en-US;1=0.8 Language뿐만 아니라, Type에도 적용이 가능하다

전송 방식

1. 단순 전송
2. 압축 전송
3. 분할 전송
4. 범위 전송

1. 단순 전송

길이(Content-Length)를 알 수 있을때만 사용

HTTP/1.1 200 OK Content-Type : ~ Content-Length : ~~

2. 압축 전송

HTTP/1.1 200 OK Content-Type : ~ Content-Encoding : gzip Content-Length : ~~

3. 분할 전송

Content-Type : ~ Transfer-Encoding : chunked ※ Content-Length 가 필요하지 않음

표현 데이터의 형식을

길이 내용 길이 내용

위와 같은 형식으로 보내는 방법

4. 범위 전송

응답 중에 오류로 중간에 끊기면 처음부터 보내야 하는 상황이 발생하므로 범위로 끊어서 보내는 방법

HTTP/1.1 200 OK Content-Type : ~ Content-Rage: bytes ab/bc

표현 데이터가 포함하는 정보

1. From - 유저 이메일 정보

• 검색 엔진, 요청에서 사용

  2. Referer - 이전 웹 페이지 주소

• 유입 경로 분석 가능

  3. User-Agent - 유저 애플리케이션 정보

• 특정 브라우저 오류 발생시 로그 파싱으로 어떤 브라우저인지 확정 가능

  4. Server - 오리진 서버의 SW 정보

  5. Date - 메시지 생성 날짜

  6. Host - 도메인

• 하나의 IP 주소에 여러 도메인이 적용 되어있을 경우 도메인을 특정하기 위해 반드시 필요한 것

7. Location - 리다이렉션

• 3xx 응답 결과에 Location 헤더가 있을경우 해당 위치로 자동 리다이렉트

  8. Allow - 허용 가능한 HTTP 메서드

• GET, HEAD, PUT

  9. Retry-After - 유저가 다음 요청하기까지 대기 시간

• 날짜 표기 ( 해당 날짜 이후 가동되도록 ), 초단위 표기 ( 시간 초 이후 가동)

클라이언트가 보낸 요청의 처리 상태를 서버가 알려주는 기능을 의미 1-- : 요청이 수신되어 처리중 2-- : 요청 정상 처리 3-- : 요청을 완료하려면 추가 행동이 필요 4-- : 클라이언트의 오류 5-- : 서버 오류

1-- (처리중)

말 그대로 처리중일때 받을 수 있는 상태코드

2-- (성공)

200 - OK 201 - Created , 생성 완료

• 요청이 성공하여 새로운 리소스가 생성됨을 의미
• ex) post로 등록
  202 - Accepted
• 요청이 접수됐으나 처리는 완료되지 않음
• ex) Batch 처리
  204 - No Content
• 요청을 성공적으로 수행, 서버가 클라이언트에게 따로 보낼 메세지가 없음
• ex) post로 저장처럼 데이터의 변동은 있지만, 환경 변경이 필요 없을 때

3-- (리다이렉션)

리다이렉션이란, 클라이언트의 요청으로 인한 서버의 응답에서 location 헤더가 있을 경우, 해당 위치로 자동 이동하는 것

리다이렉션의 종류

1. 영구 리다이렉션
2. 일시 리다이렉션
3. 특수 리다이렉션

영구 리다이렉션 (301, 308)

• 특정 리소스의 URI가 영구적으로 이동
• ex) /members -> /users

301 - Moved Permanently

• 리다이렉트시 요청 메서드가 GET으로 변할수도 있음

308 - Permanent Redirect

• 리다이렉트시 요청 메서드와 본문 유지

301과 308의 차이점

308은 리다이렉션을 해도 기존의 method유지, 301은 GET으로 메소드 변환

일시적인 리다이렉션 (302,307,308)

리소스의 URI가 일시적으로 변경되는 것으로 검색 엔진 등에서 URL을 변경하면 안된다

• 주문 완료 후 주문 내역 화면으로 이동
• 자주 쓰이는 패턴 - Post/Redirect/Get

302 - Found

• 리다이렉트시 요청 메서드가 Get으로 변할수도있음

• 307 - Temporary Redirect*
• 302와 기능은 동일하지만, 기존 메서드와 본문은 유지된다

• 303 - See Other*
• 302와 기능은 같지만 반드시 메소드가 GET으로 변경됨

정리하자면,

• 302는 Get으로 변할 수 있음

• 307은 메소드가 변하지 않음
• 303은 메소드가 Get으로 변함
  303,307을 권장하지만, 현재 이미 많은 앱들이 302를 사용 중

PRG (Post/Redirect/Get)

Post 주문 후 Redirection 시 다시 Post로 인한 재 주문 방지를 위함 따라서, 주문 후 주문 결과 화면을 Get으로 리다이렉트 하게

기존 요청 -> DB 저장 -> 응답 -> 새로고침으로 인한 요청 -> DB 주문 -> 응답 위 처럼 진행될 경우 새로고침마다 주문 횟수 증가

개선 요청 -> DB 저장 -> 응답 -> 자동 리다이렉트(다른 화면으로 이동, Post에서 Get으로 변환) -> 요청 -> DB 조회 -> 응답

특수 리다이렉션

• 결과 대신 캐시 사용

4-- (클라이언트 오류)

오류의 원인이 클라이언트에 있을 경우로, 재시도를 하더라도 실패함

400 Bad Request

• 문법, 메세지 오류

  401 Unauthorized

• 인증 되지 않음

  403 Forbidden

• 인증 자격은 있지만, 접근 권한이 불충분
• 등급에 맞지 않는 리소스 접근

  404 Not Found

• 권한이 부족한 리소스에 접근

5-- (서버 오류)

서버 문제이기 때문에 재시도 하면 성공할 가능성 존재

좋은 URI 설계란 무엇인가?

좋은 URI를 설계하기 위한 가장 중요한 점은 리소스를 식별이다

그렇다면 리소스란 뭘까

회원 명부를 예시로 든다면, 회원을 등록, 수정, 조회, 삭제 등이 있을때 회원을 리소스, 등록, 수정 등을 메소드라고 할 수 있다

그렇다면 리소스는 어떻게 식별하도록 하는게 좋은 URI 설계일까? -> 메소드를 배제하고, 오직 리소스만을 식별할 수 있도록 만들어야 한다

리소스를 식별할 수 있는 수단인 메서드에 대해서 알아보자

HTTP 메서드의 종류

1. GET - 리소스 조회
2. POST - 요청 데이터 처리 ex) 등록
3. PUT - 리소스를 대체하며 없을경우 생성한다
4. PATCH - 리소스 부분 변경
5. DELETE - 리소스 삭제

6. HEAD - 상태줄과 헤더만 조회
7. OPTIONS - 통신 가능 메소드를 설명
8. CONNECT - 서버에 대한 터널 설정
9. TRACE - 메시지 루프백 테스트 수행

GET

• 리소스를 조회
• 서버에 전달하고 싶은 데이터는 query를 통해 전달
• 메세지 바디를 통해 데이터 전달이 가능하지만, 지원 하지않는 경우가 많아 X

• 요청* GET /numbers/100 HTTP/1.1 Host: localhost:8080

• /numbers/100 { username : XX, age : OO }

• 응답* HTTP/1.1 200 OK Content Type: Content Length { username : XX, age : 00 }

Post

• 요청 데이터 처리
• 메시지 바디를 통해 서버로 데이터 전달
• 서버는 요청 데이터를 처리함
• 주로 신규 리소스 등록에 사용

• 요청* Post /members HTTP/1.1 Content-Type { username : XX, age : 00 }

• /members/OOO 신규 리소스 식별자 임의의 위치에 생성

• 응답* HTTP/1.1 200 OK Content Type: Content Length Location : /members/OOO << 생성 경로 제공 { username : XX, age : 00 }

사용처

1. 새 리소스 생성

• 서버에 아직 존재하지 않는 신규 리소스 생성

  2. 요청 데이터 처리

• 프로세스의 상태가 변경되는 경우 ex) 주문 -> 결제완료 -> 배달시작 -> 배달완료 POST /orders/{orderID}/start-delivery POST /orders/{orderID}/complete-delivery

PUT

메시지 바디에서 모든 필드 값이 아닌 일부만 있다면 그 외의 필드값은 삭제하며 메시지 바디 내의 필드값으로 재생성

쉽게 말해 덮어쓰기

PUT /members/100 HTTP/1.1

POST는 서버가 위치를 관리하는 것과 다르게 PUT의 경우 위 처럼 _클라이언트가 리소스 위치를 인지하는 상태에서 URI(members/100)을 지정해야함

PATCH

리소스의 부분 변경

메시지에 모든 필드 값이 아닌 일부만 있다면 그에 해당하는 일부만 값을 변경

DELETE

리소스 삭제

HTTP는 Hyper Text Transfer Protocol의 약자

HTTP 특징

• 클라이언트 서버 구조를 사용한다

  • Request Response 구조를 의미하며, 클라이언트가 서버에 요청(request)을 하면 서버가 클라이언트에게 응답(Response)를 하는 방식을 의미한다

• 무상태 프로토콜을 사용하며 비연결성이다

  무상태 프로토콜(Stateless) 서버가 클라이언트의 상태를 보존하지 않는 경우 ** 상태 유지**(Stateful)

    서버가 클라이언트의 상태를 보존하는 경우

상태 유지

• 항상 같은 서버가 유지 되어야함 클라이언트의 요청에 이전 상황에 대한 정보가 없기 때문에 계속 소통하던 서버와의 소통이 이루어져야함

• ex) 로그인

무상태 프로토콜

• 어느 서버든 상관없음 클라이언트 요청에서 이전 상황에 대한 요청을 모두 보내기에 같은 기능을 한다면 어떤 서버로 보내든 상관 없음

• 상태 유지보다 많은 데이터를 보내야함
• ex) 단순한 서비스 소개 화면

→ 중간에 프록시 서버와 원 서버의 연결이 끊길 경우, 무상태 프로토콜은 임의의 같은 기능을 가진 서버로 연결하면 되지만 상태 유지의 경우 작업이 불가함

비 연결성

일반적으로 클라이언트와 서버 구조는 한번** TCP/IP 연결시 연결을 유지함 하지만, 다수의 클라이언트가 하나의 서버와 **연결 후 더 이상 소통하지 않음에도 연결돼있다면 자원이 낭비되므로 나온게 비 연결성이다.

비 연결성은 요청과 응답 후 TCP/IP 연결을 종료함으로써 서버 자원 낭비를 방지함

※ HTTP는 기본이 비 연결성이다

장점

• 수천명이 서비스를 사용해도 서버에서 동시 처리하는 요청은 수십개 이하 ex) 브라우저 검색시 연속으로 검색을 누르지 않음
• 서버 자원 사용이 효율적

단점

• TCP/IP 재연결시 3 way handshake 시간이 추가됨
• 요청 시 다양한 자원을 함께 다운로드 해야함 ex) 연결 - HTML - 종료, 연결 - JS - 종료 ---

위 단점을 해결하기 위해 나온 방안이 지속 연결이다.

지속 연결

기존에 HTML, JS 및 데이터를 다운받을때 종류별로 연결과 종료를 했지만, 한 Task는 한번의 연결 싸이클에 다 응답받을 수 있도록 하는 방안을 의미 → 연결 - HTML - JS - IMG - 종료

HTTP 메시지

HTTP 메시지는 클라이언트의 요청 메시지, 서버의 응답 메시지로 나눌 수 있다

HTTP 메시지는 다음과 같은 형식을 가진다 시작 라인 헤더 공백라인(CRLF) 메세지 바디

HTTP 메시지는 request-line(요청) 과 status-line(응답) 두 가지로 나뉜다

request-line

1. 시작 라인 = method SP request-target SP HTTP-version CRLF**
2. 헤더 = field-name ":" OWS field-value OWS

request-line

Get /serach?q=hello&hl=ko HTTP/1.1
Host : www.google.com

status-line

1. 시작 라인 = HTTP-version SP status-code SP reason-phrase CRLF
2. 헤더 (metadata of message body) &nbsp2.1 Content-Type &nbsp2.2 Content-Length
3. CRLF
4. 메시지 바디 (실제로 전송할 데이터)

status-line

HTTP/1.1 200 OK
Content-Type : text/html;charset=UTF-8
Content-Length : 3423
CRLF
<html>
    <body>...</body>
</html>

• SP : Space
• CRLF : Enter
• OWS : 띄어쓰기 허용

Uniform Resource Identifier의 약자 Uniform : 리소스를 식별하는 통일된 방식 Resource : URI로 식별할 수 있는 모든 자원 Identifier : 다른 항목과 구분하는데 필요한 정보

Identifier의 종류

1. URL (Locator)

• 리소스의 위치

  2. URN (Name)

• 리소스의 이름

URL(위치)는 변할 수 있지만, URN(이름)은 잘 변하지 않기에 URN(이름)만으로 실제 리소스를 찾는 방법이 보편화 되지 않아 잘 사용하지 않는다

따라서, URI를 URL과 동치로 보는게 편하다고 한다

URL의 구조

Scheme://[userinfo@]host[:port][/path][?query][#fragment] Https://www.google.com:443/search?q=hello&hl=ko

Scheme

• 주로 프로토콜을 사용

※ 프로토콜 이란? 어떤 방식으로 자원에 접근할 것인가에 대한 규칙

host

• 호스트 명. 즉, DNS 혹은 IP 주소를 의미

Port

• 프로토콜(http,https) 사용시 생략할 경우 알아서 배정되므로 일반적으로 생략함

path

• 리소스 경로를 의미

query

• key=value 형태를 가지며 문법은 ?key=value&key=value 이다

• 다른 이름으로 query parameter, query string 등이 있다

  fragment

• 서버에 전송하는 정보가 아닌, html 내부 책갈피(원하는 위치로 가는 표식)을 의미

웹 브라우저 요청 흐름

1. 클라이언트가 HTTP 요청 메세지를 생성한다
2. Socket 라이브러리를 통해 전달
   • TCP/IP 주소, 데이터
3. HTTP 메세지를 포함한 TCP/IP 패킷 생성
4. 서버에 메세지 도착시, TCP/IP를 제외한 HTTP 메시지만을 사용

HTTP 요청 메세지

GET/search?q=hello&hl=ko HTTP/1.1 Host: www.google.com

HTTP 응답 메세지

메세지 헤더 HTTP/1.1 200 OK Content-Type: text/html:charset=UTF-8 Content-Length:3423 메세지 바디

응답 메세지를 받은 후 메세지 바디의 HTML 정보를 통해 우리가 검색 후 보이는 웹 화면을 렌더링한다

인터넷에서 컴퓨터 둘 즉, 클라이언트(사용자)와 서버는 어떻게 통신을 할까?

클라이언트와 서버를 연결하는 노드(프록시)들의 집합을 인터넷이라고 한다

어느 노드를 통해야 적절히 연결이 되는지 첫 연결시엔 알 수 없기에 우리는 집 주소처럼 컴퓨터마다 IP 주소를 부여한다

예를 들어, 광진구에 위치한 A와 성동구에 위치한 B가 있다고 가정 할 경우 A (광진구) - 화양동, 성수동, 군자동 - B(성수 1가 2동)

IP

IP는 인터넷 프로토콜(Internet Protocol)의 약자로, 패킷 이라는 통신 단위로 데이터를 전달한다

패킷

IP가 전달하는 패킷은 출발지 IP, 목적지 IP, 기타 정보와 보내고자 하는 데이터를 담고 있다

패킷 전달

클라이언트에서 패킷을 전달하면 목적지 IP로 다양한 노드들을 통해 도달하게 된다 서버가 정상적으로 패킷을 받게 된다면, 서버에서 제대로 받았는지에 대한 패킷을 통과한 노드의 역순으로 전달하여 오류 여부를 확인한다

IP의 한계

비 연결성

• 패킷을 받을 대상이 없거나 서비스 불능 상태여도 패킷이 전송되는 경우

*비 신뢰성 *

• 중간에 패킷이 사라지거나 패킷의 용량이 클때 분할해서 보낸 순서가 섞여서 되 돌아 오는 경우

프로그램 구분

• 같은 IP를 사용하는 서버에서 통신하는 어플리케이션이 둘 이상일 경우

TCP

전송 제어 프로토콜 (Transmission Control Protocol)의 약자로 세 가지 특징이 있으며, 신뢰할 수 있는 프로토콜이기에 현재 대부분 TCP를 사용한다

1. TCP 3 way handshake (가상 연결)

클라이언트와 서버의 연결 과정 클라이언트 ---SYN---> 서버 클라이언트 <---SYN+ACK--- 서버 클라이언트 ---ACK---> 서버 클라이언트 ---데이터---> 서버

SYC : 접속 요청 ACK : 요청 수락

※ 클라이언트가 서버에 ACK 전송시, 데이터도 같이 전송 가능함

2. 데이터 전달 보증

• 서버가 회신을 통해 데이터를 정상적으로 받음을 알림

  3. 순서 보장

• 용량이 큰 패킷을 분할 전송시 순서가 바뀌어 도착했다면 서버에서 알림을 보냄

UDP

사용자 데이터그램 프로토콜(User Datagram Protocol)의 약자로 IP의 상위호환, TCP의 하위호환으로 볼 수 있다.

IP에서 port와 체크섬 기능이 추가된 정도이며 TCP의 3가지 기능은 없음

TCP는 용량이 크기에 최적화에 한계가 있지만, UDP는 기능이 부족한 대신 단순하고 빠르다는 특징이 있음

Port

클라이언트가 한번에 둘 이상의 서버와 연결시 필요한 기능 예를 들어, 클라이언트가 둘 이상의 데이터를 보낼때, 각 데이터가 어느 서버에 매칭되는지를 알려주는 것 이라고 생각하면 된다

DNS

서버의 IP가 변경됐을 경우, 접근에 오류가 생길 것을 방지하기 위해 전화번호부 형태로 만들어진 기능

예시로 www.google.com - 200.200.200.2 www.naver.com - 300.300.300.3

• 위와 같을경우, IP가 변경되도 전화번호부 상의 IP를 업데이트를 해준다면 클라이언트는 DNS로만 접근하기 때문에 오류 없이 접근이 가능하다

인터넷 프로토콜 스택의 4 계층

1. 어플리케이션 계층

HTTP, FTP
ex) 웹브라우저, 게임, 채팅 프로그램 등

2. 전송 계층

TCP, UDP

3. 인터넷 계층

IP

4. 네트워크 인터페이스 계층

LAN 드라이버, LAN 장비

메세지의 전송 과정

1. 프로그램이 메세지를 생성
2. Socket 라이브러리를 통해 전달
3. 메세지 데이터를 포함한 TCP 정보 생성
4. TCP 데이터를 포함한 IP 패킷을 생성
5. 랜카드를 통해 서버로 전달

다수의 GPU를 사용하여 VRAM을 초과하는 batch_size를 선택했을 경우 사용할 수 있는 방법이다.

그냥 GPU 많이 써서 학습 시킨다고 생각하면 될듯

2. Ubuntu.sio 다운 받기

3. Vmware에 Ubuntu 설치

3.1 create to Virtual machine

3.2 ubuntu iso 파일설치

3.2.1 iso파일이 완전하게 설치되지 않았을 경우 오류 발생

3.3 이름, 비밀번호 자유지정

3.4 virtual machine 이름 짓기

3.5 VM 리소스 할당

Backchannel 이란?

백채널(이하 BC)은 대화에서 짧고 빠른 반응을 의미한다.

청자의 BC를 통해 화자는 청자가 잘 이해하고있는지, 공감되는지의 여부를 확인할 수 있다.

대화에서 적절한 타이밍에 적절한 BC를 사용하는 것은 대화를 조금 더 풍부하게 만들어준다.

위의 예시는 현재 모델을 학습시키는데에 사용하는 방식을 의미한 것이다.

음성은 BC발생 직전 1.5초를 사용하며 텍스트 정보의 경우엔 5, 10, 20등 다양한 길이를 사용한다.

실증에서 사용하기 위하여 AI가 적절한 BC를 생성해내기 위한 학습을 하고자한다.

현재 이 Task의 문제점은 다음과 같다.

1. 현재 대화에 중요한 시각적인 정보를 사용하지 않는다는 점
2. 음성과 텍스트간의 연관성을 찾지 않고 별개의 feature들을 통해 학습을 한다.

따라서 위 두가지를 해결하여 실증에서 AI가 적절한 BC를 생성해내기 위한 분류 및 생성을 하고자한다.

이 Task에서 다뤄지는 논문은 2개가 있다

1. BPM_MT

MFCC와 KoBERT를 사용하여 Concat을 통한 Loss와,
Sentiment dictionary와 대조를 시켜 만든 Sentiment Loss를 9:1의 비율로 Sum하여 학습시킨다.
이 논문은 Sentiment를 사용하여 성능을 높히고, text의 길이를 늘릴수록 성능이 좋다는 것을 보였다

2. Ortega

Ortega는 단순한 CNN 모델로써, Audio, text CNN을 통하고, 
listener embedding 총 3개의  feature를 concat한 후 Linear-Softmax를 통하여 Classifier를 한다.
이 논문은 BC 생성에 음성데이터의 중요도와 음성/텍스트의 길이에 따른 성능의 변화 추이를 보였다.

첫번째의 CrossEntropyLoss의 경우 클래스의 개수에 맞게 output 차원을 추출한다 ex) class가 4개일경우 출력값은 (batch_size,4)가 되어야한다.

• Softmax를 모듈 자체에서 지원하기 때문에 출력값을 바로 loss = F.cross_entropy(logit,label) 를 사용하면된다.

두번째의 BinaryCrossEntropyLoss의 경우 이진분류이기 때문에 softmax가 따로 없으므로 Sigmoid를 통과 시킨 후 비교를해야한다

• loss = nn.BCELoss(torch.sigmoid(logit),label)
• Batch_size 가 1인경우 - nn.sigmoid(logit)
• Batch_size 가 2이상인경우 - torch.sigmoid(logit) 을 사용해야한다.

세번째의 BCEWithLogitLoss의 경우 CrossEntropy에 softmax가 내장되어있는 것 처럼 BCE에 Sigmoid가 추가된 모듈이다

• 내가 알기로는 (batch_size,1)의 경우 BCEWithLogitLoss(logit,label) 대신 torch.sigmoid(logit)을 사용해야 오류가 없었던 것으로 기억한다.

1. Hierarchical Classification
2. Focal loss
3. Statistical algorithm 인데, 이 포스팅에서는 1번을 알아보자.

1. Hierarchical Classification

Hierarchical Classification 알고리즘은, 크게 클래스를 나누고 각 클래스 내부에서 2~n차적으로 클래스를 또 나누는 방법이다. 위의 알고리즘 방법으로 3가지가 있는데 다음과 같다

1.Top-down(Flat Classification) approach

2.Local classifiers approach

3.Big-bang classifiers approach

1.Top-down approach

가장 간단한 방법으로, 클래스의 계층을 무시하고 Leaf node의 클래스만 예측하는 방식이다. 이 방식은 train/test시에 기존의 일반적인 classification algorithm처럼 작동한다. 하지만, 이방식은 계층 분류 문제에 대한 간접적인 치팅??힌트?를 제공한다고 볼 수 있다. Leaf class에 할당될경우, 부모 클래스에 자동으로 힌트를 준다고 볼 수 있기 때문이다. 이 방법의 단점으로는 클래스 계층에 존재하는 부모-자녀 클래스 관계에 대한 정보를 확인하지않고 많은 수의 클래스(모든 리프 클래스)를 구별하기 위해 classifier를 구축해야 하는 심각한 단점을 가지고 있습니다.

2.Local classifiers approach

노드당 각각의 Local classifier의 접근 방식은 클래스 계층의 각 노드에 대해 하나의 이진 분류기 학습하는 방식으로 구성된다.

2.1 Local Classifier Per Node Approach

클래스 계층의 각 상위 노드에 대해 Multi-class classifier가 자식 노드를 구별하도록 훈련되는 방식이다.

2.2 Local Classifier Per Level Approach

Per Level 방식은 클래스 계층의 각 Level에 대해 하나의 다중 클래스 분류기를 학습하는 방식으로 구성된다.

3.Big-bang classifiers approach

Hierarchical Classification방법으로 2번의 Local 방안을 사용하여 해결할 수 있지만, 모든 클래스에 대해 단일 글로벌 모델을 학습하는 것은 일반적으로 글로벌 분류 모델의 전체 크기가 상당히 작다는 이점이 있습니다, 모든 로컬 분류기 접근법에 의해 학습된 모든 로컬 모델의 총 크기와 비교하여. 글로벌 분류기 접근 방식에서는 분류 알고리듬을 단일 실행하는 동안 클래스 계층 전체를 고려하여 훈련 세트에서 단일(상대적으로 복잡한) 분류 모델이 구축됩니다. 테스트 단계에서 사용되는 경우 각 테스트 예제는 잠재적으로 모든 계층 수준의 클래스를 테스트 예제에 할당할 수 있는 프로세스인 유도 모형에 의해 분류됩니다.

나머지 Class Imbalance를 해결하는 방안은 다음 포스팅에 확인해보도록 하자 . . 임시 저장이 안된 나머지 . . .. . . 사라졌다 . . .. . .

a=/data/datasets b=folder

os.path.join(a,b) #a와b사이에 쉼표 사용시에 /data/datasets/folder 와같이 슬래쉬가 자동생성됨 os.path.join(a+b) #a와b사이에 더하기 시에 /data/datasetsfolder 가되므로

• +를 사용할경우 a=/data/datasets/ b=folder

• ,를 사용할경우 a=/data/datasets b=folder 를 사용하도록 하자

Cross Attention을 구현하기 위한 초석으로

나동빈님의 코드를 분석하며 개인적으로 정리하는 글입니다.

import torch.nn as nn


class MultiHeadAttentionLayer(nn.Module):
    def __init__(self, hidden_dim, n_heads, dropout_ratio, device):
        super().__init__()

        assert hidden_dim % n_heads == 0

        self.hidden_dim = hidden_dim # 임베딩 차원
        self.n_heads = n_heads # 헤드(head)의 개수 ( 논문은 8개 )
        self.head_dim = hidden_dim // n_heads # 각 헤드(head)에서의 임베딩 차원

        self.fc_q = nn.Linear(hidden_dim, hidden_dim)
        # Query 값에 적용될 FC 레이어
        self.fc_k = nn.Linear(hidden_dim, hidden_dim)
        # Key 값에 적용될 FC 레이어
        self.fc_v = nn.Linear(hidden_dim, hidden_dim)
        # Value 값에 적용될 FC 레이어

        self.fc_o = nn.Linear(hidden_dim, hidden_dim)
        self.dropout = nn.Dropout(dropout_ratio)
        self.scale = torch.sqrt(torch.FloatTensor([self.head_dim])).to(device)

    def forward(self, query, key, value, mask = None):

        batch_size = query.shape[0]

        # query: [batch_size, query_len, hidden_dim]
        # key: [batch_size, key_len, hidden_dim]
        # value: [batch_size, value_len, hidden_dim]

        Q = self.fc_q(query)
        K = self.fc_k(key)
        V = self.fc_v(value)

        # Q: [batch_size, query_len, hidden_dim]
        # K: [batch_size, key_len, hidden_dim]
        # V: [batch_size, value_len, hidden_dim]

        # hidden_dim → n_heads X head_dim 형태로 변형
        # n_heads(h)개의 서로 다른 어텐션(attention) 컨셉을 학습하도록 유도
        Q = Q.view(batch_size, -1, self.n_heads, self.head_dim).permute(0, 2, 1, 3)
        K = K.view(batch_size, -1, self.n_heads, self.head_dim).permute(0, 2, 1, 3)
        V = V.view(batch_size, -1, self.n_heads, self.head_dim).permute(0, 2, 1, 3)

        # Q: [batch_size, n_heads, query_len, head_dim]
        # K: [batch_size, n_heads, key_len, head_dim]
        # V: [batch_size, n_heads, value_len, head_dim]

        # Attention Energy 계산
        energy = torch.matmul(Q, K.permute(0, 1, 3, 2)) / self.scale

        # energy: [batch_size, n_heads, query_len, key_len]

        # 마스크(mask)를 사용하는 경우
        if mask is not None:
            # 마스크(mask) 값이 0인 부분을 -1e10으로 채우기
            energy = energy.masked_fill(mask==0, -1e10)

        # 어텐션(attention) 스코어 계산: 각 단어에 대한 확률 값
        attention = torch.softmax(energy, dim=-1)

        # attention: [batch_size, n_heads, query_len, key_len]

        # 여기에서 Scaled Dot-Product Attention을 계산
        x = torch.matmul(self.dropout(attention), V)

        # x: [batch_size, n_heads, query_len, head_dim]

        x = x.permute(0, 2, 1, 3).contiguous()

        # x: [batch_size, query_len, n_heads, head_dim]

        x = x.view(batch_size, -1, self.hidden_dim)

        # x: [batch_size, query_len, hidden_dim]

        x = self.fc_o(x) # x: [batch_size, query_len, hidden_dim]

        # x: [batch_size, query_len, hidden_dim]

>         return x, attention

풍부한 관점에서 feature을 보기 위해 MultiHeadAttention을 채택

Head가 사람, Attention이 시각이라고 생각했을때 다양한 사람이 보는 시각이 다 다르기 때문에 좋은 특징공간을 찾을 수 있을거라 생각함

Positionwise

class PositionwiseFeedforwardLayer(nn.Module):
    def __init__(self, hidden_dim, pf_dim, dropout_ratio):
        super().__init__()

        self.fc_1 = nn.Linear(hidden_dim, pf_dim)
        self.fc_2 = nn.Linear(pf_dim, hidden_dim)

        self.dropout = nn.Dropout(dropout_ratio)

    def forward(self, x):

        # x: [batch_size, seq_len, hidden_dim]

        x = self.dropout(torch.relu(self.fc_1(x)))

        # x: [batch_size, seq_len, pf_dim]

        x = self.fc_2(x)

        # x: [batch_size, seq_len, hidden_dim]

        return x

위치별 특징을 적용시키기 위한 것으로 서로 다른 주기를 가지는 sin, cos을 채택 동일 column이어도, pos값이 다를경우 다른 값이 되므로 겹치는 정보를 갖는것을 방지

EncoderLayer

class EncoderLayer(nn.Module):
    def __init__(self, hidden_dim, n_heads, pf_dim, dropout_ratio, device):
        super().__init__()

        self.self_attn_layer_norm = nn.LayerNorm(hidden_dim)
        self.ff_layer_norm = nn.LayerNorm(hidden_dim)
        self.self_attention = MultiHeadAttentionLayer(hidden_dim, n_heads, dropout_ratio, device)
        self.positionwise_feedforward = PositionwiseFeedforwardLayer(hidden_dim, pf_dim, dropout_ratio)
        self.dropout = nn.Dropout(dropout_ratio)

    # 하나의 임베딩이 복제되어 Query, Key, Value로 입력되는 방식
    def forward(self, src, src_mask):

        # src: [batch_size, src_len, hidden_dim]
        # src_mask: [batch_size, src_len]

        # self attention
        # 필요한 경우 마스크(mask) 행렬을 이용하여 어텐션(attention)할 단어를 조절 가능
        _src, _ = self.self_attention(src, src, src, src_mask)

        # dropout, residual connection and layer norm
        src = self.self_attn_layer_norm(src + self.dropout(_src))

        # src: [batch_size, src_len, hidden_dim]

        # position-wise feedforward
        _src = self.positionwise_feedforward(src)

        # dropout, residual and layer norm
        src = self.ff_layer_norm(src + self.dropout(_src))

        # src: [batch_size, src_len, hidden_dim]

        return src

src 번역하는 문장 즉, input을 통과시키는 layer을 의미

class Encoder(nn.Module):
    def __init__(self, input_dim, hidden_dim, n_layers, n_heads, pf_dim, dropout_ratio, device, max_length=100):
        super().__init__()

        self.device = device

        self.tok_embedding = nn.Embedding(input_dim, hidden_dim)
        self.pos_embedding = nn.Embedding(max_length, hidden_dim)

        self.layers = nn.ModuleList([EncoderLayer(hidden_dim, n_heads, pf_dim, dropout_ratio, device) for _ in range(n_layers)])

        self.dropout = nn.Dropout(dropout_ratio)

        self.scale = torch.sqrt(torch.FloatTensor([hidden_dim])).to(device)

    def forward(self, src, src_mask):

        # src: [batch_size, src_len]
        # src_mask: [batch_size, src_len]

        batch_size = src.shape[0]
        src_len = src.shape[1]

        pos = torch.arange(0, src_len).unsqueeze(0).repeat(batch_size, 1).to(self.device)

        # pos: [batch_size, src_len]

        # 소스 문장의 임베딩과 위치 임베딩을 더한 것을 사용
        src = self.dropout((self.tok_embedding(src) * self.scale) + self.pos_embedding(pos))

        # src: [batch_size, src_len, hidden_dim]

        # 모든 인코더 레이어를 차례대로 거치면서 순전파(forward) 수행
        for layer in self.layers:
            src = layer(src, src_mask)

        # src: [batch_size, src_len, hidden_dim]

        return src # 마지막 레이어의 출력을 반환

encoder는 layer을 6개 쌓으므로 encoder layer와 structure을 구분해서 구현

class DecoderLayer(nn.Module):
    def __init__(self, hidden_dim, n_heads, pf_dim, dropout_ratio, device):
        super().__init__()

        self.self_attn_layer_norm = nn.LayerNorm(hidden_dim)
        self.enc_attn_layer_norm = nn.LayerNorm(hidden_dim)
        self.ff_layer_norm = nn.LayerNorm(hidden_dim)
        self.self_attention = MultiHeadAttentionLayer(hidden_dim, n_heads, dropout_ratio, device)
        self.encoder_attention = MultiHeadAttentionLayer(hidden_dim, n_heads, dropout_ratio, device)
        self.positionwise_feedforward = PositionwiseFeedforwardLayer(hidden_dim, pf_dim, dropout_ratio)
        self.dropout = nn.Dropout(dropout_ratio)

    # 인코더의 출력 값(enc_src)을 어텐션(attention)하는 구조
    def forward(self, trg, enc_src, trg_mask, src_mask):

        # trg: [batch_size, trg_len, hidden_dim]
        # enc_src: [batch_size, src_len, hidden_dim]
        # trg_mask: [batch_size, trg_len]
        # src_mask: [batch_size, src_len]

        # self attention
        # 자기 자신에 대하여 어텐션(attention)
        _trg, _ = self.self_attention(trg, trg, trg, trg_mask)

        # dropout, residual connection and layer norm
        trg = self.self_attn_layer_norm(trg + self.dropout(_trg))

        # trg: [batch_size, trg_len, hidden_dim]

        # encoder attention
        # 디코더의 쿼리(Query)를 이용해 인코더를 어텐션(attention)
        _trg, attention = self.encoder_attention(trg, enc_src, enc_src, src_mask)

        # dropout, residual connection and layer norm
        trg = self.enc_attn_layer_norm(trg + self.dropout(_trg))

        # trg: [batch_size, trg_len, hidden_dim]

        # positionwise feedforward
        _trg = self.positionwise_feedforward(trg)

        # dropout, residual and layer norm
        trg = self.ff_layer_norm(trg + self.dropout(_trg))

        # trg: [batch_size, trg_len, hidden_dim]
        # attention: [batch_size, n_heads, trg_len, src_len]

        return trg, attention

trg 즉 번역 이후의 문장을 의미하며 decoder엔 6개의 layer가 들어감

class Decoder(nn.Module):
    def __init__(self, output_dim, hidden_dim, n_layers, n_heads, pf_dim, dropout_ratio, device, max_length=100):
        super().__init__()

        self.device = device

        self.tok_embedding = nn.Embedding(output_dim, hidden_dim)
        self.pos_embedding = nn.Embedding(max_length, hidden_dim)

        self.layers = nn.ModuleList([DecoderLayer(hidden_dim, n_heads, pf_dim, dropout_ratio, device) for _ in range(n_layers)])

        self.fc_out = nn.Linear(hidden_dim, output_dim)

        self.dropout = nn.Dropout(dropout_ratio)

        self.scale = torch.sqrt(torch.FloatTensor([hidden_dim])).to(device)

    def forward(self, trg, enc_src, trg_mask, src_mask):

        # trg: [batch_size, trg_len]
        # enc_src: [batch_size, src_len, hidden_dim]
        # trg_mask: [batch_size, trg_len]
        # src_mask: [batch_size, src_len]

        batch_size = trg.shape[0]
        trg_len = trg.shape[1]

        pos = torch.arange(0, trg_len).unsqueeze(0).repeat(batch_size, 1).to(self.device)

        # pos: [batch_size, trg_len]

        trg = self.dropout((self.tok_embedding(trg) * self.scale) + self.pos_embedding(pos))

        # trg: [batch_size, trg_len, hidden_dim]

        for layer in self.layers:
            # 소스 마스크와 타겟 마스크 모두 사용
            trg, attention = layer(trg, enc_src, trg_mask, src_mask)

        # trg: [batch_size, trg_len, hidden_dim]
        # attention: [batch_size, n_heads, trg_len, src_len]

        output = self.fc_out(trg)

        # output: [batch_size, trg_len, output_dim]

        return output, attention

전체적인 Transformer의 structure

class Transformer(nn.Module):
    def __init__(self, encoder, decoder, src_pad_idx, trg_pad_idx, device):
        super().__init__()

        self.encoder = encoder
        self.decoder = decoder
        self.src_pad_idx = src_pad_idx
        self.trg_pad_idx = trg_pad_idx
        self.device = device

    # 소스 문장의 <pad> 토큰에 대하여 마스크(mask) 값을 0으로 설정
    def make_src_mask(self, src):

        # src: [batch_size, src_len]

        src_mask = (src != self.src_pad_idx).unsqueeze(1).unsqueeze(2)

        # src_mask: [batch_size, 1, 1, src_len]

        return src_mask

    # 타겟 문장에서 각 단어는 다음 단어가 무엇인지 알 수 없도록(이전 단어만 보도록) 만들기 위해 마스크를 사용
    def make_trg_mask(self, trg):

        # trg: [batch_size, trg_len]

        """ (마스크 예시)
        1 0 0 0 0
        1 1 0 0 0
        1 1 1 0 0
        1 1 1 0 0
        1 1 1 0 0
        """
        trg_pad_mask = (trg != self.trg_pad_idx).unsqueeze(1).unsqueeze(2)

        # trg_pad_mask: [batch_size, 1, 1, trg_len]

        trg_len = trg.shape[1]

        """ (마스크 예시)
        1 0 0 0 0
        1 1 0 0 0
        1 1 1 0 0
        1 1 1 1 0
        1 1 1 1 1
        """
        trg_sub_mask = torch.tril(torch.ones((trg_len, trg_len), device = self.device)).bool()

        # trg_sub_mask: [trg_len, trg_len]

        trg_mask = trg_pad_mask & trg_sub_mask

        # trg_mask: [batch_size, 1, trg_len, trg_len]

        return trg_mask

    def forward(self, src, trg):

        # src: [batch_size, src_len]
        # trg: [batch_size, trg_len]

        src_mask = self.make_src_mask(src)
        trg_mask = self.make_trg_mask(trg)

        # src_mask: [batch_size, 1, 1, src_len]
        # trg_mask: [batch_size, 1, trg_len, trg_len]

        enc_src = self.encoder(src, src_mask)

        # enc_src: [batch_size, src_len, hidden_dim]

        output, attention = self.decoder(trg, enc_src, trg_mask, src_mask)

        # output: [batch_size, trg_len, output_dim]
        # attention: [batch_size, n_heads, trg_len, src_len]

        return output, attention

https://www.anaconda.com/products/distribution

2. 터미널 열기

좌측 상단 메뉴 - 터미널 - 새터미널 혹은 Ctrl+ Shift + `

3. 다운받고자 하는 폴더 가기

$ cd /data/~ $ wget 위에서 복사한 링크주소 붙여넣기 $ ls
$ bash 파일명

Welcome to Anaconda3 2022.10 In order to continue the installation process, please review the license agreement. Please, press ENTER to continue

ENTER 입력 후 안내문은 Enter꾹 누르다보면

Please answer 'yes' or 'no':'

이 문구가 뜬 후 yes를 입력하면 설치가 되게됩니다.

Anaconda3 will now be installed into this location: /home/rlaalsrl0922/anaconda3

• Press ENTER to confirm the location
• Press CTRL-C to abort the installation
• Or specify a different location below [/home/rlaalsrl0922/anaconda3] >>>

따로 위치를 지정하고 싶으시다면 해당하는 위치를 입력하시면 되고, 아니라면 Enter 누르시면 설치가됩니다.

4. Anaconda 실행

$ conda activate base

입력시에 conda가 실행됩니다.

4.1 가상환경 만들기

한가지 프로젝트만 진행하는게 아니기 때문에 다양한 환경을 세팅하기 위해선 base를 기반으로 환경을 만들어줍니다.

conda create -n <환경 이름>

4.2 가상환경 지우기

$ conda env remove -n <환경 이름>

4.3 가상환경 리스트

$ conda env list

4.4 yaml파일을 통한 가상환경 만들기

$ conda create -n <환경 이름> -f <yaml 파일 이름>

💡 경고문구 발생시 (To initialize your shell, run)

To initialize your shell, run

    $ conda init <SHELL_NAME>

Currently supported shells are:
  - bash
  - fish
  - tcsh
  - xonsh
  - zsh
  - powershell

See 'conda init --help' for more information and options.

IMPORTANT: You may need to close and restart your shell after running 'conda init'.con

1. $ vim ~/.bashrc

1번 입력시 아래와 같은 화면이 나옵니다

2.

3. E 누르기

4. 환경변수 설정

맨 아랫줄에 export PATH=/콘다설치주소/bin/:$PATH

5. 파일저장

:wq
작성 후 enter

6. 활성화되는지 확인하기

터미널 재실행 후 conda activate 하면 실행될겁니당