PyojunCode | Feed

[Mathematics for Machine Learnig] Linear Algebra (2)

Sun, 09 Mar 2025 15:05:00 GMT

1. Linear Algebra - (2)

Vector Space

Matrix는 Vector를 변환하거나 Vector Space를 정의하는 등 Matrix와 Vector는 매우 밀접한 연관이 있다.

Group

Definition of Group:

Consider a set $\mathcal{G}^4$ and an operator $\otimes$ : $\mathcal{G}$ × $\mathcal{G}$ → $\mathcal{G}$ defined on $\mathcal{G}$ . Then G := ( $\mathcal{G}$ , $\otimes$ ) is called group if the following holds:
- Closure(닫힘성): 어떠한 Operation $\otimes$ 에 대하여 $\forall{x,y}\in\mathcal{G}$ 인 $x, y$ 에 대하여 $x\otimes y \in \mathcal{G}$ 이다.
- Associativity(결합법칙): $\forall{x,y,z}\in\mathcal{G}$ 에 대하여 $(x\otimes y) \otimes z = x\otimes (y \otimes z)$ 이다.
- Neutral element(중립원) or Identity element: $\exists{e}\in\mathcal{G},\ \forall{x}\in\mathcal{G}$ : $x\otimes e = x$ and $e\otimes x = x$
- Inverse element(역원): $\forall{x}\in\mathcal{G},\ \exists{y}\in\mathcal{G}$ : $x\otimes y = e$ and $y\otimes x = e$ 이면 $y = x^{-1}$ 를 $x$ 의 inverse 라고 부른다.
- Commutative(Abelian group): $\forall{x,y}\in\mathcal{G}$ : $x\otimes y = y\otimes x$ . 벡터공간에서의 덧셈은 아벨군이라고도 부름.

Vector Group의 예시는 다음과 같다.

$(\mathbb{Z},+)$ 는 Group이다.
- Closure: 두 정수를 더하면 여전히 정수임.
- Associativity: 정수의 덧셈은 결합 법칙을 만족.
- Neutral element: 0.
- Inverse element: $x, -x$
$(\mathbb{N}_0, + )$ 는 Group이 아니다.
- Inverse element 가 존재하지 않는다. (e.g. <0, 1>)
$(\mathbb{Z},\cdot)$ 는 Group이 아니다.
- Inverse element 가 존재하지 않는다. (e.g. <4, 1> → inverse = 1/4)
$(\mathbb{R}, \cdot)$ 는 Group이 아니다.
- Inverse element 가 존재하지 않는다. (e.g. <0, 1>)
$(\mathbb{R^{m\times n}}, +)$ 는 Abelian Group 이다.
- 실수 행렬에 대해서 덧셈은 조건들을 만족함.

( $\mathbb{Z}$ =정수, $\mathbb{N}_0$ =0을 포함한 자연수)

Vector Spaces

Definition of Vector Space:

A real-valued vector space $V=(\mathcal{V}, +, \cdot)$ 는 다음과 같은 두가지 연산이 정의된 set $\mathcal{V}$ 이고
- Vector Addition : $\mathcal{V}+\mathcal{V}→\mathcal{V}$
- Scalar multiplication : $\mathbb{R}\times \mathcal{V}→\mathcal{V}$
이 두가지 연산이
- $(\mathcal{V}, +)$ is an Abelian group
- Distributivity:
  
  $\ \forall{\lambda}\in\mathbb{R},\ x,y\in\mathcal{V}$ : $\lambda\cdot(x+y)=\lambda\cdot x+\lambda\cdot y$
  
  $\forall{\lambda,\psi}\in\mathbb{R},\ x\in\mathcal{V}$ : $(\lambda+\psi)\cdot x = \lambda\cdot x + \psi\cdot x$
- Associativity: $\forall{\lambda,\psi}\in\mathbb{R},\ x\in\mathcal{V}$ : $\lambda(\psi\cdot x) = (\lambda\psi)\cdot x$
- Neutral element with respect to the dot operation: $x\in\mathcal{V}$ : $1\cdot x=x$
위의 네 가지를 모두 만족하면 $\mathcal{V}$ 는 Vector Space이다.

추가적으로 Vector Subspace 의 정의는 다음과 같다.

Let $V = (\mathcal{V}, +, \cdot)$ be a vector space and $\mathcal{U} \subseteq \mathcal{V}$ , $\mathcal{U} \neq \emptyset$ . Then $\mathcal{U}=(\mathcal{U},+,\cdot)$ is called vector subspace of $V$ (or linear subspace) if $\mathcal{U}$ is a vector space with the vector space operations + and $\cdot$ restricted to $\mathcal{U} \times \mathcal{U}$ and $\mathbb{R}\times \mathcal{U}$ (closed). We write $U \subseteq V$ to denote a subspace $\mathcal{U}$ of V

예를 들어,

The solution of a homogeneous system of linear equations $Ax = 0$ with unknown $x$ is a subspace of $\mathbb{R}^n$ 이다.

아래의 그림에서는 Vector space $(\mathbb{R}^2, +, \cdot)$ 에 대하여 A, B, C, D 중 D만이 Vector subspace이다.

Linear Independence

Linear Combination

Definition of Linear Combination:

Vector Space $V$ 의 vectors $x_1, x_2, …, x_k \in V$ 와 scalars $\lambda_1, \lambda_2, …, \lambda_k \in \mathbb{R}$ 에 대하여 이 둘의 조합 $v = \sum_{i=1}^k \lambda_i x_i \in V$ 를 Linear Combination 이라고 한다.

Linear (In)dependence

Definition of Linear (In)dependence:

Let us consider a vector space V with $k \in \mathbb{N}$ and $x_1 , ..., x_k \in V$ . If there is a non-trivial linear combination, such that $0 = \sum_{i=1}^k \lambda_i x_i$ with at least one $\lambda_i \neq 0$ , the vectors $x_1 , ..., x_k$ are linearly dependent. If only the trivial solution exists, i.e., $\forall\lambda_i = 0$ , the vectors $x_1 , ..., x_k$ are linearly independent
즉 Linearly independent 하려면, 어떤 vector도 나머지 vector들의 linear combination으로 나타낼 수 없음을 의미함. ( $\lambda_i x_i = 0$ 의 해가 모든 Scalar가 0이 되는것 뿐)
Row-Echelon Form 의 형태를 만들면, 해당 Vector의 Linear (In)dependence 를 체크할 수 있다.

Basis and Rank

Span

Definition of Generating set and Span:

Consider a vector space $V = (\mathcal{V}, +, \cdot)$ and set of vectors $A = \{x_1 , ..., x_k\} \ \subseteq \mathcal{V}$ . If every vector $v \in \mathcal{V}$ can be expressed as a linear combination of $x_1 , ..., x_k$ , $\mathcal{A}$ is called a generating set of $V$ . The set of all linear combinations of vectors in $\mathcal{A}$ is called the span of $\mathcal{A}$ . If $\mathcal{A}$ spans the vector space $V$ , we write $V = span(\mathcal{A})$ or $V = span(x_1 , ..., x_k)$

즉 Vector Space $V$ 안에 존재하는 Vector $\mathcal{V}$ 들로 구성된 임의의 set $\mathcal{A}$ 에 대하여, Vector space 안의 모든 Vector가 set $\mathcal{A}$ 안의 vector들의 linear combination 으로 표현이 가능하다면 $\mathcal{A}$ 는 $V$ 의 generating set이다. 즉, $\mathcal{A}$ 안의 vector 들이 Vector space $V$ 를 생성한다.

$\mathcal{A}$ 안에 포함된 모든 벡터들의 linear combination을 $\mathcal{A}$ 의 span 이라고 하며, 만약 $\mathcal{A}$ 의 span이 Vector Space $V$ 와 같다면 $V = span(\mathcal{A})$ 라고 표현할 수 있다.

Basis

Definition of Basis:

Consider a vector space $V = (\mathcal{V}, +, \cdot)$ and $\mathcal{A} \subseteq \mathcal{V}$ . $A$ generating set $\mathcal{A}$ of $V$ is called minimal if there exists no smaller set $\mathcal{A}^′ \subseteq \mathcal{A} \subseteq \mathcal{V}$ that spans $V$ . Every linearly independent generating set of $V$ is minimal and is called a basis of $V$ .

즉 Basis는 Vector Space $A$ 에 대한 minimal generating set의 linear independent vector set 라고 할 수 있다.

(e.g. $\mathbb{R}^2, \mathcal{B} = \{\mathbf{e}_1, \mathbf{e}_2 \}$ )

Vector들의 Linear independence를 파악하기 위해서, 앞서 배운 Gaussian elimination을 사용할 수 있다.

Gaussian elimination을 거치면 Vector는 RREF 형태로 나오게 되고, 모든 Column에 대해서 Pivot이 존재한다면 linear independent 하다.

예를 들어, 위의 $\mathcal{B_2}$ 를 RREF로 만들면 $\mathcal{B}_2 = \{ [1, 0,0]^T, [0, 1 ,0]^T, [0,0,1]^T\}$ 가 되므로 linearly independent하고 각 vector로 $\mathbb{R}^3$ 공간 상의 모든 Vector를 표현할 수 있는 mininmal generating set이므로, $\mathbb{R}^3$ 의 Basis 라고 할 수 있다.

Dimension and Rank

Definition of Dimension:

There can be many basis of a vector space.
However, all bases possess the same number of basis vectors.
The number of basis vectors are called dimension of the vector space.
The dimension is not necessarily the number of elements in a vector.

즉 Dimension은 해당 Vector Space를 생성하기 위한 최소한의 Vector 수 를 뜻하며, 이는 곧 Basis 의 vector 수를 의미한다.

Definition of Rank:

The number of linearly independent columns of a matrix $A \in \mathbb{R}^{m×n}$
(=) The number of linearly independent rows of a matrix $A \in \mathbb{R}^{m×n}$
The columns of $A$ span a subspace $U \subseteq \mathbb{R}^m$ with $dim(U) = rk(A)$ . This subspace is called image or range
A matrix A has full rank if $rk(A) = min(n, m)$
A square matrix $B \in \mathbb{R}^{m×m}$ is invertible iff $B$ has full rank

Ref:

POSTECH CSED343 (Prof. Dongwoo Kim)
Mathematics for Machine Learning, Marc Peter Deisenroth, A. Aldo Faisal, and Cheng Soon Ong, Cambridge University Press 2020

[Mathematics for Machine Learnig] Linear Algebra (1)

Sat, 08 Mar 2025 21:53:00 GMT

1. Linear Algebra - (1)

Matrices

이번 시간에는 기계학습을 위한 수학 중, 선형대 수학의 Matrix 에 대한 기본적인 개념들을 알아본다.

Inverse

Definition of Inverse:

Consider a square matrix $A\in\mathbb{R}^{n\times n}$ , Let matrix $B\in\mathbb{R}^{n\times n}$ have the property that $AB=I_n=BA$ .\ $B$ is called the inverse of $A$ and denoted by $A^{-1}$

