• 선형대수학을 고등학교때 배운 문제풀이 skill 로서가 아닌, 수식의 배경과 의미 그리고 그 변화를 기하학적인 관점으로 공부하는 것에 의의가 있는 것 같다. 수학적 풀이로서만 접근하면 쉬워보일 수 있겠지만, 그것이 무엇을 의미하는지 본질을 파악하고 넘어가자 ! ! !

• 내가 이해할 수 있는 나의 언어로 기록하기

1. Essence of linear algebra

• 벡터(vector)

- 물리학 관점 : 공간에서의 화살표. 길이와 방향이 같다면 이동해도 같은 벡터임. 평평한 평면 벡터는 2차원 ... n차원 벡터
- 컴퓨터 과학 관점 : 순서가 중요한 숫자의 리스트
- 수학 관점 : 무엇이든 벡터가 될 수 있음. 두 벡터를 합해도, 곱해도 여전히 벡터 ~
- 공부하면서 : 수학적인 관점으로, 벡터 (x, y)라고 하면 원점에서의 x, y 좌표를 상상하자. 모든 숫자쌍은 하나의 벡터와 대응되고, 모든 벡터는 각 대응된은 숫자쌍이 있다. 

• 벡터의 연산

  • 벡터의 합

    

  • 벡터의 곱 : 벡터의 길이를 늘이거나 줄이거나, 방향을 뒤집는 것 = 스케일링(scaling) 벡터를 변형시키는 정도를 스칼라(Scalars)라고 하며, 벡터에 스칼라 곱을 한다고 표현. - 캡쳐 속 스칼라 : 2, 벡터 : (3,1)

2. Linear combination, span and basis vectors

• 단위벡터(unit vector)

  

  • 단위벡터는 크기가 1인 벡터를 말한다.

  • x축 단위벡터 : $\hat{i}$

  • y축 단위벡터 : $\hat{j}$

  • 위 단위벡터는 좌표계의 '기저'임. 기저벡터(basic vectors)는 스칼라가 스케일하는 대상이다.

  • 기저벡터는 단위벡터 중 하나이다.

    

    $\begin{bmatrix}-5\2\ \end{bmatrix}$는 -5(스칼라)가 $\hat{i}$(x축 단위벡터이자 기저벡터)를, 2(스칼라)가 $\hat{j}$(y축 단위벡터이자 기저벡터)를 스케일링한 것이다.

  • 2차원에 표현할 수 있는 벡터들은 기저벡터로 모두 표현할 수 있다.

• 선형조합(linear combination)

  • 두 벡터를 스케일링하고 나서 더하는 것을 두 벡터의 선형조합이라고 한다.

  • (두 벡터가 서로 선형독립적이거나 행렬식이 0이 아니라면) 2차원에 표현할 수 있는 벡터들은 기저벡터 혹은 단위벡터의 선형조합으로 모두 표현할 수 있다.

• span

  • 벡터들이 만들 수 있는 모든 선형조합의 결과
  • 2차원
    • 두 벡터가 서로 선형독립 & 행렬식이 0 => 2차원의 모든 좌표를 의미
    • 두 벡터가 서로 선형종속 => 선(line)을 의미
  • 3차원
    • 두 벡터 서로 선형독립 & 행렬식이 0 => 원점을 지나는 평면 좌표를 의미
      • 세 벡터가 모두 선형 독립 => 3차원의 모든 좌표

3. Linear transformation and matrices

• 선형 변환(linear transformation)

  • input 벡터를 output 벡터로 바꾸는 변환식과 같은 것

  • function 대신 transformation이라고 하는 이유는, input 벡터의 위치를 '옮겨서' output 벡터로 변형하는 느낌을 주기 때문이다.

  • 변환 이후에도 선형이어야 하며, 평행하고 동일한 간격으로 있어야 하며, 원점은 변환 이후에도 여전히 원점이다.

  • 이를 수식으로 구하는 방법은 input 벡터인 기저 벡터($\hat{i}$, $\hat{j}$)가 어떻게 변화하는지만 구하면 된다.

    • $\overrightarrow{v}$ = $\begin{bmatrix}-1\2\ \end{bmatrix}$ = -1$\hat{i}$+2$\hat{j}$

    • 변환 전에 v벡터를 이루는 $\hat{i}$과 $\hat{j}$의 어떤 선형결합은 변환 후에도 같은 선형결합을 유지한다.

      • $Transformed$ $\overrightarrow{v}$ = -1*($Transformed$ $\hat{i}$) + 2*($Transformed$ $\hat{j}$)
      • 만약 $Transformed$ $\hat{i}$ = (1, -2)이고, $Transformed$ $\hat{j}$ = (3,0) 이라면,

      $Transformed$ $\overrightarrow{v}$ = -1$\begin{bmatrix}1\-2\ \end{bmatrix}$ + 2 $\begin{bmatrix}3\0\ \end{bmatrix}$ = $\begin{bmatrix}5\2\ \end{bmatrix}$

      • 다르게 표현하면, $Transformed$ $\overrightarrow{v}$ = $\begin{bmatrix}1&3 \-2&0 \ \end{bmatrix}$ $\begin{bmatrix}-1 \2 \ \end{bmatrix}$ = $\begin{bmatrix}1&3 \-2&0 \ \end{bmatrix}$ $\overrightarrow{v}$

      즉, 기저벡터의 도착점만 안다면 선형변환 후의 벡터(output vector)를 구할 수 있다.

    • $\overrightarrow{v}$ = $(x, y)$ ,

      $Transformed$ $\hat{i}$ = $(a, b)$ ,

      $Transformed$ $\hat{j}$ = $(c, d)$ 라면,

      $Transformed$ $\overrightarrow{v}$ = $\begin{bmatrix}a&c \b&d \ \end{bmatrix}$ $\begin{bmatrix}x \y \ \end{bmatrix}$

- 한 행렬은 하나의 선형변환을 의미한다. 벡터에 행렬을 곱하는 것은 수식적으로 그 벡터를 선형변환하는 것이다. 

- $A$$\overrightarrow{X}$ = $\overrightarrow{V}$ 라는 것은,

$\overrightarrow{X}$가 A만큼 선형변환하여 $\overrightarrow{V}$가 된다는 것.


- $\begin{bmatrix}a&c \\b&d \\ \end{bmatrix}$ $\begin{bmatrix}x \\y \\ \end{bmatrix}$ 라는 것은,

$\hat{i}$ 가 (a, b)로, $\hat{j}$가 (c,d)로 움직인 다음
(a, b)는 $x$배, (c, d)는 $y$배로 스케일링 된 후,
결합된다는 것.

- $\begin{bmatrix}a&c \\b&d \\ \end{bmatrix}$ $\begin{bmatrix}x \\y \\ \end{bmatrix}$  = $\begin{bmatrix}e \\f \\ \end{bmatrix}$에서 x와 y란, 


$\hat{i}$ 가 (a, b)로, $\hat{j}$가 (c, d)로 선형변환될 때, (e, f)로 선형변환되는 기저벡터 (x, y)가 무엇인가를 찾는 것.

4. Matrix multiplication as composition and Three-dimensional linear transformations

• 합성 행렬(Matrix multiplication) : 행렬의 곱, 행렬의 결합(composition). 기저벡터를 한 번 선형변환하고 나서 다른 변환을 한 번 더 적용한 것