즉 $n\times n$ 의 정방행렬 $A$ 에 대하여 행렬곱을 했을 때 Identity matrix가 나오게 하는 정방행렬 $B$ 를 $A$ 의 inverse matrix 라고 한다.

역행렬은 주어진 행렬이 가역적(invertible)일 때만 존재.

가역성은 행렬식(Determinant) 를 통해서 판단 가능하고 ( $det(A) !=0$ → invertible), 이를 구하기 위해서는 행렬이 정방행렬이여야함.

(p.s. 정방행렬이 아닌 행렬식에서는 Moore-Penrose pseudo-inverse 를 통해서 해를 근사할 수 있음.)

모든 matrix가 inverse matrix를 가지는 것은 아니다.
만약 inverse matrix가 존재한다면, 그 matrix는 regular/invertible/nonsingular 라고 부른다.
만약 존재하지 않는다면, singular/noninvertible 라고 부른다.

Transpose

Definition of Transpose:

For $A\in\mathbb{R^{m\times n}}$ the matrix $B\in\mathbb{R^{m\times n}}$ with $b_{ij} = a_{ji}$ is called the transpose of $A$ . We write $B^T = A$

즉 Matrix 원소들의 Row와 Column이 바뀐 상태를 의미한다.

만약 matrix $A\in\mathbb{R^{m\times n}}$ 에 대해서 $A=A^T$ 라면 $A$ 는 symmetric 이라고 한다.

vanilla python으로 matrix의 upper triangle만 탐색하여 간단하게 transpose를 구현할 수 있다. (or numpy.array.T)

#nxn matrix
for i in range(n): #row
	for j in range(i+1, n): #col
		matrix[i][j], matrix[j][i] = matrix[j][i], matrix[i][j]

Compact representation of system of linear equations

우리는 Matrix와 Vector를 사용하여 linear equations를 표현할 수 있다.

아래와 같은 Linear equation은

아래와 같이 $Ax=b$ 형태의 Matrix와 Vector 로 표현될 수 있다.

예를 들어

위의 System은 2개의 equation과 4개의 unknown variable이 존재한다. (즉 무수한 해(solutions)가 존재)

이 문제는 마찬가지로 $\sum_{i=0}^4 x_ic_i=b$ 의 형태로 표현할 수 있는데, 여기서 $c_i$ 는 $i$ 번째 Column이고 $b$ 는 $[42, 8]^T$ 이다.

그럼 이 식을 어떻게 풀 수 있을까?

Particular Solution

Particular Solution(특별해)은 말 그대로 어떠한 Linear equation system을 만족하는 하나의 특정한 해 이다.

예를 들어 바로 앞전의 linear equation $\sum_{i=0}^4 x_ic_i=b$ 에서

위 linear equation을 만족하는 해는 single 1 을 포함하는 column들을 통해서 쉽게 구할 수 있으며 이 경우 $x=[42, 8, 0, 0]^T$ 가 될 것이다.

General Solution

General Solution(일반해) 는 Linear equation system을 만족하는 모든 해들의 집합 을 나타낸다.

간단한 아이디어로, Linear equation에서 이미 구한 Particular solution에 0을 더하는 것은 기존 해가 성립하는데 에 있어서 아무런 영향을 주지 않을것이다.

따라서 이를 이용하여 Particular solution에서 사용되지 않는 변수 (위의 예제에서 $x_3, x_4$ ) 를 linear combination으로 표현하고, 자유변수 $\lambda_i$ 를 사용하여 homogeneous solution 을 추가해 더 많은 해들의 집합 $\lambda$ 를 구할 수 있다.

앞선 예제에서 $x_3[8, 2]^T$ 는 $8\times [1, 0]^T$ (which is $c_1$ ) + $2\times [0, 1]^T$ (which is $c_2$ ) 로 나타낼 수 있다.

$\therefore$ $\lambda_1(8c_1+2c_2-c_3)=0$

마찬가지로 4번째 항도 아래와 같이 표현 가능하다.

$\therefore\lambda_2(-4c_1+12c_2-c_4)=0$

최종적으로 general solution은 아래처럼 표현 가능하다.

Row-Echelon Form

Linear equation의 Solution을 구할때에는 Matrix를 Reduced Row-Echelon Form으로 만들면 매우 유용하다.

여기서 (Reduced) Row-Echelon Form은 뭘까?

Definition of Row-Echelon Form (REF):

All rows that contains only zeros are at the bottom of the matrix; correspondingly, all rows that contains at least one nonzero element are on top of rows that contain only zeros.
Looking at nonzero rows only, the first nonzero number from the left (also called pivot) is always strictly to the right of the pivot of the row above it.

참고: REF 에서 Pivot value에 대한 정의가 다른 경우가 있다.

*Technically, the leading coefficient can be any number. However, the majority of Linear Algebra textbooks do state that the leading coefficient must be the number 1. To add to the confusion, some definitions of row echelon form state that there must be zeros both above and below the leading coefficient. It’s therefore best to follow the definition given in the textbook you’re following (or the one given to you by your professor). ref;* statisticshowto

예를 들어,

위의 Matrix는 모든 Pivot 이 이전 row 의 Pivot 위치보다 오른쪽에 있고,

모든 값이 0인 Row가 제일 밑에 존재하므로 Row-Echelon Form 이라고 할 수 있다.

Definition of Reduced Row-Echelon Form (RREF):

It is in row-echelon form
Every pivot is 1.
The pivot is the only nonzero entry in its column.

예를 들어,

위의 Matrix는 1) 모든 Pivot value가 1이고, 2) 이전 row의 Pivot보다 오른쪽에 있으며, 3) 각 Pivot의 Column은 pivot이외의 값들이 모두 0이기 때문에 Reduced Row-Echelon Form 이라고 할 수 있다.

Reduced Row-Echelon Form에서는 Linear equation의 해를 매우 쉽게 구할 수 있다.

각각의 $i$ 번째 Pivot이 $x_i$ 의 해를 나타내므로

$x_1 = -2,\ x_3=1,\ x_4=-2$ 이고 Pivot이 존재하지 않는 2번째 Column은 free variable이 되므로 단순히 0 을 대입해 $x_2=0$ 을 얻으면 하나의 Particular Solution을 얻을 수 있다.

Free variable을 활용한 General Solution도 마찬가지로 아래와 같이 구할 수 있다

$x_1=2x_2-2,\\ x_3=1,\\ x_4=-2$

여기서 $x_2$ 는 Free variable이므로 $x_2=\lambda$ 라고 하면

$(x_1, x_2, x_3, x_4)=2\lambda-2,\ \lambda, 1,\ -2$

즉 $x\in\mathbb{R}^4 : x= [-2, 0, 1, -2]^T + \lambda[-2, -1, 0, 0]^T$

혹은 Minus one Trick을 사용하여 직관적으로 구할 수도 있다.

Free variable이 위치하는 Column에 -1 을 넣어주면

마찬가지로 $x\in\mathbb{R}^4 : x= [-2, 0, 1, -2]^T + \lambda[-2, -1, 0, 0]^T$ 를 얻을 수 있다.

Reduced Row-Echelon Form을 만드는 방법으로는 Gaussian elimination algorithm을 사용하면 된다.

Ref: Wikipedia

Ref:

POSTECH CSED343 (Prof. Dongwoo Kim)
Mathematics for Machine Learning, Marc Peter Deisenroth, A. Aldo Faisal, and Cheng Soon Ong, Cambridge University Press 2020

[논문리뷰] FastSpeech 2: Fast and High-Quality End-to-End Text to Speech

Sun, 23 Jun 2024 13:25:20 GMT

FastSpeech2

Basic of tts: FastSpeech2

Abstract

Tacotron 같은 auto regressive TTS 모델과 달리, FastSpeech와 같은 Non-auto regressive TTS 모델은 Training/Inference speed 에 있어서 매우 큰 장점을 가지고 있습니다.

하지만 FastSpeech model은 Non-auto regressive model의 핵심 요소인 Duration predictor를 학습하는데에 있어서, Teacher model로부터의 distillation 방식으로 학습이 이루어지기 때문에 여러가지 한계점이 존재했습니다.

따라서 FastSpeech2 논문에서는 우수한 성능을 발휘하면서 기존 Fastspeech에서 가지고 있던 한계점과 문제점을 해결할 수 있는 새로운 방법을 제시합니다.

Paper: FastSpeech 2: Fast and High-Quality End-to-End Text to Speech

Github: unofficial github

Methods

FastSpeech2 에서는 이전 논문인 FastSpeech 의 문제점을 해결하는데에 중점을 두었으며 전체적인 contribution은 다음과 같습니다.

Teacher - Student 구조의 학습 pipeline 대신 ground-truth mel-spectrogram을 직접 학습하는 구조를 차용하였습니다. FastSpeech 대비 3배에 달하는 학습 속도 향상을 이끌어냄과 동시에, Teacher model의 output 에서 이미 손실된 정보들을 사용하지 않기 때문에 Voice quality 또한 상승하였습니다.

Duration, Pitch, Energy 등의 추가적인 Variation information을 학습시에 condition input으로 제공하였습니다. 이를 통해 Text↔Mel-spectrogram 의 One-to-many mapping 에 있어서 더 정확한 학습을 가능하게 하였습니다.
기존의 TTS model이 Mel-spectrogram 을 output으로 생성하고 이후 vocoder로 waveform을 생성하는것과 달리, FastSpeech2 에서는 음성 품질을 유지하면서 Text로 부터 직접 waveform을 생성하는 fully end2end 의 TTS model의 구조를 사용합니다.

1. Overall structure

Deep learning TTS 에 있어서 고질적인 문제는 text sequence 정보만 가지고는 pitch, duration, prosody 등의 요소에 의해 결정될 수 있는 여러가지 가능성을 올바르게 예측하기 어렵다는 것입니다.

FastSpeech2는 이러한 문제점을 해결하기 위한 Module 들로 구성되어 있으며 Phoneme Embedding - Encoder - Variance Adaptor - Mel-spectrogam/Waveform Decoder 의 순서를 따릅니다.

2. Encoder

encoder github

Phoneme Embedding과 Encoder/Decoder 부분은 기존 FastSpeech 모델과 동일합니다.

Input phoneme data를 encoder의 input dimension으로 embedding을 해주고, Sinusoidal position encoding을 통해 위치 정보를 더해줍니다.

self.src_word_emb = nn.Embedding(
    n_src_vocab, d_word_vec, padding_idx=Constants.PAD
)
#n_position = max_sequence_length + 1
self.position_enc = nn.Parameter(
    get_sinusoid_encoding_table(n_position, d_word_vec).unsqueeze(0),
    requires_grad=False,
)

#max_len = input sequence length
enc_output = self.src_word_emb(src_seq) + self.position_enc[
    :, :max_len, :
].expand(batch_size, -1, -1)

이후 $N$ (4 in paper)개 의 FFT Block (multi-head self attention + 1D conv) 로 이루어진 Encoder를 통과시켜 줍니다.

for enc_layer in self.layer_stack:
  enc_output, enc_slf_attn = enc_layer(
      enc_output, mask=mask, slf_attn_mask=slf_attn_mask
  )

3. Variance Adaptor

variance adaptor github

Variance Adaptor는 encoder의 output에 여러가지 variance information을 더해주어 더 정확한 음성을 생성하도록 도와주는 역할을 합니다.

대표적인 Variance information으로는 1) 생성될 음성의 길이 정보인 Duration, 2) 음성의 emotion과 prosody를 결정하는데에 중요한 역할을 하는 Pitch, 3) 음성의 소리 크기와 prosody에 영향을 주는 Energy 가 있습니다.

그 밖에도 emotion, style, speaker 등 부가적인 feature들도 얼마든지 선택적으로 제공할 수 있습니다.

Variance Adaptor는 여러개의 Predictor가 중첩되어있는 구조를 가지고 있습니다.

Predictor는 1D Conv, ReLU, LayerNorm, DropOut으로 구성된 간단한 구조를 가지고 있습니다.

FastSpeech2의 학습 시에는 GT Variance information을 encoder의 output에 더해주어 올바른 음성을 예측하도록 학습시킴과 동시에 encoder의 output을 input으로 받아 해당 GT 값을 예측 하도록 Predictor를 학습시키게 됩니다.

2-1. Duration Predictor

Duration predictor는 phoneme hidden sequence 를 input으로 받아 각 phoneme의 duration을 예측합니다.

duration은 각 phoneme이 몇개의 mel-spectrogram frame에 할당되느냐를 나타내며, log scale로 된 duration을 MSE(L2) Loss 를 통해 학습하게 됩니다.

FastSpeech1 에서 pre-trained auto regressive TTS model (Transformer TTS) 의 output을 GT로 사용한것과 달리, 수리통계 기반 방식인 Montreal forced alignment(MFA) 를 통해서 얻은 Duration을 GT로 사용하여 더 정확한 학습을 가능하게 합니다.

랜덤으로 선택한 50개의 샘플에서, GT와의 길이차이와 음성 품질이 MFA 에서 더 좋은것을 확인할 수 있습니다.

2-2. Pitch Predictor

GT pitch contour의 high variations 때문에 Pitch contour 값을 올바른 분포로 바로 예측하는것은 어렵습니다.

따라서 FastSpeech2 논문의 업데이트된 버전(v8)에서는 Pitch contour를 바로 예측하는 것이 아니라 continuous wavelet transform(CWT) 을 통해 pitch spectrogram (frequency) 영역에서 예측 후 역과정을 취해주는 방식을 차용했습니다. (결과 확인 필요)

해당 과정을 통해 얻은 pitch $F_0$ 를 256 범위로 quantize하고 log를 취한 값을 embedding 하여 feature에 더해주게 됩니다.

2-3. Energy Predictor

Energy는 각 frame에 short-time fourier transform(STFT) 를 적용하여 나온 L2-Norm amplitude값을 사용하였습니다. 해당 값을 256 범위로 quantize 후 embedding 하여 feature에 더해주게 됩니다.

Predictor는 quantized 된 energy value가 아닌 original energy value를 예측하도록 MSE (L2) Loss를 통해서 학습됩니다.

Energy를 사용하지 않은 FastSpeech보다 FastSpeech2, FastSpeech2s 에서 GT와의 MAE가 더 작은것을 확인할 수 있습니다.

4. FastSpeech2s

FastSpeech2s 는 text 로부터 waveform 을 바로 예측하는 fully end2end 의 구조를 가지고 있습니다.

FastSpeech2 를 포함한 기존의 모델들이 output이 mel-sepctrogram인 acoustic model인것과 달리,

Fastspeech2s는 mel-spectrogram 생성 과정을 생략하고 바로 waveform을 예측하기 때문에 별도의 vocoder 가 필요 없다는 장점이 있습니다.

하지만 text로부터 waveform 을 직접 예측하는데에는 아래와 같은 어려움이 존재합니다.

Waveform은 phase 등 mel-spectrogram에 비해서 더 많은 variance information을 가지고 있기 때문에 input과 output 사이의 information gap이 더 큽니다. 따라서 비교적 더 어려운 one2many problem을 해결해야 합니다.
text에 대응되는 audio clip은 매우 긴 waveform을 가지기 때문에 학습/추론에 있어서 GPU memory를 매우 많이 소모합니다.

이러한 어려움을 해결하기 위해 FastSpeech2s 에서는 다음과 같은 waveform decoder를 제시합니다.

Waveform decoder가 hidden sequence로 부터 waveform을 만들때 필요한 phase 정보는 variance predictor 로 학습시키기 어렵다는 한계가 있습니다.

따라서 이를 해결하기 위해 mel-spectrogram decoder + vocoder(WaveNet)로 부터 생성된 waveform 을 target으로하는 adversarial training을 통해 waveform decoder를 학습합니다.

Conclusions

FastSpeech2는 더욱 정확한 duration 정보와 pitch, energy 같은 부가적인 정보를 variance adaptor를 통하여 제공하여 기존보다 고품질의 음성 생성 능력을 학습하였습니다.
또한, FastSpeech2s 에서는 Waveform decoder를 통해서 Text2Waveform의 fully end2end TTS pipeline 에서 의미있는 성과를 달성하였습니다.

Deploy pytorch model with AWS inferentia

Fri, 22 Dec 2023 22:00:00 GMT

Deploy pytorch model with AWS inferentia

What is AWS inferentia?

AWS Inferentia 및 AWS Inferentia2는 저렴한 비용으로 높은 성능의 추론을 제공하도록 AWS가 설계 및 구축한 기계 학습 추론 액셀러레이터입니다. 각 AWS Inferentia 액셀러레이터에는 4개의 1세대 NeuronCore가 있으며 FP16, BF16 및 INT8 데이터 유형을 지원합니다. 각 AWS Inferentia2 액셀러레이터에는 2개의 2세대 NeuronCores가 있으며 FP32, TF32 및 구성 가능한 새로운 FP8(cFP8) 데이터 유형을 추가로 지원합니다.

https://aws.amazon.com/ko/ec2/instance-types/inf1/

해당 글에서는 pytorch model을 AWS inferentia instance에 배포하고, 비슷한 사양의 CPU instance와 추론 속도를 비교하여 inferentia를 통해 얼마나 큰 폭의 비용절감과 속도 향상이 있는지 알아봅니다.

Pytorch model for inferentia

Create inferentia instance

inferentia instance를 생성합니다. aws neuron SDK는 inferentia instance에서만 정상 작동 하기 때문에, 앞으로의 과정은 해당 instance 내에서 진행해야 합니다.

https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EC2_GetStarted.html#ec2-launch-instance

instance: inf1.2xlarge

storage: 16GB~ 권장

security rule: default

instance를 생성할 때 발급했거나 이미 존재하는 key로 instance에 접속합니다.

(접속이 불가능할 시 security rule에서 0.0.0.0 ip가 허용되어 있는지 확인.)

ssh -i <key>.pem ubuntu@<server_ip>

Install pytorch-neuron dependencies (Inferentia1)

아래의 명령어들을 실행하여 inferentia에서 model을 추론하기 위해 필요한 환경을 구축합니다.

install drivers

# Configure Linux for Neuron repository updates
. /etc/os-release
sudo tee /etc/apt/sources.list.d/neuron.list > /dev/null <<EOF
deb <https://apt.repos.neuron.amazonaws.com> ${VERSION_CODENAME} main
EOF
wget -qO - <https://apt.repos.neuron.amazonaws.com/GPG-PUB-KEY-AMAZON-AWS-NEURON.PUB> | sudo apt-key add -

# Update OS packages 
sudo apt-get update -y

# Install OS headers 
sudo apt-get install linux-headers-$(uname -r) -y

# Install git 
sudo apt-get install git -y

# install Neuron Driver
sudo apt-get install aws-neuronx-dkms=2.* -y

# Install Neuron Tools 
sudo apt-get install aws-neuronx-tools=2.* -y

# Add PATH
export PATH=/opt/aws/neuron/bin:$PATH

install pytorch-neuron

# Install Python venv 
sudo apt-get install -y python3.8-venv g++ 

# Create Python venv
python3.8 -m venv aws_neuron_venv_pytorch_inf1 

# Activate Python venv 
source aws_neuron_venv_pytorch_inf1/bin/activate 
python -m pip install -U pip 

# Install Jupyter notebook kernel
pip install ipykernel 
python3.8 -m ipykernel install --user --name aws_neuron_venv_pytorch_inf1 --display-name "Python (torch-neuron)"
pip install jupyter notebook
pip install environment_kernels

# Set pip repository pointing to the Neuron repository 
python -m pip config set global.extra-index-url <https://pip.repos.neuron.amazonaws.com>

# Install PyTorch Neuron
python -m pip install torch-neuron neuron-cc[tensorflow] "protobuf" torchvision

Compile model for inferentia

torch model을 neuron을 사용하여 compile해야 inferentia에 알맞게 최적화 할 수 있습니다. (fp16, bf16, int8 지원)

python virtual env가 활성화 되어있지 않다면, source aws_neuron_venv_pytorch_inf1/bin/activate 명령어를 통해 활성화 합니다.

이후 아래와 같이 model을 불러오고, 알맞은 dummy input을 생성하여 neuron을 통해 compile을 진행합니다.

import torch
import torch_neuron

model = Model() # Init your model

model.eval()

data = torch.rand(1, 3, 1088, 1920) # Create dummy data

torch.neuron.analyze_model(model, example_inputs=[data])

model_neuron = torch.neuron.trace(model, example_inputs=[data])

model_neuron.save("simpleunet_neuron.pt")

아래와 같이 Compiler status PASS 가 출력되면 compile을 성공적으로 마친것입니다.

설정한 경로에 pt 파일이 생성된 것을 확인할 수 있습니다.

INFO:Neuron:The following operations are currently supported in torch-neuron for this model:
INFO:Neuron:prim::Constant
INFO:Neuron:aten::_convolution
INFO:Neuron:aten::add
INFO:Neuron:prim::ListConstruct
INFO:Neuron:aten::relu_
INFO:Neuron:aten::upsample_bilinear2d
INFO:Neuron:100.00% of all operations (including primitives) (656 of 656) are supported
INFO:Neuron:100.00% of arithmetic operations (63 of 63) are supported
INFO:Neuron:All operators are compiled by neuron-cc (this does not guarantee that neuron-cc will successfully compile)
INFO:Neuron:Number of arithmetic operators (pre-compilation) before = 63, fused = 63, percent fused = 100.0%
...
...
Compiler status PASS
INFO:Neuron:Number of arithmetic operators (post-compilation) before = 63, compiled = 63, percent compiled = 100.0%
INFO:Neuron:The neuron partitioner created 1 sub-graphs
INFO:Neuron:Neuron successfully compiled 1 sub-graphs, Total fused subgraphs = 1, Percent of model sub-graphs successfully compiled = 100.0%
...

Define pre/post processing functions

필요 시 data 전/후 처리 pipeline을 구성합니다.

예제에서는 간단하게 dummy input으로 batching 해주는 함수만 구현 하였습니다.

import numpy as np