• $AB$ 란, 기저벡터가 B만큼 선형변환된 후, A가 적용되어 선형변환되는 것이다.

• AB != BA 인 이유를 수식으로 설명하는 것이 아닌, 머릿속에서 이미지화하여 생각한다면 쉽다.

  • 기저벡터를 90도 회전하고 옆으로 기울이는 것(shear)과, 옆으로 기울이고(shear) 90도로 회전하는 것은 다르다.

    • 참고 : 기울이기(shear) 변환을 나타내는 행렬은 $\begin{bmatrix}1&1 \0&1 \ \end{bmatrix}$ 이다. $\hat{i}$ 는 움직이지 않고, $\hat{j}$만 (1,1)로 움직인다.

  • 3차원 행렬 또한 마찬가지

6. The determinant

• 2차원에서 선형변환이 일어날 때, 격자선이 평행하고 균등한 거리를 유지하기 때문에, 벡터가 만들어내는 공간의 변환 정도 역시 동일하다.

• 행렬식(determinant) : 선형변환에 의한 영역(공간)의 변화를 나타내는 요인.

  • $A$의 행렬식은 $det(A)$라고 표현한다. $A$ = $\begin{bmatrix}a&b \c&d \ \end{bmatrix}$ 일 때, $det(A)$ = ad - bc 이다.

  • 행렬식 양수 k라면 벡터 영역의 크기가 k배 만큼 변화한다는 것, 음수 k라면 영역의 크기 자체는 k배만큼 커지지만 방향이 반대임.

  • 행렬식이 음수가 되어 방향이 변환하는 것을 invert the orientation of space 라고 부른다.

  • 원래 $\hat{i}$ 왼쪽에 $\hat{j}$ 가 있는데,
    선형변환 이후 $\hat{i}$ 의 오른쪽에 $\hat{j}$ 가 있게 된다면, 이는 orientation of space가 inverted 되었다고 한다.

    이때 행렬식은 항상 음수값을 가지며, 절댓값만큼 공간(영역)이 스케일된다.

  • 행렬식이 0이라는 것은, 공간이 찌부되어 점 혹은 선을 이룬다는 것이다. 즉, 선형종속이 된다는 뜻.

• 3차원에서의 행렬식은 부피로서의 공간 변화를 나타낸다. 행렬식이 0이라면 선형변환 후 평면, 선, 점이 된 것. (선형종속)

7. Inverse matrices, column space and null space

• 역행렬 : $det(A)$ != 0 일때 존재

  • 일대일 대응 변환 : $A$ 의 역행렬은 $A^{-1}$ 하나뿐이다.

  • 항등 변환 : $A^{-1}$*$A$ 의 결과값은 아무것도 하지 않은 $\hat{i}$ 과 $\hat{j}$ 됨. = 단위행렬 $\begin{bmatrix}1&0 \0&1 \ \end{bmatrix}$ 이 된다는 것.

- $A$$\overrightarrow{X}$ = $\overrightarrow{V}$ 이라면,  $\overrightarrow{X}$ = $A^{-1}$$\overrightarrow{V}$

• rank : 선형변환의 결과가 n차원이라면, rank는 n이다. 행렬의 선형 독립인 column vector의 갯수이다. column space의 차원의 수임.

• column space : 행렬의 선형 독립인 기저벡터가 선형 조합으로 만들 수 있는 부분 공간. 3차원 공간에서 rank가 2일 경우, column space는 2차원 평면이 된다.