def preprocess(batch_size=1, num_neuron_cores=1):
		image = torch.rand(1, 3, 1088, 1920)

    # Create a "batched" image with enough images to go on each of the available NeuronCores
    # batch_size is the per-core batch size
    # num_neuron_cores is the number of NeuronCores being used
    batch_image = image
    for i in range(batch_size * num_neuron_cores - 1):
        batch_image = torch.cat([batch_image, image], 0)
     
    return batch_image

Run inference using neuron model

속도 테스트를 할 수 있는 전체 코드 예시는 아래와 같습니다.

# inference.py
from time import time

import torch
import torch_neuron
import numpy as np

def preprocess(batch_size=1, num_neuron_cores=1):
    image = torch.rand(1, 3, 1088, 1920)

    # Create a "batched" image with enough images to go on each of the available NeuronCores
    # batch_size is the per-core batch size
    # num_neuron_cores is the number of NeuronCores being used
    batch_image = image
    for i in range(batch_size * num_neuron_cores - 1):
        batch_image = torch.cat([batch_image, image], 0)
     
    return batch_image

def benchmark(model, image):
    print('Input image shape is {}'.format(list(image.shape)))

    # The first inference loads the model so exclude it from timing
    results = model(image)

    # Collect throughput and latency metrics
    latency = []
    throughput = []

    # Run inference for 100 iterations and calculate metrics
    num_infers = 100
    for _ in range(num_infers):
        delta_start = time()
        results = model(image)
        delta = time() - delta_start
        latency.append(delta)
        throughput.append(image.size(0)/delta)

    # Calculate and print the model throughput and latency
    print("Avg. Throughput: {:.0f}, Max Throughput: {:.0f}".format(np.mean(throughput), np.max(throughput)))
    print("Latency P50: {:.0f}".format(np.percentile(latency, 50)*1000.0))
    print("Latency P90: {:.0f}".format(np.percentile(latency, 90)*1000.0))
    print("Latency P95: {:.0f}".format(np.percentile(latency, 95)*1000.0))
    print("Latency P99: {:.0f}\\n".format(np.percentile(latency, 99)*1000.0))

if __name__ == "__main__":
    image = preprocess()
    model = torch.jit.load("<neuron_model_name>")

    benchmark(model, image)

위의 코드를 실행하면, 100번의 추론에 대한 평균 throughput과 latency(s) 가 출력됩니다.

Run inference using DataParallel (Optional)

inferentia에는 여러개의 neuron core가 존재합니다. (inf1.2xlarge의 경우 4개)

DataParallel을 이용하면, input batch를 slice 하여 각각의 neuron core로 보내 연산하기 때문에, throughput의 향상을 가져올 수 있습니다.

neuron core는 아래와 같이 torch.neuron.DataParallel 을 사용하여 사용할 수 있습니다.

# inference.py
...
...
if __name__ == "__main__":
    model = torch.jit.load("simpleunet_neuron.pt")
    model_parallel = torch.neuron.DataParallel(model)

    batch_size = 1
    num_neuron_cores = 4

    image = preprocess(batch_size, num_neuron_cores)

    benchmark(model_parallel, image)

Compile with different batch sizes (Optional)

Small batch size로 compile 된 모델로 dynamic batching을 사용하는것은 slicing, transfer 등의 작업 때문에 sub-optimal 한 throughput을 초래할 수 있습니다.

따라서 compile시에 더 큰 batch size를 설정하여 compile하면 dynamic batching을 통해 더 효율적으로 throughput을 개선할 수 있습니다.

batch size를 설정하는 법은 위에서 compile 할 때 model에 넘겨준 dummy input의 batch size를 키우기만 하면 됩니다.

...
data = torch.rand(<batch_size>, 3, 1088, 1920) # Create dummy data
...

Results

같은 Unet model을 동등한 spec의 c5.2xlarge instance에서 속도를 비교하였습니다.

1 batch size에서 각각 1.53fps, 4.23fps로 큰 차이가 있을 뿐 아니라,

CPU instance에서는 batch size를 높여도 아무런 이득이 없는 반면, Inferentia에서는 큰 개선이 있는것을 확인할 수 있습니다.

c5.2xlarge

OpenVino: 0.8259968497245238 -> 1.21 fps
Eager:  0.8111959931666711 -> 1.23 fps
Script:  0.6788944289999361 -> 1.49 fps
Compile:  0.6576376958332983 -> 1.53 fps
Intel-extension:  0.6574252737221337 -> 1.53 fps
Quantized script:  0.5683428937777788 -> 1.78 fps

inf1.2xlarge

#Input image shape is [1, 3, 1088, 1920]
Avg. Throughput: 4.23, Max Throughput: 4.25
Latency P50: 0.2357
Latency P90: 0.2360
Latency P95: 0.2364
Latency P99: 0.2558


#Input image shape is [24, 3, 1088, 1920]
Avg. Throughput: 15.60, Max Throughput: 15.81
Latency P50: 1.5380
Latency P90: 1.5540
Latency P95: 1.5585
Latency P99: 1.5689

Ref

https://awsdocs-neuron.readthedocs-hosted.com/en/latest/frameworks/torch/inference-torch-neuron.html#inference-torch-neuron

NVIDIA Jetson TensorRT Inference

Wed, 27 Sep 2023 21:54:00 GMT

NVIDIA Jetson TensorRT Inference

이 글에서는 pytorch를 사용해 만든 모델을 torch -> onnx -> trt 로 변환하여 최적화 후 배포하기위한 과정을 소개합니다.

Install torch

아래의 링크를 참고하여 설치하였습니다.

https://docs.nvidia.com/deeplearning/frameworks/install-pytorch-jetson-platform/index.html

Install dependencies

sudo apt-get -y update; 
sudo apt-get -y install autoconf bc build-essential g++-8 gcc-8 clang-8 lld-8 gettext-base gfortran-8 iputils-ping libbz2-dev libc++-dev libcgal-dev libffi-dev libfreetype6-dev libhdf5-dev libjpeg-dev liblzma-dev libncurses5-dev libncursesw5-dev libpng-dev libreadline-dev libssl-dev libsqlite3-dev libxml2-dev libxslt-dev locales moreutils openssl python-openssl rsync scons python3-pip libopenblas-dev;

Install Torch 2.0

export TORCH_INSTALL=https://developer.download.nvidia.cn/compute/redist/jp/v511/pytorch/torch-2.0.0+nv23.05-cp38-cp38-linux_aarch64.whl
python3 -m pip install --upgrade pip; python3 -m pip install aiohttp numpy=='1.19.4' scipy=='1.5.3' export "LD_LIBRARY_PATH=/usr/lib/llvm-8/lib:$LD_LIBRARY_PATH"; python3 -m pip install --upgrade protobuf; python3 -m pip install --no-cache $TORCH_INSTALL

저의 경우 LDLIBRARYPATH 환경변수 관련해서 에러 메세지가 나왔지만 정상적으로 설치되었습니다.

Verify Install

$ export LD_LIBRARY_PATH=/usr/lib/llvm-8/lib:$LD_LIBRARY_PATH
$ python3

>>> import torch

에러메세지 없이 torch가 import되고 torch.cuda.is_available() == True 면 정상적으로 설치된 것입니다.

Torch to Onnx

https://tutorials.pytorch.kr/advanced/super_resolution_with_onnxruntime.html

위의 글을 따라 쉽게 변환할 수 있습니다.

Onnx to TRT

onnx 변환을 jetson 이 아닌 다른 환경에서 했다면 rsync를 통해 옮겨줍니다.

rsync -rvz <onnx_name>.onnx <user_name>@<jetson_ip>:<dest_path>

앞선 과정처럼 환경을 설치했다면, tensorrt가 이미 깔려있기 때문에 아래의 명령어로 onnx를 trt로 빌드만 하면 됩니다.

/usr/src/tensorrt/bin/trtexec --onnx=<onnx_name>.onnx --saveEngine=<trt_name>.engine --int8 --verbose

빌드에 성공하면 아래와 같은 메세지 출력 후 파일이 생성됩니다.

&&&& PASSED TensorRT.trtexec [TensorRT v8502]
...

TRT Inference

https://docs.nvidia.com/deeplearning/tensorrt/api/index.html

위의 링크에서 trt의 전반적인 API를 확인할 수 있습니다.

pytorch로 TRT inference 하는 코드는 아래와 같이 작성할 수 있습니다.

몇몇 function은 추후 deprecated 될 수 있으니 참고바랍니다.

import argparse

import torch
import tensorrt as trt

def load_trt_engine(engine_path: str):
    with open(engine_path, "rb") as stream:
        serialized = stream.read()
    logger = trt.Logger(trt.Logger.ERROR)
    runtime = trt.Runtime(logger)
    engine = runtime.deserialize_cuda_engine(serialized)
    return engine

class TRTModel:
    def __init__(self, trt_path):
        self.model = load_trt_engine(trt_path)
        self.model_ctx = self.model.create_execution_context()

    @torch.no_grad()
    def run_engine(self, input_tensor):
        idx = self.model.get_binding_index("output_0")
        device = torch.device("cuda")
        dtype = torch.int8
        shape = tuple(self.model.get_binding_shape(idx))

        input_tensor = input_tensor.to(device=device, dtype=dtype)

        bindings = [None] * 2
        bindings[0] = input_tensor.contiguous().data_ptr()

        output = torch.empty(size=shape, dtype=dtype, device=device)
        bindings[idx] = output.data_ptr()

        self.model_ctx.execute_async_v2(
            bindings, torch.cuda.current_stream().cuda_stream
        )
        torch.cuda.synchronize()
        return output

if __name__ == "__main__":
    import time
    import numpy as np
    parser = argparse.ArgumentParser()
    parser.add_argument("--trt_path", type=str)
    args = parser.parse_args()
    trt_model = TRTModel(args.trt_path)
    total_time = []
    
    for i in range(100):
        input_tensor = torch.rand(1, 21, 1088, 1920)
        start = time.time()
        output = trt_model.run_engine(input_tensor)
        total_time.append(time.time() - start)
    print(np.mean(total_time[1:]))

output

>>> 0.24760057227780122

[논문리뷰] Simple Baselines for Image Restoration

Wed, 13 Sep 2023 13:54:00 GMT

Simple Baselines for Image Restoration

Paper: https://arxiv.org/pdf/2204.04676.pdf (ECCV 2022)

Introduction

최근 Computer vision task에서 다양한 방법론과 구조가 등장함에 따라 성능이 매우 향상되었습니다.

하지만 이러한 성능 향상을 위해 computational cost가 커지고, 모델 구조 (혹은 레이어) 는 더욱 복잡해졌습니다.

논문의 저자는 이러한 system complexity 를 1)inter-block complexity, 2)intra-block complexity 두가지로 나누어 분류합니다.

Inter-block complexity

Inter-block complexity에는 대표적으로 multi-stage, multi-scale fusion 등이 있습니다.

각각의 간단한 예로는

FastDVDNet처럼 앞의 Unet 에서는 feature를 추출하고 다음 stage의 Unet에서 해당 feature를 refine하는 구조는 multi-stage architecture에 해당하고