• 영공간(null space)(=kernel) : 선형변환의 결과가 영벡터가 되게 하는 벡터의 해집합. $A$$\overrightarrow{X}$ = $\overrightarrow{V}$ 에서 $\overrightarrow{V}$가 영벡터인 경우, 해($\overrightarrow{X}$)는 모든 null space가 될 수 있다.

  
  

  ---

  8. Nonsquare matrices as transformations between dimensions

  • $n$ X $m$ 행렬에서, $m$ : input 기저 벡터의 수, $n$ : 기저벡터의 변환 후 좌표값 개수(차원(

  • $3$ X $2$ 행렬은 2차원 평면이 3차원상에 나타나는 것. $2$ X $3$ 행렬은 3차원 공간이 2차원으로 찌그러져 축소되는 것.

  
  

  ---

  9. Dot products and duality

  • 내적(Dot products)

    • 두 벡터의 내적이란, 각 인덱스에 대응하는 원소를 곱한 뒤 더하여 하나의 스칼라 값으로 만들어 주는 연산

    $\begin{bmatrix}a \b \ \end{bmatrix}$ * $\begin{bmatrix}c \d \ \end{bmatrix}$ $= ac + bd$

    • 이는 행렬과 벡터의 곱셈과 결과가 같다. = 기하학적으로 본다면 하나의 벡터를 다른 벡터에 투영(projection)하고 투영된 벡터의 길이와 다른 벡터의 길이를 곱하는 것이다.

    • [ $a\ \ b$ ]$\begin{bmatrix}c \d \ \end{bmatrix}$ $= ac + bd$

    (1x2)행렬과 2d 벡터의 곱셈이란, 2차원 평면$\begin{bmatrix}c \d \ \end{bmatrix}$ 을 1차원 선[ $a\ \ b$ ] 으로 축소(투영, projection)시킨다는 의미를 갖고 있다.

    • $\begin{bmatrix}c \d \ \end{bmatrix}$를 $\hat{i}$ 과 $\hat{j}$ 으로 projection시키면 (c$\hat{i}$, d$\hat{j}$)가 되는데, [ $a\ \ b$ ] 는 [ $a$$\hat{i}$$\ \ b$$\hat{j}$ ]로 표현할 수 있으며 단위 벡터의 스칼라 값은 그대로 스칼라배 되기 때문에,$\begin{bmatrix}c \d \ \end{bmatrix}$를 [ $a$$\hat{i}$$\ \ b$$\hat{j}$ ] 으로 projection 시킨다는 것 즉, [ $a\ \ b$ ]$\begin{bmatrix}c \d \ \end{bmatrix}$ 는 $= ac + bd$ 가 되는 것이다.

    • 내적 곱 ($\overrightarrow{v}$*$\overrightarrow{w}$)

      • < 0 : 두 벡터의 방향이 반대,
      • = 0 : 두 벡터는 직교
      • > 0 : 두 벡터 방향 같음

• 이중성(duality, 쌍대성)

  • $\hat{i}$ 와 $\hat{j}$ 를 2차원 형태의 수선(number line)의 단위 벡터인 $\hat{u}$ 에 투영시킨다고 할 때, 대칭성에 의해 $\hat{i}$ 에서 수선으로 투영된 위치는 $\hat{u}$ 의 x 좌표값이 된다. 마찬가지로 $\hat{j}$ 에서 수선으로 투영된 위치는 $\hat{u}$ 의 y 좌표값이 된다.

  • 즉, 투영변환을 나타내는 1X2 행렬은 $\hat{u}$ 의 좌표가 되는 것이다.

  • 어떤 공간을 수선(number line)으로 선형변환을 하는 것은, 그 특정 벡터의 내적을 구하는 것과 같다는 것이다.

10 & 11. Cross products

• 외적(Cross product)

- 두 벡터의 평행사변형 면적이자, 3차원에서는 평행사변형에 직각인 외적의 벡터의 길이를 의미.
결과값은 단순한 숫자가 아닌, 벡터를 의미. $\overrightarrow{V}$ X $\overrightarrow{W}$ = $\overrightarrow{p}$

- $\overrightarrow{V}$ = $[a\ \ b]^T$, $\overrightarrow{W}$ = $[c\ \ d]^T$ 일때, 외적은 행렬식인 $det(
$$\begin{bmatrix}a&c \\b&d \\ \end{bmatrix}$$
)$  = -5 이다.
![](https://velog.velcdn.com/images/jiho-kang/post/a3472cc8-8de9-4deb-9e7f-9f59f6d90bee/image.png)

- $\overrightarrow{V}$ 가 $\overrightarrow{W}$ 의 오른쪽에 있으면 양수, 왼쪽에 있으면 음수

- 두 벡터가 수직에 가까울수록 값은 커진다.

12. Cramer's rule, explained geometrically

• 내적이 선형변환 이후에도 보존되는 변환은 직교변환이라고 한다. 모든 $\overrightarrow{v}$와 $\overrightarrow{w}$에 대하여 $T$($\overrightarrow{v}$)*$T$($\overrightarrow{w}$) = $\overrightarrow{v}$*$\overrightarrow{v}$ 라면, $T$는 직교변환(Orthonormal transformations) 이다. 기저벡터의 수직 상태, 길이까지 유지되는 변환이다.

  • 이를 회전변환행렬(rotation matrices)로 생각할 수도 있다. 고정된 움직임에 대응하는, 늘거나 줄거나 등의 변형이 없는 변환.

• 대부분은 직교변환하지 않는다. 그러므로 선형변환 후에도 입력 벡터에서 변하지 않고 남아 있는 다른 기하학적인 무언가를 찾아본다면 ?

• $\begin{bmatrix}a&c \b&d \ \end{bmatrix}$ $\begin{bmatrix}x \y \ \end{bmatrix}$ = $\begin{bmatrix}e \f \ \end{bmatrix}$ 의 의미는, $\hat{i}$를 (a, b)로, $\hat{j}$를 (c, d)로 선형변환할 때, (e, f)로 변형되는 (x, y) 를 구하라는 것이다.

• $\hat{i}$ 과 (x, y) 벡터의 넓이 = 1 * $y$

• 선형변환된 이후의 넓이는 $det($$\begin{bmatrix}a&c \b&d \ \end{bmatrix}$$)$만큼 scale 된다. 그러므로, $변환\ 후\ 넓이$ = $det($$\begin{bmatrix}a&c \b&d \ \end{bmatrix}$$)$ * $y$ 즉, $y$ = $변환\ 후\ 넓이$ / $det($$\begin{bmatrix}a&c \b&d \ \end{bmatrix}$$)$ 이다. '$변환\ 후\ 넓이$' 는 $det($$\begin{bmatrix}a&e \b&f \ \end{bmatrix}$$)$ 로 표현할 수 있으므로,

• $y$ = $det($$\begin{bmatrix}a&e \b&f \ \end{bmatrix}$$)$ / $det($$\begin{bmatrix}a&c \b&d \ \end{bmatrix}$$)$

• 마찬가지로, $x$ = $det($$\begin{bmatrix}e&c \f&d \ \end{bmatrix}$$)$ / $det($$\begin{bmatrix}a&c \b&d \ \end{bmatrix}$$)$

13. Change of basis

• J의 기저벡터가 $b_{1}$ = $\begin{bmatrix}2 \1 \ \end{bmatrix}$, $b_{2}$ = $\begin{bmatrix}-1 \1 \ \end{bmatrix}$ 라고 할 때. J입장에서 $\overrightarrow{v}$ = $\begin{bmatrix}-1 \2 \ \end{bmatrix}$는 우리 입장 ($\hat{x}$, $\hat{y}$) 에서 어떻게 표현할 수 있을까 ?

  • [J 기저벡터] [J언어] = [우리언어] $\begin{bmatrix}2&-1 \1&1 \ \end{bmatrix}$ $\begin{bmatrix}-1 \2 \ \end{bmatrix}$ = $\begin{bmatrix}-4 \1 \ \end{bmatrix}$

    즉, J 관점의 $\begin{bmatrix}-1 \2 \ \end{bmatrix}$ 는 우리 관점에서 $\begin{bmatrix}-4 \1 \ \end{bmatrix}$ 이다.

• [J 기저벡터] [J언어] = [우리언어]

  [J언어] = [J 기저벡터]$^{-1}$ [우리언어]

  
  

• 아래 행렬곱은 무엇을 의미할까?

  J 의 기저벡터 = $\begin{bmatrix}2&-1 \1&1 \ \end{bmatrix}$ = $A$

  새로운 선형변환 = $\begin{bmatrix}0&-1 \1&0 \ \end{bmatrix}$ = 90도 회전

  J 입장 $\overrightarrow{v}$

  

  = J입장 벡터($\overrightarrow{v}$)를 우리 입장에서 새로운 선형변환을 취해 J의 언어로 표현한 것.

  = J입장 벡터($\overrightarrow{v}$)를 우리 입장(J 기저벡터를 곱하여)에서 새로운 선형변환(새로운 선형변환 곱)을 취해 J의 언어로 표현(J기저벡터의 역행렬)한 것.

  = [J 기저벡터]$^{-1}$ [새로운 선형변환] [J 기저벡터] [J입장 $\overrightarrow{v}$]

  = [J 기저벡터]$^{-1}$ [새로운 선형변환] [우리 입장 $\overrightarrow{v}$]

  = [J 기저벡터]$^{-1}$ [우리 입장 새로운 선형변환]

  = [J 입장 새로운 선형변환된 벡터]

• $A^{-1} M A$ => $M$ : 선형변환 => $A^{-1}, A$ : 관점의 변환

14 & 15. Eigenvectors and eigenvalues

• 고유벡터(Eigenvectors) : 선형변환 후 벡터가 선형변환 전 벡터의 스팬에 포함되어 있는 경우. 즉, 선형변환을 해도 스케일링만 변하고 자신의 span을 벗어나지 않는 벡터

• 고윳값(Eigenvalues) : 고유벡터가 변환될 때 상수배되는 값

• 특징

  • 모든 선형변환에 고유벡터가 있는 것은 아님.
  • 고윳값은 하나여도 여러개의 고유벡터를 가질 수 있ㄷ음.

• 아래 그림은, 행렬-벡터 곱셈($A \overrightarrow{v}$)가 고유벡터($\overrightarrow{v}$)를 임의의 상수($\lambda$, 고윳값)로 스케일링한 결과와 같다는 것.

  $A \overrightarrow{v}$ = $\lambda\overrightarrow{v}$ $A \overrightarrow{v}$ - $\lambda\overrightarrow{v}$ = 0 $(A - \lambda I) \overrightarrow{v}$ = 0 ( $\lambda$ 는 $\lambda I$로 쓸 수 있음.) -> 두 행렬곱의 선형변환이 영벡터가 된다는 것. 이때, 영벡터가 아닌 고유벡터 $\overrightarrow{v}$를 찾고 있기 때문에, $det(A - \lambda I)$ = 0인 값을 찾아야 함.

• 고유기저(Eigenbasis) : 기저벡터($\hat{i}$, $\hat{j}$)가 고유벡터일 경우, $\overrightarrow{v}$(고유벡터의 행렬)은 대각선 외에 모두 0인 대각선 행렬(diagonal matrix)가 된다.

• 대각선 행렬(diagonal matrix) : 모든 기저벡터는 고유벡터이고, 대각선의 값들이 고유값이 됨 $\begin{bmatrix}-5&0&0&0 \0&-2&0&0 \0&0&4&0 \0&0&0&3 \end{bmatrix}$

• 선형변환에서 고유벡터유벡터가 많다면, 이 고유벡터들을 기저벡터로 사용할 수 있다.

• $\begin{bmatrix}a&b \c&d \end{bmatrix}$ 의 고윳값($\lambda_1, \lambda_2$) 계산식

  • 특징 1) $a+b = \lambda_1 + \lambda_2$

  • 고윳값의 평균 ($m$) = $(a+b)/2$

  • 특징 2) $ad - bc = \lambda_1*\lambda_2$

  • 고윳값의 곱 ($p$) = $ad-bc$

  • |$\lambda$|와 $m$ 사이의 거리가 $d$라고 했을 때, $\lambda_1, \lambda_2 = m \pm d$ $p$ = $(m+d)(m-d)$ $d^2$ = $m^2$ - p $d = \pm \sqrt{m^2-p}$ $\therefore \lambda_1, \lambda_2 = m \pm \sqrt{m^2-p}$

  • $\begin{bmatrix}3&1 \4&1 \end{bmatrix}$ 의 고윳값은 ? $m = (3+1)/2 = 2$ $p = (31 - 41) = -1$ $\lambda = 2 \pm \sqrt{2^2-(-1)} = 2 \pm \sqrt{5}$

16. Abstract vector spaces

• 선형 변환은 합과 실수배를 보존한다.

  • 합(additivity) : $L(\overrightarrow{v}+\overrightarrow{w}) = L(\overrightarrow{v}) + L(\overrightarrow{w})$
  • 실수배(scaling) : $L(c\overrightarrow{v})=cL(\overrightarrow{v})$

• 미분 역시 선형변환이다.

• 선형대수에서 사용되는 컨셉은 (<->) 함수에서도 사용되는데,

  • Linear transformations <-> Linear operators Dot products <-> Inner products Eigenvectors <-> Eigenfunctions

1~2. Introudction & Background

Transformer 이전의 문제점

Long-Term Dependency Problem

• Sequence data를 처리하기 위해 기존에는 recurrent model이 가장 많이 쓰였다. t번째 output을 위해 t번째 input과 t-1번째 hidden state를 이용하는 것이다. recurrent model은 순차적인 특성을 유지시킬 수 있으나, 문장의 길이가 길어질 경우 거리가 먼 단어끼리는 영향력이 감소한다는 단점이 있다.

Parallelization

• recurrent model은 학습 시 이전 결과를 순차적으로 입력 받는다. t번째 hidden state를 얻기 위해 t-1번째 hidden state가 필요했기 때문에 병렬처리가 불가능 하여 속도가 느렸다.
• 이를 해결하기 위해 transformer에서는

해결방안

• encoder에서 position에 대해 attention을 하고, decoder에서 maksing 기법을 이용해 병렬 처리를 해주었다.

3. Model Architectrue

• 논문 속 Transformer의 모델 구조
  

3.1 Encoder and Decoder Stacks

• Encoder와 Decoder를 이해하기 좋은 애니메이션.

Encoder

• 6개의 동일한 layer의 stack으로 구성.

• 하나의 Layer에는 (1) multi-head self-attention layer (2) position-wise fully connected feed-forward layer 두 개의 sub-layer로 구성되며, 각각의 sub-layer는 normalization을 거쳐 residual connection이 된다.

• residual connection하기 위해 모든 sublayer의 출력은 embedding layer 의 크기와 같은 512차원으로 생성된다.

• 코드로 이해하기

# 하나의 Layer를 코드로 이해해보자.
Stage1_out = Embedding512 + TokenPositionEncoding512 #w2v결과 + pos정보
Stage2_out = layer_normalization(multihead_attention(Stage1_out) + Stage1_out)
Stage3_out = layer_normalization(FFN(Stage2_out) + Stage2_out)

out_enc = Stage3_out

Decoder

• Encoder와 마찬가지로 6개의 동일한 layer의 stack으로 구성.

• 하나의 Layer에는 (1) Masked multi-head self-attention layer (2) multi-head self-attention layer (with encoder output) (3) position-wise fully connected feed-forward layer 세 개의 sub-layer로 구성되며, 각각의 sub-layer는 normalization을 거쳐 residual connection이 된다.

• residual connection하기 위해 모든 sublayer의 출력은 embedding layer 의 크기와 같은 512차원으로 생성된다.

• 코드로 이해하기

# 하나의 Layer를 코드로 이해해보자.
Stage1_out = OutputEmbedding512 + TokenPositionEncoding512

# i보다 작은 위치의 시퀀스 요소에 대해서만 어텐션 메커니즘이 동작할 수 있도록 마스킹한 어텐션
Stage2_Mask = masked_multihead_attention(Stage1_out)
Stage2_Norm1 = layer_normalization(Stage2_Mask) + Stage1_out
Stage2_Multi = multihead_attention(Stage2_Norm1 + out_enc) + Stage2_Norm1
Stage2_Norm2 = layer_normalization(Stage2_Multi) + Stage2_Multi

Stage3_FNN = FNN(Stage2_Norm2)
Stage3_Norm = layer_normalization(Stage3_FNN) + Stage2_Norm2

out_dec = Stage3_Norm

3.2 Attention

• Attention은 Query vector, Key vector, Value vecotr 쌍을 output으로 maaping하는 과정이다.
• Transformer에서 사용된 Attention에 대해 알아보자.

Scaled Dot-Product Attention

• 입력: dk 차원의 query, key, value. (이하, Q, K, V)

  1. encoder-decoder attention일 때, Q: Decoder의 이전 layer hidden state k: Encoder의 output state V: Encoder의 output state

  2. self-attention일 때, Q=K=V= Encoder의 output state

• dot_product(Q,K) 이후, $$\sqrt{dk}$$로 나눈다. ($$\sqrt{dk}$$로 나누는 이유는 dot 값이 너무 크면 softmax의 기울기 값이 작아지기 때문에 scale하는 것.)

• 그 값을 softmax를 적용하며, 이것이 V의 weight가 되는 것이다.

• 즉, Q, K에 맞게 V에 attention을 주는 방식이다.

Multi-Head Attention

• Sclaed dot-product attention을 복수(h)번 수행.

• 각각의 head 즉 K, V, Q를 h개로 나눈 값들의 attention을 수행하고 concat.

• 벡터의 크기를 줄이고 병렬 처리가 가능.

3.3 Position-wise Feed-Forward Networks

• encoder와 decoder의 각각의 layer는 마지막 단계에서 fully connected feed-forward network를 포함한다.

• position 마다, 즉 개별 단어마다 적용되기 때문에 position-wise이다.

• x에 linear transformation을 적용하고 -> ReLU를 거쳐 -> 다시 한 번 linear transformation을 적용한다.

3.4 Embedding and softmax

• input token과 output token을 변환하는 과정에서 learned embedding을 사용한다. decoder의 output이 FNN을 거친 후 softmax를 통해 각 token의 확률값으로 표현된다.

3.5 Positional Encoding

• RNN이나 CNN파트를 사용하지 않기 때문에 순서 즉, 시퀀스의 위치 정보를 알려줘야 한다.

• encoder 및 decoder의 input embedding에 positional encoding을 더한다.

4. Why Self-Attention

• *layer당 계산량이 줄어든다. *
• 병렬처리가 가능한 계산이 늘어난다.
• 문장의 길이가 길어져도 학습이 잘 된다.

출처

－　https://velog.io/@veonico/%EB%85%BC%EB%AC%B8-%EC%9A%94%EC%95%BD-Attention-is-All-You-Need
－　https://hipgyung.tistory.com/entry/ATTENTION-IS-ALL-YOU-NEED-%EB%85%BC%EB%AC%B8-%EB%A6%AC%EB%B7%B0
－　https://pozalabs.github.io/transformer/
－　https://dalpo0814.tistory.com/49
- https://ai.googleblog.com/2017/08/transformer-novel-neural-network.html)
- https://3.bp.blogspot.com/-aZ3zvPiCoXM/WaiKQO7KRnI/AAAAAAAAB_8/7a1CYjp40nUg4lKpW7covGZJQAySxlg8QCLcBGAs/s1600/transform20fps.gif

• NLP에는 NLU와 NLG가 있다. NLU(Natural Language Understanding) 자연어 이해: 언어를 이해하는 기술. NLG(Natural Language Generation) 자연어 생성: 새로운 언어를 생성하는 기술. NLG 중에서도 Extractive Summarization에 대해 알아보자!

Extractive Summarization

문제 정의

• context가 주어졌을 때, 핵심을 나타낼 수 있는 키워드나 문장을 고르는 것.

MatchSum

• 기존의 Extractive summairzation 모델은 문장 단위의 scoring으로 문서를 요약한다. 그러나 이 방법은 context와 target summary 사이를 적절히 고려하지 못한 요약이라 주장한다.
• 본 모델은 2 stage로 진행된다. summary 후보군을 추출하고, 매칭하는 방식이다. context와 summary 후보군이 semantic space에서 매칭될 것이라 가정한다.
• 논문: Extractive Summarization as Text Matching
• 코드: MatchSum
• 키워드: Document Summarization, Extractive Summarization, Semantic Text Matching, Text Matching, Text Summarization
• 학습 자료: 고려대학교 산업경영공학부 DSBA 연구실 Paper Review

BertSumExt

• 문장에 대한 표현을 만들어주는 BERT를 기반으로 documnet-level-encoder를 제안하여 문서 요약이 가능한 프레임워크를 제시했다.
• BERT의 인코더 위에 몇 개의 inter-sentece 트랜스포머 레이어를 추가하였다.
• 논문: Text Summarization with Pretrained Encoders
• 코드: github
• 키워드: BERT, extractive, abstractive, summarization encoder, extractive summarization,
• 학습 자료: https://aimaster.tistory.com/46

데이터

• CNN/DailyMail
• CNN과 Daily Mail의 뉴스 기사 데이터셋.
• 원본문서에서 나타나는 엔티티들을 익명화하여 변환 후, “X”로 명기된 엔티티(단어 또는 구/절)를 찾아야 하는 질문셋 1,384,887건.
• 그러나 이 데이터셋은 에러가 많이 포함되어 있다는 지적이 있으며, 엔티티에 대한 빈칸 채우기 문제(Cloze type question)는 독해력 난이도가 낮아 사람의 성능과 근접한 연구결과가 도출되고 있어 기계의 독해력 판별에는 변별력이 낮다는 지적이 제기된다.

• NLP에는 NLU와 NLG가 있다. NLU(Natural Language Understanding) 자연어 이해: 언어를 이해하는 기술. NLG(Natural Language Generation) 자연어 생성: 새로운 언어를 생성하는 기술. 오늘은 그 중 NLU에서 관심 있는 task에 대해 간략하게 정리해봈다.

1. Paraphrase Identification

문제 정의

• 두 개의 context가 같은 의도를 가졌는지의 여부를 판별한다.
• 기업 입장에서 소비자가 유사한 질문을 할 경우, 기존의 context data를 토대로 일치여부를 판별하여 answer를 제공할 수 있다.

Charformer

• 모델: soft grandient-based subword tokenization (GBST)를 사용하여 단어의 토크나이징이 아닌, 더 하위 레벨인 character 단위의 특징과 위치 임베딩을 사용하여 학습한 모델이다. 노이즈가 있는 단어(오탈자 등) 에서 강한 성능을 보인다고 한다.
• 논문: Charformer: Fast Character Transformers via Gradient-based Subword Tokenization
• 코드: Charformer
• 키워드: paraphrase identification, sentiment textual similarity,
• 학습 자료: 유튜브

데이터

• Quora Question Paris
• 사용자가 직접 질문하고 답변하는 커뮤니티 사이즈 (like 지식인)에서 제공하는 데이터로, 중복 질문 식별 여부를 판단하기 위해 데이터를 공개했다.
• data_detail

2. Semantic Textual Similarity

문제 정의

• 두 개의 context의 유사도를 판별하는 task이다.
• 추천시스템에서 어떻게 쓰일까❓ 영화/책의 줄거리 유사성이나, item의 상세글 유사성으로 비슷한 아이템인지 판별할 수 있을 것이다.
• x_train: 두 개의 contexts
• y_label : 1~5까지 유사성을 점수 메긴 score

SMART-RoBERTa

• 모델: Transformer를 기반으로 한 RoBERT모델의 진화 버전. Semantic Textual Similarity, Sentiment Analysis, Natural Lnaguage Inference 등에서 좋은 성능을 보인 SOTA 모델이다. 기존의 pre-trained 모델은 용량이 너무 크다는 단점이 존재하고, 해당 모델에서 이를 극복하기 위해 Smoothness-Inducing Adversarial Regularization과 Bregman Proximal Point Optimization을 도입한다.
• Single Model을 기준으로 3개의 GLUE Subtask에서 약 30배의 Parameter 수의 차이를 보이는 T5를 상회하는 성능을 기록하였고, MT-DNN과의 Ensemble을 통해 GLUE Benchmark 평균 성능에서 T5를 상회하는 성능을 기록하고, State-of-the-art를 갱신한 모델이다.
• 논문: SMART: Robust and Efficient Fine-Tuning for Pre-trained Natural Language Models through Principled Regularized Optimization
• 코드: 깃헙의 namisan/mt-dnn
• 키워드: Linguistic Acceptability, Natural Language Inference, Semantic Textual Similarity, Sentiment Analysis, Transfer Learning
• 학습 자료: 유튜브

데이터

• Sementic Textual Similarity Benchmark(STS-B)
• 영어로 구성되어 있다. 이미지 캡션, 뉴스 헤드라인 및 사용자 포럼의 텍스트가 포함된다.

NLP를 좀 더 깊게 공부해보고 싶어서 Wanted의 프리온보딩코스에 지원했다. 나의 꿈은 추천시스템 엔지니어가 되는 것. 많은 산업군에서 추천시스템을 고객 유지 마케팅으로 사용한다. 마케팅을 공부했던 경영학도로서 (?) 추천시스템만큼 강력한 마케팅 전략이 어딨을까? Deep-learing-based-Recommendation System is a future of marketing 이다! 하는 생각으로 추천시스템 엔지니어의 꿈을 키웠다. 객관적인 데이터를 근거로 한 의사결정과 추천이라는게 아름답게 느껴졌달까!

최근에 item-user 매칭 프로젝트를 진행하며 다음 단계의 성장을 위해 두 가지가 필요함을 깨달았다.

1) 딥러닝 모델의 구조와 원리를 배우며 정제된 데이터로 모델을 구현해보는 것과, 실제 현업의 데이터로 원하는 문제를 해결하기 위해 SOTA 모델을 customize하는 것은 다르다! 나에겐 후자의 경험이 더욱 필요하구나! 2) 추천시스템 앞단에는 NLP나 CV가 필요하다. item의 feature을 만들기 위해 text 에서 tag를 추출하거나, image로부터 feature를 추출해야하기 때문이다.