MPRNet 처럼 여러 size의 feature map 끼리 fusion 해주는 경우가 multi-scale fusion에 해당한다고 할 수 있습니다.

Intra-block complexity

Intra-block complexity는 Restormer, SwinIR 과 같이, 별도의 커널이나 복잡한 로직을 구현해야하는 경우라고 할 수 있습니다.

python이 지원되는 GPU server 에서는 해당 system-complexity가 크게 문제가 되지는 않지만, edge-device나 NPU 등 system, resource가 제약적인 환경에서는 문제가 될 수 있습니다.

Simple Baseline Network

논문의 저자는 이러한 system-complexity를 최소화 하면서 SOTA 급의 성능을 낼 수 있는 방법을 연구합니다.

이를 위해 우선 Baseline이 될 simple network를 구성하는데, inter-block complexity를 최소화 하기 위해서 일반적으로 vision task에서 사용되는 single-stage UNet (Plain UNet) 의 구조를 차용하였습니다.

UNet을 구성하는 block은 마찬가지로 conv-relu + skip connection의 plain 조합을 사용하였습니다.

이와 같은 Plain Unet을 기반으로, 이후에 서술될 내용과 같이 component들을 교체/추가 하여 SOTA급의 성능을 낼 수 있는 16GFLOPs (256x256) 크기의 Baseline Network를 구성하게됩니다.

Normalization

Normalization은 모델의 학습에 있어서 도움이 되는것은 맞지만, batch norm, Instance norm 과 같은 경우 batch size 등과 같은 요소들에 의한 불확실성이 존재합니다.

그렇기 때문에 실제로 최근 vision model의 경우 normalization을 제외시키는 경우가 대부분입니다.

하지만 저자는 최근 transformer 구조를 사용하는 SOTA 모델에서 사용하는 Layer Normalization에 주목하고, 이를 network에 도입하여 실험하였습니다.

그 결과, 학습에 안정성이 크게 증가하여 더 높은 learning rate를 사용할 수 있으며, 성능 또한 상향되었다고 하였습니다.

(denoising과 deblurring에서 각각 +0.44dB, +3.39dB의 PSNR 상승이 있었다고 하는데 크게 유의미한 수치인지는 모르겠습니다.)

Activation

일반적으로 Vision task에서는 activation function으로 ReLU나 Leaky ReLU를 주로 사용합니다.

저자는 최근 transformer 기반 SOTA 모델들이 GeLU function을 사용하는점에 주목하여 activation function을 GeLU로 교체하였습니다.

이를 통해 denoising task에서는 성능을 유지하고 (-0.02dB), deblurring task에서는 +0.2dB 의 성능 향상이 있었다고 합니다.

(이또한 수치적으로 의미는 별로 없고, 교체 이유또한 타당성이 있어보이진 않습니다.)

Attention

Transformer 구조가 vision task에 적용되면서 SOTA 성능을 낼 수 있게된 가장 핵심적인 요인은 self-attention 이라고 할 수 있습니다.

하지만 self-attention은 input size에 비례하여 연산량이 quadratic 하게 증가한다는 한계점이 있습니다.

이를 해소하기 위해서 SwinIR 등에서 window attention을 도입한 image restoration 모델을 제안하였지만, 연산량을 해결하는 대신 global context를 캐치하는 능력과 구현이 복잡하여 intra-block complexity가 상승한다는 단점이 있습니다.

따라서, Baseline network에는 self-attention 대신 local information을 위해 depthwise convolution을, global information을 위해 channel attention을 추가하였고, 이는 각 feature를 추출하는데에 충분하다고 주장합니다.

Baseline Network Summary

최종적으로 Baseline network는 위와 같은 Block을 가지는 UNet architecture가 됩니다.

이렇게 구성된 baseline network가 system-complexity가 높은 다른 모델들과 비교하여 성능면에서 뒤떨어지지 않는다는것을 실험을 통해 입증합니다.

Nonlinear Activation Free Network

결과에서 확인할 수 있듯, Baseline network는 기존 SOTA 모델들과 비교하여도 comparable한 성능을 보여줍니다.

하지만 논문에서는 이에 그치지 않고 simplicity를 유지하며 성능을 더 향상시킬수는 없는가? 성능을 유지하며 모델을 더 simple하게 만들수 없는가에 대해서 추가적인 고민을 하게됩니다.

Gated Linear Unit

저자는 고민에 대한 해답을 GLU(Gated Linear Unit) 에서 찾습니다.

Gate(X, f, g, \sigma)=f(x)\odot \sigma({g(X))},

GLU는 이미 수많은 transformer 기반 SOTA 모델에서 차용하고 있지만, 이것을 단순히 모델에 끼워넣는것은 intra-block complexity를 증가시키므로 목표에 알맞지 않습니다. 그렇기 때문에 아래의 과정을 통해 GLU를 단순화 합니다.

GELU(x)=x\Phi(x),

0.5x(1+tanh[\sqrt{2/\pi}(x+0.0044715x^3)]).

GELU의 근사식에 따라서, GELU는 GLU의 special case라고 할 수 있습니다.

따라서 GLU는 1)activation function으로 사용될 수 있고, $\sigma$ 를 제거하더라도 2)그 자체로 nonlinearity를 갖습니다.

이에 근거하여 저자는 GLU의 simple 버전인 SimpleGate를 제안하고 GELU를 대체합니다.

SimpleGate(X,Y) = X\odot Y

GELU의 복잡함과 달리, SimpleGate는 단순히 feature map의 channel을 반으로 나누어 곱해주는것으로 구현됩니다.

Baseline network의 GELU를 SimpleGate로 교체하였을때, 기존과 비교하여 성능 차이가 없거나 성능이 소폭 상승하는것을 확인했습니다.

Simplified Channel Attention

GELU를 SimpleGate로 대체하게 되면, Baseline network에서 nonlinear activation function은 오직 channel attention 내의 ReLU, Sigmoid만 존재하게 됩니다.

#Channel attention block
channel_attention = nn.Sequential(
	nn.AdaptiveAvgPool2d(1)
  nn.Conv2d(channel, channel // reduction, 1, padding=0, bias=bias),
  nn.ReLU(inplace=True),
  nn.Conv2d(channel // reduction, channel, 1, padding=0, bias=bias),
  nn.Sigmoid()
)

x = x * channel_attention(x)

일반적으로 channel attention은 위와 같은 과정으로 이루어지게 되는데, channel attention 을 하나의 function $\Psi$ 로 본다면 다음과 같은 형태로 다시 쓸 수 있습니다.

CA(X)=X*\Psi(X)

이 형태는 앞선 GLU 와 유사하게 볼 수 있고, 그렇다면 Channel Attention 또한 simplify 할 수 있다고 추측할 수 있습니다.

Channel attention의 핵심적인 역할만을 남겨두고 단순화를 하면 다음과 같이 Simple Channel Attention을 사용할 수 있습니다.

SCA(X)=X*Wpool(X)

Channel attention을 Simple Channel Attention으로 교체하였을때, 성능이 유지되거나 소폭 상승하는 결과를 얻을 수 있었다고 합니다.

Summary

GELU와 Channel Attention을 교체하는것으로 network에는 non linear activation function이 존재하지 않게 되었고, 성능 또한 유지되거나 소폭 상승하였습니다.

Conclusions

결론적으로 해당 논문에서는 single-stage UNet 구조를 사용하여 기존 목적인 inter, intra complexity를 줄였고, 거기에 더해 network 내의 nonlinear activation function을 모두 제거하여 simplicity를 더욱 높임과 동시에 SOTA급의 성능을 유지하였습니다.

저자는 이러한 network를 NAFNet(Nonlinear Activation Free Network) 라고 제안하였습니다.

NAFNet은 단순한 구조와 적은 계산량으로도 기존의 denoising, deblurring SOTA 모델과 동등하거나 더 좋은 성능을 나타냈습니다.

또한 Block 수를 조정하더라도 작은 모델부터 큰 모델까지 안정적으로 우수한 성능을 보여주어 scalable 하다는 장점을 갖고 있습니다.

[논문리뷰] AP-BSN: Self-Supervised Denoising for Real-World Images via Asymmetric PD and Blind-Spot Network

Mon, 05 Jun 2023 15:27:00 GMT

Paper: https://arxiv.org/pdf/2203.11799.pdf

Github: https://github.com/wooseoklee4/AP-BSN

Introduction

noise2void를 근본으로하여, Self-supervised denoising task 에서 다양한 Blind-spot network의 변형이 연구되고 있습니다.

하지만 대부분의 BSN 계열 연구들은 synthetic noise에 대해서 수행하였고, 실제 real noise data에 적용할 시 denoising 성능이 매우 떨어지는 경향이 있습니다.

따라서 해당 논문에서는 기존의 Blind-spot network, synthetic data의 문제점을 파악하고 그 한계점을 개선한 Assymetric Pixel shuffle downsampling BSN (AP-BSN) 을 제안합니다.

BSN and PD

Blind-spot network는 convolution layer의 receptive field에서 center pixel이 masking된 형태입니다. network는 주변 pixel로부터 noise를 제외한 signal들의 정보를 바탕으로 center pixel의 값을 예측하게 됩니다.

이러한 방식으로 denoising 능력을 학습하려면 1) noise가 spatially independent 해야하고 2) noise가 zero-mean 이어야 한다는 전제조건이 필수적입니다.

이러한 측면에서, 기존 synthetic noise 연구에서 대표적으로 사용하는 noise type인 additive white gaussain noise (AWGN) 는 위의 전제조건을 모두 만족하기 때문에 모델이 뛰어난 denoising 능력을 학습할 수 있습니다.

하지만, real noise는 isp process 등의 과정에서 noise 사이에 sptial correlation이 생기게 됩니다. (특히 interpolation이 일어나는 demosaicking)

결과적으로 근처의 subpixel의 noise 또한 BSN의 학습 타겟인 center pixel에 대한 단서가 될 수 있기때문에, 제대로된 학습이 진행되지 않습니다. 실제로 real noise에서는 BSN 모델이 identity mapping 하는 방향으로 학습이 진행되는것을 확인하였다고 합니다.

Pixel shuffle down sampling

따라서 real noise에서 이러한 spatial correlation을 제거하기 위해 When AWGN-based Denoiser Meets Real Noises 논문에서 Pixel shuffle down sampling (PD) 이라는 방법을 고안하였습니다.

PD는 일종의 pixel-shuffling의 inverse operation이라고 생각할 수 있습니다. image를 subsampling하고 mosaic 패턴으로 채워놓는 과정을 수행합니다.

이 과정을 통해서, noise 사이의 실제 거리가 더 멀어지는 효과가 생기고 이를 통해 spatial correlation을 어느정도 줄일 수 있습니다.

그럼에도 불구하고 기존의 연구들에서는 PD와 BSN의 직관적인 통합이 진행되지 않았는데, 그 이유는 PD로 인해 발생하는 correlation reduction과 detail reconstruction quality 사이의 trade-off 때문입니다.