이번 프리온보딩코스에서는 NLP를 Pytorch로 배울 수 있다. 좀 더 code적으로, Tensorflow가 아닌 Pytorch로 공부해볼 수 있는 좋은 기회인 것이다. (Tensorflow와 Pytorch 중 무엇을 배워야 하는 것은 다른 포스트에 남겨놔야징.)

Interesting Task in NLP

1. Multi-Label Text Classification

문제 정의

• Context가 들어왔을 때, 어떤 tag를 가지는지 분류하는 문제.
• 검색 엔진에 키워드를 넣었을 때, 어떤 context가 상위에 노출되는지, 블로그에 글을 작성하고 발행하기 전 자동으로 태그를 부여해주는 것 등에서 사용되는 task이다.

TagBERT

• 모델: 사전 학습된 BERT 기반의 TagBERT 모델은 전통적인 태깅 모델보다 성능이 좋을 뿐만 아니라, 기존의 태그 수가 많아질 경우 precision이 떨어지는 문제에서도 좋은 성능을 보였다.
• 논문: Tag Recommendation for Online Q&A Communities based on BERT Pre-Training Technique
• 코드: Bert-Based-Tag-Recommendation
• 키워드: tag recommendation, Multi-Label Text Classification, BERT, TAG

데이터

• Online QnA, Open source community (ex. StackOverflow)
• context가 있고, 적절한 tag 가 있는 데이터
• kaggle의 freecode datasets