실제로 real noise의 spatial correlation을 제거하기 위해서는 적어도 stride 5 정도의 PD가 수행되어야 합니다. 하지만 stride가 커질수록 더 강한 aliasing artifact가 랜덤으로 생겨나게 되는데, 이는 이미지의 detail이 noise로 인식되어서 detail이 더 많이 손실될 수 있음을 의미합니다.

AP-BSN

(Overall pipeline)

Asymmetric PD

앞서 언급했던것 처럼 large stride 를 통해 학습한 BSN은 denoising 능력이 뛰어나지만 image의 detail reconstruction에서 꼭 필요한 aliasing artifact를 noise로 판단하여 다 지워버리는 경향이 있습니다.

따라서 해당 논문에서는 Training time에는 stride $a$ , Testing time에는 stride $b$ 로 asymmetric하게 PD를 수행하는 방법론을 제시하였습니다.

실험을 통해 $a=5$ , $b=2$ 의 조합이 real noise에 대해서 가장 적절한 성능을 보이는것을 확인하였습니다.

PD의 stride factor를 아무리 작게 설정해도 denoising 과정에서 informative high-frequency 는 손실이 됩니다.

이를 방지하고자 기존 연구에서는 PD-refinement 라는 방식을 사용하여 inference를 진행하였습니다.

고정된 stride factor 로 겹치지 않는 영역에 대해서 각각 masking을 진행하고, 각각에 대해서 denoising을 진행한 뒤 평균을 취해 final result $I_{DN}$ 을 얻게 됩니다.

하지만 fixed stride를 통해 masking을 진행할 경우, 결국 항상 주변의 pixel과의 correlation은 어느정도 유지된다는 한계가 있고 이는 곧 성능적으로 부정적인 영향을 미치게 됩니다.

따라서 본 논문에서는 새로운 refinement 방법인 random-replacing refinement $R^3$ 을 제시합니다.

$R^3$ 에서는 T개의 randomized binary mask가 적용된 image에 대해서 infernce를 하고 합치게 됩니다.

randomized binary mask 는 p의 확률에 따라서 구성되며, 이를 통해 spatial correlation을 무시할 수 있을 수준으로 줄일 수 있으며 그렇기 때문에 $R^3$ 과정에서는 별도의 PD를 진행하지 않고 원본 이미지에 대해서 denoising을 수행합니다.

실험 결과 $p$ 는 약 0.16일때 가장 뛰어난 성능을 보였고 T는 개수가 많으면 많을수록 성능이 향상되는 추이를 보였습니다.

PD-refinement 에서는 fixed stride를 통해 non-overlapping masking 을 진행하기 때문에 $T$ 가 4로 고정되지만 $R^3$ 에서는 $T$ 에 대한 없다는 점 또한 장점이 될 수 있습니다.

Architecture

Results

[논문리뷰] IDR: Self-Supervised Image Denoising via Iterative Data Refinement

Sat, 20 May 2023 20:51:00 GMT

Paper

GitHub - zhangyi-3/IDR: Self-Supervised Image Denoising via Iterative Data Refinement (CVPR2022)

Introduction

Image denoising task에 있어서, noise image와 clean image의 pair를 취득하는것은 매우 까다롭고 high-cost인 작업입니다.

그렇기 때문에 noise image들만 사용하여 pair를 구성하여 학습하는 noise2noise와 같은 방법론이 소개되었습니다.

하지만 noise image pair를 얻는 것 또한 완벽하게 align된 scene을 새롭게 취득해야하기 때문에 쉬운 일이 아닙니다.

이를 해결하고자 noise2self, noise2void, neighbor2neighbor 등 single noisy image만을 사용하여 self-supervised learning을 하려는 연구가 계속해서 존재하였지만, 만족스럽지 못한 결과를 보여주었습니다.

최근에는 noise image에 synthetic noise를 더하여 noisier - noise image를 pair로 학습하는 Noisier2Noise 라는 방법이 소개되었고, 이전의 연구보다 성능이 뛰어나며 noise2noise나 noise-clean image로 학습한 결과에도 뒤떨어지지 않는 결과를 보여주었습니다.

해당 방법을 사용하여 학습하면 synthetic noise와 비슷한 분포의 noise는 매우 잘 없어지지만, 실제 noisy-clean image와 noisier-noise data 사이에 존재하는 일종의 “data bias” 때문에 actual noise에 대해서는 매우 떨어지는 성능을 보이게 됩니다.

따라서 IDR 논문에서는, 기존 noisier2noise 방법론에 더해서 학습에 있어서 noisy-clean image와 noisier-noisy pair 사이의 data bias를 줄이기 위한 방법을 제시합니다.

Methods

Pilot Study on Data Bias

noisier2noise 방법으로 모델을 학습했을 때 actual noise $x$ 에 대해서는 성능이 좋지 않은 이유가 data bias 때문이라고 가정하고 이를 확인하기 위해 선행연구를 진행하였습니다.

clean image $y$ 에 대해서 noise image $x:=y+n$ 과 noisier image $x+n$ 을 생성하였고, $\{{y_i+n_i, y_i}\}, \{{x_i+n_i, x_i}\}$ 에 대해서 U-net을 학습하고, 학습을 마친 모델에 대해서 noise image를 inference하여 결과를 분석하였습니다.

우선 noisier-noisy dataset 으로 학습했을 때 actual noise에 대한 denoising 성능을 확인하기 위해 Gaussian, Raw, Correlated noise에 대해서 각각 학습을 진행하였습니다.

모든 noise type에 대해서 clean image와의 PSNR을 구해봤을 때, 모델을 통과하지 않은 noisy image보다 높은 PSNR를 보여주었기 때문에 다음과 같은 결론을 얻을 수 있습니다.

Finding (1): noisier-noisy dataset으로 학습한 모델이 actual noise에 대해서도 denoising을 할 수 있다.

다음으로는 data bias가 denoising에 어떠한 영향을 미치는지 알아보기 위해서 기존 $\{{y_i+n_i, y_i}\},$ 로 학습한 모델에 임의로 gaussian noise, blur를 주어 data bias를 만든 후 inference를 진행하였습니다.

모든 noise type에 대해서 gaussian의 $\sigma$ 값이 커지는것에 비례하여 기존의 결과보다 PSNR Drop 이 일어나는것을 확인할 수 있었고, 따라서 다음과 같은 결론을 얻을 수 있습니다.

Finding (2): ideal noisy-clean dataset과 비교하였을때 더 적은 biased dataset에 대해서 학습된 모델이 더 좋은 denoising 성능을 갖는다.

이 두가지 findings를 통해서, noisier-noisy 와 noisy-clean dataset의 data bias 줄이는것을 통해 denoising 성능의 향상을 이끌어낼 수 있다는것을 알 수 있습니다.

논문에서는 data bias를 줄이기 위한 방법으로 Iterative Data Refinement (IDR) 을 제시합니다.

우선, noisier-noise dataset $\{{x_i+n_i, x_i}\}$ 으로 model $\mathcal{F_0}$ 를 학습합니다.

Finding(1) 에 따르면, 이렇게 학습된 모델도 actual noisy image에 대해서도 어느 정도의 denoising을 할 수 있습니다.

따라서 $\mathcal{F_0}$ 에 noisy image $x_i$ 를 통과시켜 refined noisy image $\mathcal{F_0}(x_i)$ 를 얻습니다.

얻은 refined noisy image에 다시 임의의 synthetic noise $n_i$ 를 더해 새로운 noisier image $\mathcal{F_0}(x_i)+n_i$ 를 얻어 최종적으로 refined trainning dataset:

\{\mathcal{F_0}(x_i) + n_i, \mathcal{F_0}(x_i)\}

를 얻게됩니다.

이렇게 새롭게 구성된 dataset으로 다음 stage의 모델 $\mathcal{F_1}$ 을 학습하게 되면, ideal noisy-clean dataset과의 bias가 줄어들었기 때문에 더 좋은 denoising 성능을 가진 model을 학습할 수 있게 됩니다.

\mathcal{F_{m+1}}←\{\mathcal{F_m}(x_i)+n_i,\mathcal{F_m}(x_i)\}

이 과정을 반복적으로 수행하면 점점 더 data bias가 줄어든 새로운 dataset을 구성할 수 있고, denoising 성능도 따라서 향상되게 됩니다.

기존에 존재하는 iterative method와 달리, IDR은 inference 과정에서 한 번만 denoising을 하기 때문에 detail이 심하게 사라지는 문제점또한 없는것이 장점이라고 할 수 있습니다.

위에서 소개한 학습 방법론대로라면, 매 round 마다 초기화된 model을 새로 학습해야하기 떄문에 training time이 매우 오래걸린다는 단점이 있습니다.

논문에서는 이를 해결하기 위한 대안 2가지를 제시합니다.

1) One-epoch training

Refined dataset $\{\mathcal{F_m}(x_i)+n_i,\mathcal{F_m}(x_i)\}$ 에 대해서 1 epoch만 학습하는 방식입니다. dataset의 한 cycle이 끝나면, 그 당시의 model state를 고정시키고 next stage의 refined dataset 를 생성하고, $\mathcal{F_{m+1}}$ 를 학습할때 사용합니다.

이 방법을 사용하면 새로운 refined dataset을 생성하는 시간의 overhead가 생기지만, 이 시간은 전체 training time 대비 5% 정도만 차지하기 때문에 무시 가능한 수준입니다.

해당 방법을 사용하여 학습할 시 기존 full training 에서의 한 round 시간만에 전체 학습을 끝낼 수 있습니다.

2) Share model wieghts

두번째 방법은 model weight를 공유하는것입니다. 기존의 방법에서는 round가 새로 시작될때마다 model weight를 초기화하고 학습을 시작합니다.

따라서 각 round 마다 model이 안정적으로 학습되기 위한 epoch수가 많이 필요하게 됩니다.

그렇기 때문에 weight를 초기화하는 대신, 이전 round에서 model의 weight를 불러와 학습을 시작하면 각 round에서 학습이 완료되는데 필요한 epoch가 크게 줄어들게됩니다.

특히 one-epoch training에 대한 실험 결과 table을 보면, 1 round의 시간만에 full training과 비슷한 denoising 성능을 내는것을 확인할 수 있습니다.

Experiments

Gaussian, Binomial, Impulse, Correlated noise, Real noise에 대해서 실험을 하였습니다.

Gaussian

Binomial, Impulse (non zero-mean)

Correlated kernel

Real noise

Custom Data

gaussian noise를 더해서 학습하였을 때 train noise인 gaussian noise 뿐만 아니라 ISP noise와 JPEG compression artifact 등 다른 type의 noise 또한 denoising 되는것을 확인할 수 있습니다.

Conclusions

Denoising에서 큰 cost로 존재하는 dataset에 있어서 single noisy image만 가지고 학습을 진행할 수 있다는 점에서 큰 이점을 줍니다.

기존의 self-supervised denoising과 비교하여, n2n이나 n2c 학습과 비교해도 뒤떨어지지 않는 퍼포먼스를 보여주는것에서 의의가 있다고 볼 수 있습니다.