2. Word Embedding

문제 정의

• 비정형화된 Text를 숫자로 바꿔줌으로써 사람의 언어를 컴퓨터 언어로 번역하는 것.
• 임베딩된 벡터는 similarity, clustering, classification, deep learning model 등 다양하게 활용된다.

FastText

• 모델: Facebook (현 메타)에서 만든 모델로, 다른 워드임베딩 기법인 Word2Vec과 자주 비교된다. FastText는 노이즈가 많은 데이터에서 성능이 좋으며, 사전에 없는 단어는 예측하지 못하는 OOV(Out Of Vocabulary)문제에 대응할 수 있다는 장점을 가지고 있다.
• 깃헙: facebookresearch/fastText

데이터

• 모든 언어가 데이터가 될 수 있다. FastText의 경우 wikipedia의 데이터를 기반으로 학습되었다.

객체란 무엇인가?

객관적으로 존재하는 실체이다. Python은 클래스(Class)를 사용해서 객체를 만든다. 클래스에는 속성 (Attributes), 메소드(Method)가 포함될 수 있다. 클래스는 이렇게 속성과 메소드를 묶을 수 있고, 클래스를 선언하여 객체를 만든다. 이후 객체가 메모리에 할당되면 인스턴스(Instance)가 되며, 이를 해당 클래스의 인스턴스라고 부른다.

객체 지향 프로그래밍의 필요성

앞서 본 '객체'라는 개념을 주로 사용 & 활용하는 프로그래밍을 객체 지향 프로그래밍이라고 한다. 기존에는 절차적 프로그래밍(Procedural Programming)을 사용했었다. 말 그대로 코드가 위에서 아래로 순서대로 실행이 된다. 객체 지향 프로그래밍 (Object Oriented Programming)은 기능(함수, 변수)의 재사용과 수정이 용이하도록, 최소 비용으로 최대 효율을 얻을 수 있다. 특히나 대용량 데이터를 다룰 때, 데이터의 유형은 같고 내용만 다르니 반복되는 코드가 존재한다. 이를 더욱 쉽게 처리할 수 있다.

# 절차적 프로그래밍
Jiho = {'name':'jiho', 'age':26, 'grade':'A'}
Jake = {'name':'jake', 'age':24, 'grade':'B'}
Mike = {'name':'mike', 'age':21, 'grade':'C'}

# 객체 지향 프로그래밍
class Person():
    def __init__(self, name, age, grade):
        self.name = name
        self.age = age
        self.grade = grade
    def get_old(self):
        self.age +=1
Jhio = Person('jiho', 26, 'A')
Jake = Person('jake', 24, 'B')
Mike = Person('mike', 21, 'C')

'''
데이터가 적으니 객체 지향 프로그래밍이 더 길어보이지만, 만약 사람이 100명이라면?
절차적 프로그래밍에서는 'name', 'age', 'grade'라는 Key 단어와 Value 단어를
100번 입력해야하지만, 객체 지향 프로그래밍에서는 Class 선언과 Value 단어만
입력하면 된다.

또한, 만약 name이 아닌 call_me 로 바꾸고 싶다면, 절차적 프로그래밍은 name이라는
key값을 100번 수정해야 하지만, 객체 지향 프로그래밍에서는 Person이라는 클래스만
수정해주면 된다. 이처럼 객체 지향 프로그래밍은 재사용과 수정에 용이하다.
'''

객체 지향 프로그래밍의 특징

1. 상속

상속을 해주는 부모 클래스, 상속을 받는 자식 클래스 부모 클래스의 기능(함수, 변수)를 그대로 재사용

class Person(): # 부모 클래스
    def __init__(self, name):
        self.name = name
        print(f'name: {self.name}')

class Teacher(Person): # Person을 상속받았다.
    def work(self):
        print(f'{self.name}의 본분은 teaching 입니다.')

class Student(Person): # Person을 상속받았다.
    def study(self):
        print(f'{self.name}의 본분은 studying 입니다.')

a = Teacher('jiho')
# 출력: name: jiho
'''
Teacher 클래스를 선언할 때, Teacher는 Person으로부터 상속 받았으므로
1. Person의 생성자 함수(__init__)가 실행된다.
2. self.name에 name이 저장되고 --->  3. 'name: jiho' 출력

'''
b = Student('mike') 
# 출력: name: mike

a.work() 
# 출력: jiho의 본분은 teaching 입니다.
b.study() 
# 출력: mike의 본분은 studying 입니다.

print(a.name) #  jiho
print(b.name) # mike

2. 다형성 (오버라이딩/오버로딩)

부모 클래스의 기능(함수, 변수)를 변형하여 사용

class Person():
    def __init__(self, name):
        self.name = name
        print(f'name: {self.name}')


class Teacher(Person):
    def __init__(self, name):
        super().__init__(name) # 부모 클래스의 생성자 함수를 가져온다.
        print('Teacher입니다.') # 자식 클래스의 생성자 함수에 기능을 추가한다.

a = Teacher('jiho')
# 출력
# name: jiho
# Teacher입니다.
'''
1. Teacher 클래스가 a로 인스턴스화될 때, Person의 생성자 함수를 가져오게 된다.
2. 부모 클래스에서 self.name = jiho 진행됨.
3. 부모 클래스에서 'name: jiho'를 출력함.
4. 자식 클래스에서 'Teacher'입니다. 를 출력함.
'''