또한 self-supervised 방식으로 인해 black box로 학습이 되기 때문에, 의도하지 않았던 추가적인 noise pattern 또한 denoising이 되는 효과도 직접 진행한 실험에서 관찰되었습니다.

다만 Real noise에 있어서, 더해주는 synthetic noise와 real noise의 distribution이 많이 다를 경우 실제 target인 actual real noise에 대해서는 denoising 능력이 잘 학습되지 않는 경향이 있다는 한계가 있습니다.

[논문리뷰] Noisier2Noise: Learning to Denoise from Unpaired Noisy Data

Fri, 19 May 2023 21:01:00 GMT

Noisier2Noise: Learning to Denoise from Unpaired Noisy Data

Noisier2Noise

Intro

Deep learning image denoising task 에서는 일반적으로 noise image - clean image 를 pair로 갖는 data에 대해서 학습하였습니다.

하지만 이러한 condition의 image pair를 취득하는것은 매우 까다로운 일이기 때문에 Noise2Noise 처럼 noise image들로만 학습하는 방법론이 소개되었습니다.

Nooisier2Noise 에서는 더 나아가 pair data가 필요 없는 single noise image로 denoising network를 학습하는 방법을 제시합니다.

Method

Random distribution $\mathcal{A}$ 로부터 얻어진 random variable $M,N$ 이 있다고 가정해봅시다.

$Z=M+N$ 에 대해서 $N$ 을 예측한다고 할 때, $N$ 의 근사값 $\mathbb{E}[N|Z]$ 를 구하는것에 있어 $M, N$ 는 같은 distribution $\mathcal{A}$ 로부터 얻어졌기 때문에 각각 추측된 값에 대한 그 반대 조합도 symmetric 하게 존재합니다.

결국 두 추측값의 평균은 $N=M=\frac{z}{2}$ 가 될것이며, 이것이 Noisier2Noise에 있어서 핵심적인 포인트입니다.

위의 과정을 두개의 i.i.d noise sample 에도 그대로 적용할 수 있습니다.

i.i.d noise sample $M, N$ 에 대해서 $Z=M+N$ 이라고 할 때, 주어진 unknown quantity $x$ 에 대해서 $x+Z$ 를 가지고 $x+N$ 을 예측한다고 가정해봅니다.

그렇다면 최적 예측값은 마찬가지로 $x+\frac{Z}{2}$ 에 수렴할것이고, 이것은 $x, x+Z$ 의 중간값 입니다. 그러므로 이 값들을 통해서 $x$ 를 근사할 수 있습니다.

중요한 것은, 이러한 점을 그대로 Image denoising의 관점에 대입할 수 있다는 것입니다.

Clean image $x$ , Noise image $x+N$ , Noisier image $x+N+M=x+Z$ 이라고 할때, 우리는 noisy image $x+N$ 과 같은 noise distribution을 추가해 만든 noisier image $x+Z$ 를 통해 clean image $x$ 를 구할 수 있다는 결론을 도출할 수 있습니다.

Noisier2Noise는 noise image $Y=X+N$ , noisier image $Z=Y+M$ 라고 할 때, noisier Input $Z$ 를 통해서 noise image $Y$ 를 예측하는 task입니다.

natural image distribution $\mathcal{X}$ 에 대한 $X\sim\mathcal{X}$ 가 존재할때, $X$ 를 직접 볼 수 없지만 known noise distribution $\mathcal{A}$ 에 대한 noise $N\sim\mathcal{A}$ 이 추가된 $Y=X+N$ 은 얻을 수 있습니다. $\mathcal{A}$ 가 known distribution이므로, synthetic noise sample $M\sim\mathcal{A}$ 을 생성하여 noisier image $Z$ 를 합성할 수 있습니다.

이것을 Deep learning process에 도입하여 $L_2$ loss 를 사용하여 neural network $f(;\theta)$ 를 통해 input $Z$ 로 $Y$ 를 예측하는 과정을 아래와 같이 정의할 수 있습니다.

\argmin_\theta\mathbb{E}[\parallel f(Z;\theta)-Y \parallel_2]

Loss function을 최소화 하는 가장 좋은 정답은 $Z$ 에서 정확히 $M$ 을 구해서 빼주는것이지만, network는 $N, M$ 중 어떠한 것도 관찰하지 못했기 때문에 불가능하며, $\mathbb{E}[Y|Z]$ 를 근사하는것이 최선이라고 할 수 있습니다.

이 때, $M,N$ 이 i.i.d 이기 때문에 $\mathbb{E}[M|Z] = \mathbb{E}[N|Z]$ 이므로 아래와 같은 식을 유도할 수 있습니다.

위의 식을 통해서 $\mathbb{E}[X|Z]=2\mathbb{E}[Y|Z]-Z$ ,즉 Model의 Output * 2 - Input 을 통해서 clean image $x$ 를 구할 수 있다는것을 알 수 있습니다.

$\mathbb{E}[X|Z]$ 가 정확한 true image로 reconstruct된다는 것은 보장할 수 없지만, 적어도 clean images 후보들의 mean으로 향하게될것이고, 이는 noise 2 clean 의 학습에 있어서도 마찬가지 현상입니다.

아래의 과정을 통해서 앞에서 설명한 가정이 올바름을 확인할 수 있습니다.

Augmented Input $z$ 를 network에 통과시켜 $f(z;\theta)$ 를 얻습니다. $f(z;\theta)$ 는 clean image $x$ 가 아니라 $x$ 와 $x+n$ (noisy) 의 중간으로 가기 때문에 아직 noise가 남아있는것을 확인할 수 있습니다.
$z-f(z;\theta)$ 를 통해 남아있는 estimate noise 를 얻습니다. noise의 양상을 통해 이 noise의 표준편차가 $\frac{\sqrt{2}\sigma}{2}$ 를 따른다고 추측할 수 있습니다.
위의 noise를 $f(z;\theta)$ 에 빼주어 $2f(z;\theta) - z$ = Output * 2 - Input 을 계산합니다.
최종적으로 Reconstruct된 estimate clean image 를 확인할 수 있습니다.

Improvement

Noisier2Noise 방법으로 학습된 model은, Input으로 doubly-noisy (Noisier) image를 받는다는 한계점이 있습니다.

이로인해 model이 원래의 noisy image에 대해서 정확한 참고를 할 수 없기때문에, 저자는 이 문제를 해결하기 위한 두가지의 방법을 제시합니다.

Inference unaugmented (singly) noisy image

간단하게 생각해볼 수 있는 첫번째 방법은, inference 시 image에 추가적인 noise를 더하지 않는것입니다.

model이 random patch image로 학습하기 때문에 어떠한 데이터는 다른 데이터와 비교했을 때 더 적은 noise 를 가지고있을것입니다.

model은 이러한 데이터 또한 denoising 할 수 있는 능력을 학습하기 때문에 image 전체가 더 적은 noise를 가지고 있어도 충분히 denoising 할 수 있다고 가정할 수 있습니다.

하지만 실혐결과, singly-noisy image로 inference 했을 경우 PSNR 수치는 소폭 상승하지만 over-smoothing으로 인해서 detail이 많이 사라지는것을 확인할 수 있었습니다.

Changing noise intensity

두번째 방법은 noisy image보다 더 적은 정도의 noise를 더해주는것입니다.

앞선 과정들에서 우리는 표준편차 $\sigma_\mathcal{A}$ 를 가진 noise distribution $\mathcal{A}$ 에 대해서 synthetic noise $M\sim\mathcal{A}$ 를 생성했습니다.

대신, $\sigma_\mathcal{B} < \sigma_\mathcal{A}$ 인 distribution $\mathcal{B}$ 에 대해서 noise $M \sim \mathcal{B}$ 를 생성하는 방법이 있습니다.

이를 통해서 synthetic noise $M$ 을 통해 image가 왜곡되는 정도가 줄어들고, model은 target noisy image 그 자체에 대해서 참고를 더 많이 할 수 있게 됩니다.

synthetic noise distribution 이 바뀌게 되면 $\mathbb{E}[Y|Z]$ 의 값들도 바뀌게 되는데, 이는 correction step 또한 바뀌어야함을 의미합니다.

$\sigma_\mathcal{B} = \alpha\sigma_{\mathcal{A}}$ , zero-mean인 gaussian $\mathcal{A}, \mathcal{B}$ 에 대해서 correction step은 Lemma 3.1. 로 정리할 수 있습니다.

논문에서는 실험을 통해 $\alpha=0.5$ 일때 general 하게 좋은 성능을 보여주며, fine tuning을 통해 새로운 $\alpha$ 값으로 학습될 수 있다는것을 알아냈습니다.

Experiments

논문에서는 Noise2Noise와 같은 Unet 구조의 network를 사용하여 학습과 테스트를 진행하였습니다.

Noise intensity

각각의 gaussain noise에 $\alpha=0.5$ 를 사용하여 denoising을 했을 때의 결과입니다.

$L_2$ loss의 사용으로 인해서, input에 noise가 많아질수록 증가한 불확실성들의 mean으로 학습이 되기 때문에 detail이 사라지고 smooth 해지는 경향을 보이는것을 확인할 수 있습니다.

Other noises

논문에서는 gaussian noise외에도 bernoulli, structured noise에 대해서도 실험을 하였고, 효과가 있음을 보여주었습니다.

Compare with other models

BM3D, Noise2Noise, Noise2Void 와의 PSNR 비교를 하였습니다. Train data에 대한 requirement가 다르기 때문에 공평한 비교라고 볼수는 없지만, 좋은 성능을 보여주는것을 확인할 수 있습니다.

Discussion

Real noise에 적용하기 위해서는 noise distribution을 알아야 한다는 말인가? 어떻게 알 수 있는가? 만약 synthetic image에만 적용할 수 있으면 굳이 n2n을 놔두고 이걸 쓸 이유가 있는가?
PSNR 비교표에서 singly-noisy image를 inference 한것임. 각 sigma에 대한 visualize된 정확한 결과 비교가 없음.

[논문리뷰] MAE: Masked Autoencoders Are Scalable Vision Learners

Tue, 02 May 2023 20:17:00 GMT

MAE : Masked Autoencoders Are Scalable Vision Learners

Introduction

Deep Learning에서는 지속적으로 더 큰 capability와 capacity를 가진 architecture가 등장함에 따라, 수백만~수억 개의 dataset을 학습할 수 있게 되었고, 어떻게 bias없이 잘 학습할 수 있는지가 중요해졌습니다.

이 글에서는 "Masked Autoencoders Are scalable Vision Learners" 논문에서 소개한 image encoder 가 large-scale vision dataset 을 보다 효율적이고 잘 학습할 수 있게하는 novel architecture; MAE 에 대해 설명합니다.

What is Masked autoencoder

Big data를 deep learning에 잘 학습시킨 케이스를 뽑자면 단연코 NLP의 foundation model들이 있을것입니다.

그 중에서도 BERT는 랜덤하게 input data에서 일정 부분을 masking하고 해당 부분을 예측하는 masked autoencoding 방법을 사용해 self-supervised learning 을 통한 뛰어난 성능에 도달했습니다.