print(a.name) # jiho

3. 캡슐화

• 객체의 속성과 메소드를 하나로 결합

  아래 코드의 person은 <name, age, _a, __b>라는 속성과, <_check1, __check2>라는 메소드를 결합한 클래스이다.

• 정보 은닉

  외부로부터의 직접적인 액세스를 차단한다.

  • 언더바 1개 사용 (_)

    class 안에 언더바 1개인 속성이나 메소드는 외부 사용자는 사용하지 말라는 권유의 문법

  • 언더바 2개 사용( __ )

    class 안에 언더바 2개인 속성이나 메소드는 외부에서 확인 및 수정할 수 없고, 클래스 내부에서만 사용 가능하다. (like 지역변수)

  • name mangling

    '_클래스명__함수명'으로 은닉된 정보에 접근 가능하다.

class Person():
  def __init__(self, name, age):
    self.name = name
    self.age = age
    self._a = 'a'
    self.__b = 'b'

def _check1(self): print('_check1 메소드가 실행됨.')

def check2(self): print('chcek2 메소드가 실행됨.')

j = Person('jiho', 26)

print(j.name) # jiho print(j.age) # 26 print(j._a) # a | 접근은 가능하지만 지양하라 print(j.b) # AttributeError: 'person' object has no attribute 'b' print(j._Person__b) # b

j._check1() # 출력: _check1 메소드가 실행됨. j.check2() # AttributeError: 'person' object has no attribute 'check2' j._Person__check2() # __chcek2 메소드가 실행됨.

4. 추상화

객체마다 반복적인 개념이나 기능을 요약한다. 보통 상위클래스로 추상클래스를 만들고, 이를 상속 받은 개별 클래스를 생성한다. 추상클래스에는 추상메소드를 선언까지만 하며, 해당 메소드는 상속받은 다른 클래스의 메소드에서 구현된다. 추상클래스를 사용하는 이유? : 복잡한 대형 프로젝트는 클래스의 기본적인 틀을 만드는 1차적 설계를 추상화시켜놓고, 활용 여부는 차후에 결정하기 위함이다.

from abc import ABC, abstractmethod

class DogHouse(ABC):

    @abstractmethod  
    def create_roof(self, roof_color):  # 지붕 만들기
        pass

    @abstractmethod
    def creat_windows(self, window_count):  # 창문 만들기
        pass

    @abstractmethod
    def creat_space(self, where):  # 공간 사이즈 정하기
        pass

    @property
    def count(self):  # 집에 살 강아지 수
        pass

class MyDogHouse(DogHouse):

    def create_roof(self, roof_color):
        self.roof_color = roof_color

    def creat_windows(self, window_count):
        self.window_count = window_count

    def creat_space(self, where):
        self.where = where

    @property
    def count(self):
        return self.dog_count   

    @count.setter
    def count(self, dog_count):
        self.dog_count = dog_count

    def __str__(self):
        return "강아지집 정보\n\n지붕 색: {}\n창문 갯수: {}\n공간: {}\n집에 사는 강아지수: {}".format(
            self.roof_color,self.window_count, self.where, self.dog_count)

my_dog_house = MyDogHouse()

my_dog_house.create_roof("빨강")
my_dog_house.creat_windows(2)
my_dog_house.creat_space("4평")
my_dog_house.count = 3 # count함수의 setter를 이용

print(my_dog_house)
'''
출력:
강아지집 정보

지붕 색: 빨강
창문 갯수: 2
공간: 4평
집에 사는 강아지수: 3
'''

출처: Panda의 IT노트

프로그래밍을 하다보면 파일 안에 여러개의 함수를 만들기도 한다. 함수 내에서 선언하며 해당 함수 안에서만 존재한다. 함수가 호출되어 실행될 때 만들어지고, 함수의 실행이 끝나면 모두 삭제된다. 함수 밖에서는 해당 변수를 부를 수 없다.

def local_variable_check():
    a = 'local'
    return a
print(local_variable_check()) # local
print(a) # NameError: name 'a' is not defined

전역변수 (global variable)

함수 밖에서 선언하며 어디에서든지 접근 가능한 변수이다.

a = [1,2,3]
def plus():
    a.append(4)
plust()
print(a) # [1,2,3,4]

함수 안에서 처음 선언된 변수는 지역변수이지만, 해당 변수를 전역변수를 사용하고 싶다면 'global 변수명' 형태로 입력하면 된다.

a = [1,2,3]
def plus2():
    a.append(4)
    global b # 함수 내에서 전역변수를 선언
    b = 'hello world'
    c = 50
print(a) # [1,2,3,4]
plus2()
print(b) # hello world
print(c) # NameError: name 'c' is not defined

본격 Python만의 유용한 문법 자랑 TIME

• rjust & ljust & zfill

  s.rjust(n, k) | s.ljust(n, k) | s.zfill(n) * k가 생략일 경우 띄어쓰기로 채움. * type(s) == type(k) == str * len(k) <= 1

  # rjust
  s1 = 'you'
  k1 = '0'
  n1 = 5 
  print(s1.rjust(n1, k1)) # 00you | 기존의 n앞에 k를 붙여서 총 5글자를 만든다.
  check = '123'.rjust(4))
  print(check) # 123
  print(len(check)) # 4 | 123옆에 공백 하나가 더 있는, '123 '인 것이다.
  

ljust

a = '123' print(a.ljust(5, '0')) # 12300 k = a.ljust(5) print(k) # 123 print(len(K)) # 5 | k는 '123 '인 문자열이다.

zfill: 0을 왼쪽부터 채운다.

print('300'.zfill(5)) # 00300

</br>

- ## map & filter - with.  lambda
1. map과 filter는 **반복 가능한 iterable 객체**를 받아서 **특정 함수**를 적용시킨다.
2. lambda는 특정 함수를 간략히 작성하기 위해 사용된다.