masked autoencoder의 아이디어를 그대로 computer vision에도 적용해보려는 시도는 꾸준하게 있었으나, 항상 NLP만큼의 기대치에는 미치지 못하는 성능을 보여주었습니다.

따라서 논문에서는 우선 어떠한 요소가 vision과 language에 있어서 masked autoencoding이 다르게 작용하게 하는지에 대해서 다음과 같이 분석하였습니다.

Convolution layer의 특성

최근까지 vision model에서는 convolution layer를 쓰는 경우가 대다수였습니다. convolution layer는 regular grid에서 local하게 동작하기 때문에 mask token이나 positional embedding과 같은 'indicator' 의 역할을 하는 특성들을 잘 통합하지 못합니다.

하지만 이러한 점은, 최근 NLP의 transformer구조가 ViT 등을 통해 vision task에도 적용되기 시작하면서 구조적 차이가 좁혀졌다고 볼 수 있습니다.
Information density

language는 인간에 의해 만들어졌고 매우 semantic하고 information-dense한 특성을 가지고 있습니다. 따라서 모델로 하여금 높은 언어적 이해를 강제하여 매우 고차원적인 정보를 바탕으로 masked word 를 추론하도록 유도할 수 있습니다.

하지만 Image는 매우 spatial redundancy한 특징을 가지고 있습니다. 따라서 모델이 context에 대해서 높은 레벨의 이해력을 가지고 있지 않아도 주변의 픽셀 정보로부터 손쉽게 missing patch(mask) 를 추론할 수 있습니다. 따라서 model은 image 자체의 latent representation을 학습하지 않아도 손쉽게 mask를 추론하기 때문에 encoder의 성능 향상이 잘 이루어지지 않게됩니다.
Decoder role

language와 image 를 reconstruction 하는것에 있어서 decoder의 역할이 다르다고 할 수 있습니다. vision decoder는 pixel을 reconstruct하며, pixel은 비교적 낮은 레벨의 semantic information을 가집니다.

반면 NLP decoder에서는 매우 높은 레벨의 semantic information level을 가지고 있는 missing word를 reconstruct하기 때문에 decoder가 MLP 구조처럼 간단한 레이어를 통해서 trivial 한 결과를 만들 수 있습니다.

저자는 vision에서 image decoder의 design이 encoder를 통해 학습되어진 latent representation의 semantic level을 결정하는데에 매우 중요한 역할을 한다는 것을 발견했습니다.

MAE

위의 분석에 근거하여 논문에서는 간단하고 효율적이고 scalable한 masked autoencoder MAE 를 설계합니다.

MAE는 asymmetric encoder-decoder design으로 되어있는 것이 핵심이라고 할 수 있습니다.

encoder는 mask token을 제외한 오직 "visible patch" 에 대해서만 feature를 학습하고,

decoder는 encoder 의 latent representation과 mask token 을 모두 이용해 pixel을 reconstruct하게 됩니다.

이 때, decoder는 lightweight 구조이기 때문에 mask token 전체를 decoder 에서만 사용하게 하는것으로 매우 큰 computation cost 감소 효과를 만들어낼 수 있습니다.

이러한 구조에서 높은 masking ratio 를 가져가게 될수록 encoder에 input으로 들어가게 되는 patch가 적어져서 계산량이 줄어드는 것 뿐 아니라, 위에서 설명한 Information density 에 대한 문제점도 동시에 해결되는 장점이 있습니다.

Masking

Random sampling

Masking 을 sampling하는 방법은 단순합니다. ViT에서 하는것과 같이 image를 patch로 나눈 뒤, uniform distribution에 따라서 input patch와 mask patch 의 subset으로 나눕니다. 이 방법을 통해 center bias가 생기는것을 방지할 수 있습니다.

random sampling 외에도 block, grid 등의 masking strategy를 적용해 보았지만, random sampling을 할 때 보다 너무 쉬워지거나 어려워져서 encoder가 적절한 latent representation을 학습하는데에 방해가 되는 경향을 보였습니다.
Masking ratio

앞서 설명한 asymmetric 구조의 장점을 극대화 하기 위해서는, 결국 높은 masking ratio에도 encoder 가 잘 학습할 수 있는가? 가 관건이 됩니다.

Image의 information density 특성때문에, encoder가 잘 학습하는 masking ratio는 75% 정도로 꽤 높게 측정됩니다. 75%의 수치는 기존 vision에서의 masking 연구 (20% ~ 50%) 와 NLP model (15%~)에 비해서 상당히 높은 수치로 볼 수 있습니다.
Mask token

MAE 구조에서의 키포인트는 encoder에서 mask token을 skip한다는 것이라고 할 수 있습니다. encoder에서 mask token을 학습시에 사용하게 되면 linear probing task에서 14% 가량의 큰 성능 하락을 보였습니다.

무엇보다 masking ratio가 75%정도로 매우 높기때문에, mask token들을 학습에 모두 사용하면 train, inference시의 computational cost또한 수 배 이상 증가하게 됩니다. (self-attention = quadratic increase)

Encoder

Encoder

encoder는 기본적으로 standard ViT 구조를 똑같이 사용합니다. Image를 patch화 하고, positional embedding이 더해진 path token들을 embed하게됩니다.

하지만 약 4분의1 (25%) 정도의 subset에 대해서만 encoder가 처리하기 때문에, computational cost와 memory 사용량을 대폭 줄여 encoder가 더 큰 사이즈로 쉽게 scale 가능하다는 차별점이 있습니다.

Decoder

Decoder

decoder에서는 encoder에서 skip하였던 mask token을 포함하여 full input에 대해서 작동합니다. 이때는 mask token 까지 포함하여 전체 patch에 대해서 다시 positional embedding을 수행하여 decoder가 전체적인 location information을 알 수 있도록 합니다.

또한 decoder 는 encoder 가 학습한 latent representation을 reconstruct 하여 성능을 평가하기 위한 수단으로 사용되기 때문에 decoder는 오직 pre-training 단계에서만 사용되며 encoder와 완전 독립적인 디자인으로 자유롭게 구성할 수 있습니다.
Decoder design

NLP와 달리, image task에서의 output 은 다소 non-tirivial하기 때문에 decoder 또한 여러 블럭의 transformer block들로 구성하였습니다.

실험 결과, fine tuning, 즉 image reconstruction을 수행하는 경우에는 decoder 의 block이 1개라도 충분한 퍼포먼스를 보여주는것을 확인하였습니다.

반면 image recognition이 필요한 linear probing의 경우 decoder 의 block 개수가 퍼포먼스에 직접적인 영향을 주었습니다.

dimension의 경우에도 fine tuning과 linear probing 모두에서 ~512 dimension 정도면 충분히 좋은 결과를 보여주었으며, 이는 encoder의 1024 보다 더 적은 숫자입니다.

따라서 fine-tuning의 용도일 경우 decoder depth는 1개 512 dimension 으로도 충분하며, 이를 통해 좋은 성능과 적은 연산량을 가질 수 있게됩니다.

Experiments

Partial fine-tuning

mask autoencoder 방식으로 fine-tuning을 진행할 때, encoder의 전체 layer가 아니라 마지막 몇개의 layer의 weight만 fine-tuning하더라도 충분히 좋은 결과를 낼 수 있습니다. (24 = whole)

이는 관련 선행 연구와 MAE의 실험에서도 입증되었으며, 해당 내용에 대한 더 자세한 내용은 아래를 참고해주세요.

Jason Yosinski, Jeff Clune, Yoshua Bengio, and Hod Lipson. How transferable are features in deep neural networks? In NeurIPS,
2014.
Richard Zhang, Phillip Isola, and Alexei A Efros. Colorful image colorization. In ECCV, 2016.
Mehdi Noroozi and Paolo Favaro. Unsupervised learning of visual representations by solving jigsaw puzzles. In ECCV, 2016.

Transfer learning

MAE는 detection, segmentation, classification등 다양한 downstream task에도 의미있는 향상을 보여주었습니다.

Conclusions

"Masked Autoencoders Are scalable Vision Learners" 에서는 NLP에서 large scale data를 학습할 때 사용하는 self-supervised learning의 방법을 차용하여 Image model또한 large scale data에 대해서 효율적으로 잘 학습할 수 있는 새로운 방법을 제시하였습니다.

이 방법을 통해서 Vision model또한 방대한 데이터셋에 대해서 self-supervised로 학습을 할 수 있게 되었고, Meta의 "Segment Anything", "Dino" 등의 Foundation 모델에서 수천만개의 real-world image를 encoder에 잘 학습시킨것으로 그 효용성이 입증되었다고 볼 수 있습니다.

또한 이 방법은 특정한 downstream task에 대해서만 적용될 수 있는 것이 아니라, Image encoder 자체의 feature 학습에 도움을 줄 수 있으므로 Vision deep learning에 있어서 의미있는 연구라고 할 수 있습니다.

PyojunCode | Feed

[Mathematics for Machine Learnig] Linear Algebra (2)

1. Linear Algebra - (2)

Vector Space

Group

Vector Spaces

Linear Independence

Linear Combination

Linear (In)dependence

Basis and Rank

Span

Basis

Dimension and Rank

[Mathematics for Machine Learnig] Linear Algebra (1)

1. Linear Algebra - (1)

Matrices

Inverse

Transpose

Compact representation of system of linear equations

Particular Solution

General Solution

Row-Echelon Form

[논문리뷰] FastSpeech 2: Fast and High-Quality End-to-End Text to Speech

FastSpeech2

Abstract

Methods

1. Overall structure

2. Encoder

3. Variance Adaptor

4. FastSpeech2s

Conclusions

Deploy pytorch model with AWS inferentia

Deploy pytorch model with AWS inferentia

What is AWS inferentia?

Pytorch model for inferentia

Create inferentia instance

Login to instance

Install pytorch-neuron dependencies (Inferentia1)

Compile model for inferentia

Define pre/post processing functions

Run inference using neuron model

Run inference using DataParallel (Optional)

Compile with different batch sizes (Optional)

Results

Ref

NVIDIA Jetson TensorRT Inference

NVIDIA Jetson TensorRT Inference

Install torch

Torch to Onnx

Onnx to TRT

TRT Inference

[논문리뷰] Simple Baselines for Image Restoration

Simple Baselines for Image Restoration

Introduction

Inter-block complexity

Intra-block complexity

Simple Baseline Network

Normalization

Activation

Attention

Baseline Network Summary

Nonlinear Activation Free Network

Gated Linear Unit

Simplified Channel Attention

Summary

Conclusions

[논문리뷰] AP-BSN: Self-Supervised Denoising for Real-World Images via Asymmetric PD and Blind-Spot Network

AP-BSN: Self-Supervised Denoising for Real-World Images via Asymmetric PD and Blind-Spot Network

Introduction

BSN and PD

Blind Spot Network

Pixel shuffle down sampling

AP-BSN

Asymmetric PD

Random-replacing refinement

Architecture

Results

[논문리뷰] IDR: Self-Supervised Image Denoising via Iterative Data Refinement

IDR: Self-Supervised Image Denoising via Iterative Data Refinement

Introduction