```python
# map(함수, iterable 객체)
lst = ['1','2','3','4']
result = map(int, lst)
print(result) # 객체 주소 <map object at 0x7f70ca673890>
print(list(result)) # [1, 2, 3, 4] | map 객체를 list로 변형


# map with lambda
lst = ['1','2','3','4']
result = list(map(lambda x: int(x), lst))
''' 해석
1) map 함수로 인해 lst의 요소를 하나씩 받을 수 있다.
2) lambda로 인해 하나씩 받은 요소는 x가 되고, int(x)를 반환한다.
3) map 객체를 list로 묶어준다.
'''
print(result) # [1,2,3,4]



# filter(함수, iterable 객체)
def even(x): # 짝수를 구하는 함수
    if x % 2 == 0:
        return True
    else:
        return False
lst = [1,2,3,4,5]
result = filter(even, lst) # filter(필터 조건 함수, iterable한 객체)
print(result) # 객체 주소 <filter object at 0x7f70ca4d0bd0>
print(list(result)) # [2,4]


# filter with lambda
lst = [1,2,3,4,5]
result = list(filter(lambda x: x % 2 == 0, lst))
'''해석
1) lst의 요소를 filter에 넣는다.
2) lambda x 식의 조건을 만족하는 값만 반환한다.
3) x가 들어올 때, x%2==0을 만족하는 값
'''
print(result) # [2,4]

• 컴프리헨션 (Comprehension)

  코드 간소화를 위해 함수나 파이썬 기능을 한 줄로 구현한 것.

# ex1) list
n = [1,2,3,4,5]
plus = []
for i in n:
    plus.append(i+1)
print(plus) # [2,3,4,5,6]
# 리스트 컴프리헨션을 사용하면?
compre = [i+1 for i in n]


# ex2) dict
n = {'a':1, 'b':2, 'c':3, 'd':4, 'e':5}
dic_compre = {value: key for key, value in n.items()}


# ex3) 조건
numbers = {'amy': 7, 'jane': 9, 'sophia': 5, 'jay': 10}
pas = {name: 'PASS' if numbers > 8 else 'NO PASS' for name, numbers in numbers.items()}
print(pas) # {'amy': 'NO PASS', 'jane': 'PASS', 'sophia': 'NO PASS', 'jay': 'PASS'}

• 또 어떤 재미있는 문법이 있을까?

쉽지만 헷갈리는 리스트의 문법을 모아보자!

• *더하기(+) & append & extend & insert *

  a = [1,2]
  b = ['a','b']
  

더하기

print(a + b) # [1, 2, 'a', 'b']

append1

a.append('rol') print(a) # [1,2,'rol']

append2

c = [1,2,3] c.append(b) print(c) # [1,2,3,['a', 'b']]

extend

a.extend(b) print(a) # [1,2,'rol', 'a', 'b']

insert(i,n) : i번째 위치에 n을 삽입

a.insert(4, '=') print(a) # [1, 2, 'rol', 'a', '=', 'b']

insert(i,n) : i >= len(list)일 경우, 마지막에 삽입된다.

a = [0,1,2,3] a.insert(8, 4000) print(a) # [0,1,2,3,4000]

</br>

- ### **del & remove & pop**
```python
a = [1,2,1,4,5]

# del: index를 찾아 삭제
del a[3:] # 세번째 index인 4부터 모두 삭제
print(a) # [1,2,1]

# remove1: 첫 번째 값을 찾아 삭제
a.remove(1) # a 속 2를 찾아 삭제
print(a) # [2,1]

# remove2: 값이 없으면 Error
a.remove(4) # ValueError: list.remove(x): x not in list

# pop
a = [1,2,3,1,4]
print(a.pop()) # 4 | 마지막 요소인 4을 삭제하고 반환한다.
print(a) # [1,2,3,1]
print(a.pop(1)) # 2 | 1번째 index 값인 2를 삭제하고 반환한다.
print(a) # [1,3,1]

• sort & sorted & reverse

  # sort
  a = [2,5,1]
  print(a.sort()) # None | a가 정렬되었을 뿐, 반환하진 않는다.
  print(a) # [1,2,5]
  a.sort(reverse=True) # a를 내림차순 정렬한다.
  print(a) # [5,2,1]
  

sorted

a = [2,5,1] print(sorted(a)) # [1,2,5] # 정렬된 a를 반환할 뿐, a 자체를 정렬하진 않는다. print(a) # [2,5,1]

reverse

a = [2,5,1] print(a.reverse()) # None | a가 현재 순서의 역순으로 정렬되만, 반환되진 않는다. print(a) # [1,5,2]

</br>

- ### **반복 (*)**
```python
a = [1,2]
print(a * 3) # [1,2,1,2,1,2]

• count

  a = [1,2,1,3]
  print(a.count(1)) # 2 | 1이라는 요소의 갯수를 count

정규표현식은 전처리 등의 작업을 위해 복잡한 문자열을 처리할 때 자주 사용된다.

1. 컴파일 후 매칭 (re.compile)

원하는 문자열을 re.compile(조건) 형태로 객체화시킨 후, 이를 사용하여 문자열 검색을 수행할 수 있다.

import re
r = re.compile([a-z]) # 패턴(소문자 a-z)를 가지고 있는 r 객체를 리턴한다. 

# match함수는 아래에서 자세히 살펴본다.
m = r.match('aBc3') # 문자열(aBc3)이 소문자로 시작하는 패턴을 갖는가? Y
print(m.group()) # a

2. 축약형

math, search 등의 메소드 안에 패턴과 문자열을 모두 집어넣는 방법

import re
str1 = 'aBc3'
m = re.match('[a-z]', str1)
print(m.group()) # a

메타문자

:원래 그 문자가 가진 뜻이 아닌 특수한 기능을 하는 문자. compile로 패턴을 만드려면 패턴을 나타내는 메타문자를 알아야 한다.

. * [ ] ^ $ + ? { }  \ | ( )

정규표현식 메소드

re.match

문자열의 처음부터 정규식(패턴)과 일치되는지 조사. 일치하는게 없을 경우 re.match는 None을 반환한다. 패턴이 발견되면 검색을 멈추고 패턴을 객체로 return 한다.

1. 컴파일 사용

   r = re.compile('[a-z]') # 소문자로 시작하는 패턴
   m = r.match( "let's study hard" )
   print(m.group()) # 결과: l
   

#문자열이 소문자로 시작하지 않을 경우 m_none = r.match("Let's study hard") # 소문자로 시작하지 않음= 일치하는게 없음 print(m_none) # 결과: None print(m_none.group()) # 결과: AttributeError: 'NoneType' object has no attribute 'group'

2. 축약형
```python
m2 = re.match('[a-z]*', "let's study hard" ) # 소문자가 계속 반복되는 패턴
print(m2.group()) # 결과: let

re.search

match는 문자열의 처음부터 찾는다면, search는 처음부터 끝까지 확인. 일치하는게 없을 경우 re.search는 None을 반환한다. 패턴이 발견되면 검색을 멈추고 패턴을 객체로 return 한다.

1. 컴파일 사용

   r = re.compile('[a-z]') # 소문자로 시작하는 패턴
   m = r.search( "Let's study hard" )
   print(m)
   # 결과: <re.Match object; span=(1, 2), match='e'>
   # span(1,2)는 1번째 index인 e부터 시작하여, 2번째 인덱스 전까지를 의미한다.
   print(m.group()) # 결과: e
   

2. 축약형
```python
m2 = re.search('[a-z]*', "let's study hard" ) # 소문자가 계속 반복되는 패턴
print(m2.group()) # 결과: let

re.finall

문자열 중 패턴과 일치되는 부분을 모두 찾아 리스트 형태로 return 한다. 일치하는게 없을 경우 빈 리스트를 return.

r = re.compile('[a-z]') # 패턴: 소문자
m = r.findall('A Bc deF')
print(m)
# 결과: ['c', 'd', 'e']

m2 = r.findall('MY NAME IS..') # 소문자가 없음
print(m2)
# 결과: []

re.finditer

findall처럼 문자열 중 패턴과 일치되는 부분을 모두 찾는다. 다만, 매치되는 문자열을 iterator 객체로 return한다. iterator 객체 값을 불러오려면 for문을 사용해야 한다.

r = re.compile('[a-z]') # 패턴: 소문자
m = r.finditer('A Bc deF')
print(m) # 결과: <callable_iterator object at 0x7f70ca5b1690>

# iterator 객체인 m을 불러오려면
for i in m:
  print(i)
  print(i.group())

# 결과
<re.Match object; span=(3, 4), match='c'>
c
<re.Match object; span=(5, 6), match='d'>
d
<re.Match object; span=(6, 7), match='e'>
e