Minhyeok Lee

Taming Transformers for High-Resolution Image Synthesis

hydragon — Sat, 16 Dec 2023 20:03:21 +0900

VQ-GAN을 이해하기 위해서는 VAE(Variational Auto-Encoder)와 VQ-VAE에 대한 지식이 필요하다.

1. VAE

VAE의 대략적인 구조는 위와 같다. Input image $x$를 인코더에 통과시켜 latent vector $z$를 생성하고, $z$를 다시 디코더에 통과시켜 기존 input $x$와 비슷하지만 새로운 이미지 $x$를 찾아내는 구조이다. 그렇다면 auto-encoder와의 차이점은 무엇인가?

위 그림과 같이 auto-encoder는 특정 입력 이미지를 잘 임베딩 하여 원본 이미지로 복원하는 과정을 학습한다. 즉 feature 추출과 압축을 위한 과정을 학습한다. 반면 VAE는 어떠한 latent space가 원하는 이미지를 만들어 내는지 그 확률 분포를 학습한다. 즉 새로운 이미지 생성을 위한 모델이다.

결과적으로 latent space의 "분포"가 중요하기 때문에 VAE의 인코더는 입력 이미지 $x$를 인코딩한 확률 분포 $q_\phi(\mathbf{z} \mid \mathbf{x})$의 평균 $\mu$와 표준편차 $\sigma$의 값을 학습한다. 반대로 디코더는 latent space $z$를 다시 input $x$로 변환하는 역할을 한다. 만약 입력 이미지로부터 생성된 $z$를 그대로 사용한다면 VAE는 언제나 입력 이미지와 동일한 이미지만 생성이 가능할 것이다. 이러한 문제를 해결하기 위해 가우시안 분포 $N(O,I)$ 를 따르는 노이즈 $\epsilon$을 샘플링하여 새로운 latent space $\mathrm{z}=\mu+\sigma^2 \cdot \epsilon$를 생성한다. 이러한 방법을

reparametererization trick이라고 부르는데, 사실 노이즈를 샘플링하는 과정은 미분이 불가능하기 때문에 학습을 위해 $z$를 이러한 형태로 표현하는 것이다. 결과적으로 디코더는 latent vector $z$가 주어졌을 때 $x$의 분포 $p_\theta(\mathbf{x} \mid \mathbf{z})$를 approximate하는 것을 목적으로 한다. $z$ 주어짐에 따라 다시 데이터 $x$를 generate하는 역할을 하기 때문에 디코더가가 generative model의 역할을 하게 된다.

이제 VAE를 학습하기 위해 maximum likelihood를 적용한다. 이를 수식으로 표현하면 다음과 같다. (마지막 줄은 KL divergence의 정의를 활용한다.)

$$
\begin{aligned}
\log p_\theta(\mathbf{x}) & =\int q_\phi(\mathbf{z} \mid \mathbf{x}) \log p_\theta(\mathbf{x}) d \mathbf{z} \\
& =\int q_\phi(\mathbf{z} \mid \mathbf{x}) \log \frac{p_\theta(\mathbf{x} \mid \mathbf{z}) p(\mathbf{z})}{p_\theta(\mathbf{z} \mid \mathbf{x})} d \mathbf{z} \\
& =\int q_\phi(\mathbf{z} \mid \mathbf{x}) \log \frac{p_\theta(\mathbf{x} \mid \mathbf{z}) p(\mathbf{z})}{p_\theta(\mathbf{z} \mid \mathbf{x})} \frac{q_\phi(\mathbf{z} \mid \mathbf{x})}{q_\phi(\mathbf{z} \mid \mathbf{x})} d \mathbf{z} \\
& =\int q_\phi(\mathbf{z} \mid \mathbf{x}) \log p_\theta(\mathbf{x} \mid \mathbf{z}) d \mathbf{z}-K L\left(q_\phi(\mathbf{z} \mid \mathbf{x}) \| p(\mathbf{z})\right)+K L\left(q_\phi(\mathbf{z} \mid \mathbf{x}) \| p_\theta(\mathbf{z} \mid \mathbf{x})\right)
\end{aligned}
$$

마지막 식에서 첫째 항은 인코더로부터 $z$를 sampling하고, 다시 이 $z$로부터 디코더를 활용해서 $p_\theta(\mathbf{x} \mid \mathbf{z})$를 계산함으로써 구할수 있다. 그리고 두 번째 항은 $q$와 $p$가 둘 다 정규분포이기 때문에, 정규분포 두 개 사이의 KL divergence는 쉽게 계산이 가능하다. 하지만 세 번째 항은 우리가 $p_\theta(\mathbf{z} \mid \mathbf{x})$ 를 알 수가 없기 때문에 계산하는 것이 불가능하다. 하지만 우리는 KL divergence가 항상 양수라는 것을 안다. 그래서 우리는 마지막 식을 다음과 같은 부등식으로 표현할 수 있다. 이것이 그 유명한 (evidence lower bound, ELBO이다.)

$$
\begin{aligned}
& =\int q_\phi(\mathbf{z} \mid \mathbf{x}) \log p_\theta(\mathbf{x} \mid \mathbf{z}) d \mathbf{z}-K L\left(q_\phi(\mathbf{z} \mid \mathbf{x}) \| p(\mathbf{z})\right)+K L\left(q_\phi(\mathbf{z} \mid \mathbf{x}) \| p_\theta(\mathbf{z} \mid \mathbf{x})\right) \\
& \geq \int q_\phi(\mathbf{z} \mid \mathbf{x}) \log p_\theta(\mathbf{x} \mid \mathbf{z}) d \mathbf{z}-K L\left(q_\phi(\mathbf{z} \mid \mathbf{x}) \| p(\mathbf{z})\right) \longleftarrow \text { Evidence lower bound (ELBO) }
\end{aligned}
$$

2. VQ-VAE (Vector Quantization Variational Auto Encoder)

위 그림과 같이 VQ-VAE는 기존 VAE에 discrete 한 codebook을 추가한 버전이다. 인코더의 출력으로 어떤 벡터가 나오면, codebook의 모든 벡터들 간 거리를 계산한다. Codebook의 벡터들 중 인코더의 출력 벡터와 가장 거리가 짧은 벡터를 찾고, 그 벡터를 디코더에 넣어 학습하는 구조이다. 위 그림을 참고하면 다음과 같은 수식으로 계산된다.

$z_q(x)=e_k, \quad \text { where } \quad k=\operatorname{argmin}_j\left\|z_e(x)-e_j\right\|_2$

문제는 위 식이 미분 불가능함으로 gradient를 계산할 수 없다는 것이다. 대신 straight-through estimator와 비슷한 방법을 사용하여 gradient를 근사할 수 있다. 좀 더 자세히 설명하면 디코더 입력인 $z_q(x)$의 gradient를 인코더의 출력 쪽으로 gradient 복사하면 된다는 것이다. 따라서 전체 loss function은 다음과 같다.

$L=\log p\left(x \mid z_q(x)\right)+\left\|\operatorname{sg}\left[z_e(x)\right]-e\right\|_2^2+\beta\left\|z_e(x)-\operatorname{sg}[e]\right\|_2^2$

첫 번째 항은 reconstruction loss로 위에서 설명한 estimator를 통해 decoder와 encoder를 모두 최적화한다. 임베딩 $e_i$는 어떤 gradient도 받지 못하기 때문에 Vector Quantisation(VQ)를 사용한다. 두 번째 항의 VQ objective는 각 $e$를 인코더의 출력 $z_e(x)$로 이동하게끔 한다. 마지막으로 embedding space는 무한하기 때문에 $e_{i}$ 는 인코더 parameter만큼 빠르게 학습되지 않을 수 있다. 인코더가 embedding과 출력이 grow할 수 있게 만들기 위해 3번째 항 commitment loss를 추가한다.

3. VQ-GAN

마지막으로 VQ-VAE의 GAN 확장 버전인 VQ-GAN의 구조는 위와 같다. 그림과 같이 VQ-GAN은 VQ-VAE와 거의 동일한 구조를 가지지만 몇가지 차이점이 있다.

VQ-VAE와 달리 adversarial learning을 사용하여 학습을 진행한다. VQ-VAE 처럼 Encoder에서 나온 vector 값과 codebook 간의 유클리디안 distance를 비교한 후 distance가 가장 작은 vector 들의 값으로 quantized vector를 구성한다. 이렇게 생성한 feature를 디코더에 넣어 reconstruction image를 생성한다. 그리고 이를 discriminator에 넣어 patch 단위로 real인지 fake인지 판단한다.
Code book에 transformer를 추가하여 codebook의 index를 전에 나왔던 값을 기반으로 auto-regressive 하게 예측한다. $i$ 번째 보다 작은 값들을 이용하여 $i$ 번째의 index를 예측하는 것이다. 따라서 이렇게 예측한 $i$ 번째 index 값을 codebook 과 mapping 하여 생성하는 이미지 다음 patch vector를 구성한다.

위와 같이 구성된 이유는 일반적으로 CNN은 local 정보에, transformer는 global 정보에 특화 되어있기 때문에 CNN을 통해 각 영역별 $z$를 추출하고 transformer로 전체 순서를 예측한다.

VQ-GAN의 loss function은 아래와 같다. VQ-VAE와 거의 동일하다.

\begin{aligned}
\mathcal{L}_{\mathrm{VQ}}(E, G, \mathcal{Z})=\|x-\hat{x}\|^2 & +\left\|\operatorname{sg}[E(x)]-z_{\mathbf{q}}\right\|_2^2+\beta\left\|\operatorname{sg}\left[z_{\mathbf{q}}\right]-E(x)\right\|_2^2
\end{aligned}

GAN loss는 다음과 같다.

$\mathcal{L}_{\mathrm{GAN}}(\{E, G, \mathcal{Z}\}, D)=[\log D(x)+\log (1-D(\hat{x}))]$

따라서 전체 loss는 다음과 같다.

\begin{aligned}
& \mathcal{Q}^*=\underset{E, G, \mathcal{Z}}{\arg \min } \max _D \mathbb{E}_{x \sim p(x)}\left[\mathcal{L}_{\mathrm{VQ}}(E, G, \mathcal{Z})+\lambda \mathcal{L}_{\mathrm{GAN}}(\{E, G, \mathcal{Z}\}, D)\right]
\end{aligned}

이때 $\lambda$는 adaptive weight로 두 loss 간의 균형을 맞추는 값이다. 이는 다음과 같이 정의된다.

$\lambda=\frac{\nabla_{G_L}\left[\mathcal{L}_{\mathrm{rec}}\right]}{\nabla_{G_L}\left[\mathcal{L}_{\mathrm{GAN}}\right]+\delta}$

DDPM: Denoising Diffusion Probabilistic Model

hydragon — Wed, 29 Nov 2023 18:37:25 +0900

DDPM이 무엇인지는 너무 유명하니 패스한다. DDPM에서 설명하는 diffusion 방식은 아래 그림과 같다.

먼저 DDPM은 이미지에 작은 가우시안 노이즈를 더하는 과정의 역과정 (즉 노이즈를 제거하는 과정) 역시 가우시안 분포로 모델링이 가능하다는 가정으로 시작한다. 즉 다시 말하면 normal distribution에 대한 노이즈가 주어졌을 때 이를 어떻게 복원할 것인가에 대한 문제를 모델이 해결하는 것이다.

먼저 $t$ 시간 이미지 $X_t$에 노이즈 $I$를 더하는 과정의 확률분포 $q \left ( X _ { t } \mid X _ { t-1 } \right ) $는 다음과 같다.

$q \left ( X _ { t } \mid X _ { t-1 } \right ) = \mathcal{N} \left ( X _ { t } ; \sqrt { 1- \beta _ { t } } X _ { t-1 } , \beta _ { t } I \right )$

$ \beta _ { t } $는 $t$ 시간에서 이미지에 노이즈를 얼마나 더할지에 대한 값이다. 먼저 $ \mathcal{N} \left ( X _ { t } ; \sqrt { 1- \beta _ { t } } X _ { t-1 } , \beta _ { t } I \right )$와 같은 꼴로 표현한 이유를 간단하게 설명하자면

$Var \left ( ax \right ) =a ^ { 2 } Var \left ( x \right )$

$Var \left ( x+y \right ) =Var \left ( x \right ) +Var \left ( y \right )$

의 variance 성질을 사용하면

$Var \left ( \sqrt { 1- \beta _ { t } } X _ { t } + \beta _ { t } \right ) =Var \left ( \left ( \sqrt { 1- \beta _ { t } } \right ) ^ { 2 } + \beta _ { t } \right ) =Var \left ( 1 \right )$

으로 전체 variance를 항상 1로 고정할 수 있기 때문이다. 이 값은 learnable parameter로 둘 수도 있지만, 실험을 해보니 상수로 두어도 큰 차이가 없어서 constant로 두었다고 한다. 논문에서는 $t$에따라 $10^-4$에서 $0.02$로 linear하게 증가시킨다.

이제 만약 최초의 이미지 $X_0$을 알고 있을때 $T$ 시간 이후의 최종 $X_T$에 대한 확률 분포 $ q\left(X_{1: T} \mid X_0\right)$ 는 다음과 같이 표현이 가능하다.

$q\left(X_{1: T} \mid X_0\right)=\prod_{t=1}^T q\left(X_t \mid X_{t-1}\right)$

이 수식이 만족하는 이유는 먼저

$q\left(x_{1: T} \mid x_0\right)=\frac{q\left(x_0, x_1, x_2, x_3, \ldots, x_T\right)}{q\left(x_0\right)}$

이고

$\prod_{t=1}^T q\left(x_t \mid x_{t-1}\right)=q\left(x_1 \mid x_0\right) q\left(x_2 \mid x_1\right) q\left(x_3 \mid x_2\right) \ldots q\left(x_T \mid x_{T-1}\right)$

으로 정의됨을 이용하면 Marcov chain에 의해

\begin{aligned}
& q\left(x_1 \mid x_0\right) q\left(x_2 \mid x_1\right) q\left(x_3 \mid x_2\right) \ldots q\left(x_T \mid x_{T-1}\right)=\frac{q\left(x_1, x_0\right)}{x_0} \frac{q\left(x_2, x_1\right)}{x_1} \ldots \frac{q\left(x_T, x_{T-1}\right)}{x_{T-1}} \\
& =\frac{q\left(x_1, x_0\right)}{x_0} \frac{q\left(x_2, x_1, x_0\right)}{x_1, x_0} \ldots \frac{q\left(x_T, x_{T-1}, \ldots, x_1, x_0\right)}{x_{T-1}, \ldots, x_0} \\
& =\frac{q\left(x_0, x_1, x_2, x_3, \ldots, x_T\right)}{q\left(x_0\right)}
\end{aligned}

임이 성립한다.

사실 $t$번의 sampling을 통해 매 step을 차근차근 밟아가면서 $X_0$에서 $X_t$를 만들 수도 있지만, 한 번에 $X_0$에서 $X_t$를 만들 수도 있다. 만약 $\bar{\alpha}_t=\prod_{s=1}^t\left(1-\beta_s\right)$라고 한다면

$\left.q\left(\mathbf{x}_t \mid \mathbf{x}_0\right)=\mathcal{N}\left(\mathbf{x}_t ; \sqrt{\bar{\alpha}_t} \mathbf{x}_0,\left(1-\bar{\alpha}_t\right) \mathbf{I}\right)\right)$

라고 표현되며 이를 정리하면

$\mathbf{x}_t=\sqrt{\bar{\alpha}_t} \mathbf{x}_0+\sqrt{\left(1-\bar{\alpha}_t\right)} \epsilon \quad \text { where } \epsilon \sim \mathcal{N}(\mathbf{0}, \mathbf{I})$

와 동일하다. 이 수식을 증명하자면 먼저

\begin{aligned}
& q\left(x_t \mid x_{t-1}\right) \sim N\left(x_t ; \sqrt{1-\beta_t} x_{t-1}, \beta_t I\right) \\
& \rightarrow x_t=\sqrt{1-\beta_t} x_{t-1}+\sqrt{\beta_t} \varepsilon \quad * \alpha_t=1-\beta_t, \overline{\alpha_t}=\prod_{s=1}^t \alpha_s \\
& =\sqrt{\alpha_t} x_{t-1}+\sqrt{1-\alpha_t} \varepsilon_{t-1} \\
& =\sqrt{\alpha_t}\left(\sqrt{\alpha_{t-1}} x_{t-2}+\sqrt{1-\alpha_{t-1}} \varepsilon_{t-2}\right)+\sqrt{1-\alpha_t} \varepsilon_{t-1} \\
& =\sqrt{\alpha_t \cdot \alpha_{t-1}} x_{t-2}+\sqrt{\alpha_t} \sqrt{1-\alpha_{t-1}} \varepsilon_{t-2}+\sqrt{1-\alpha_t} \varepsilon_{t-1}
\end{aligned}

인데

\begin{aligned}
\sqrt{\alpha_t} & \sqrt{1-\alpha_{t-1}} \varepsilon_{t-2}+\sqrt{1-\alpha_t} \varepsilon_{t-1} \\
& \sim N\left(0,\left[\alpha_t\left(1-\alpha_{t-1}\right)+\left(1-\alpha_t\right)\right] I\right) \\
:= & \sqrt{\left(1-\alpha_t\right)+d_t\left(1-\alpha_{t-1}\right)}=\sqrt{1-\alpha_t \alpha_{t-1}}
\end{aligned}

이므로

\begin{aligned}
x_t=\sqrt{\alpha_t \alpha_{t-1}} x_{t-2}+\sqrt{1-\alpha_t \alpha_{t-1}} \bar{\varepsilon}_{t-2}=\sqrt{\bar{a}_t} x_0+\sqrt{1-\bar{\alpha}_t} \varepsilon \\
\therefore q\left(x_t \mid x_0\right)=N\left(x_t ; \sqrt{\alpha_t} x_0,\left(1-\bar{\alpha}_t\right) I\right)
\end{aligned}

로 증명이 가능하다. 달리 말하면 이론상 $\bar{\alpha}_T \rightarrow 0$ 인 경우 $\left.q\left(\mathbf{x}_T \mid \mathbf{x}_0\right) \approx \mathcal{N}\left(\mathbf{x}_T ; \mathbf{0}, \mathbf{I}\right)\right)$으로 근사할 수 있다. 한 step씩 학습을 하면 메모리와 resource가 너무 많이 들기 때문에 이렇게 한 번에 계산한다고 논문은 표현한다.

다음으로 노이즈로부터 이미지를 복원하는 즉 generative 과정이다. 우선 $p\left(\mathbf{x}_T\right)=\mathcal{N}\left(\mathbf{x}_T ; \mathbf{0}, \mathbf{I}\right)$라고 한다면, 임의의 $t$시간에서 $t-1$시간으로의 복원 확률 분포는 다음과 같다.

$p_\theta\left(\mathbf{x}_{t-1} \mid \mathbf{x}_t\right)=\mathcal{N}\left(\mathbf{x}_{t-1} ; \mu_\theta\left(\mathbf{x}_t, t\right), \sigma_t^2 \mathbf{I}\right)$

이때 $\mu_\theta\left(\mathbf{x}_t, t\right)$는 U-net, Denoising Autoencoder과 같은 학습 가능한 모델이다.

이제 학습을 적용할 차례이다. 대부분의 오토 인코더가 그렇듯 negative log likelihood를 최소화 하는 방식을 논문은 사용한다. 이를 수식으로 표현하면 다음과 같다.

$\mathbb{E}\left[-\log p_\theta\left(\mathbf{x}_0\right)\right] \leq \mathbb{E}_q\left[-\log \frac{p_\theta\left(\mathbf{x}_{0: T}\right)}{q\left(\mathbf{x}_{1: T} \mid \mathbf{x}_0\right)}\right]=\mathbb{E}_q\left[-\log p\left(\mathbf{x}_T\right)-\sum_{t \geq 1} \log \frac{p_\theta\left(\mathbf{x}_{t-1} \mid \mathbf{x}_t\right)}{q\left(\mathbf{x}_t \mid \mathbf{x}_{t-1}\right)}\right]=: L$

이를 증명하는 방법은 비교적 간단하다. 먼저 bayes rule에 의해 $p_\theta\left(x_T \mid x_0\right)=\frac{p_\theta\left(x_T, x_0\right)}{p_\theta\left(x_0\right)}$ 이므로

\begin{aligned}
& \mathbb{E}_{x_T \sim q\left(x_T \mid x_0\right)}\left[-\log p_\theta\left(x_0\right)\right]=\mathbb{E}_{x_T \sim q\left(x_T \mid x_0\right)}\left[-\log \frac{p_\theta\left(x_0, x_1, x_2, \ldots, x_T\right)}{p_\theta\left(x_1, x_2, x_3, \ldots, x_T \mid x_0\right)}\right]
\end{aligned}
이고 이 식은

$=\mathbb{E}_{x_T \sim q\left(x_T \mid x_0\right)}\left[-\log \frac{p_\theta\left(x_0, x_1, x_2, \ldots, x_T\right)}{p_\theta\left(x_1, x_2, x_3, \ldots, x_T \mid x_0\right)} \cdot \frac{q\left(x_{1: T} \mid x_0\right)}{q\left(x_{1: T} \mid x_0\right)}\right]$

으로 바꿔서 표현이 가능하다. 이제 Evidence of Lower BOund (ELBO)를 적용하면 KL divergence가 양수임을 이용하여

$\leq \mathbb{E}_{x_T \sim q\left(x_T \mid x_0\right)}\left[-\log \frac{p_\theta\left(x_0, x_1, x_2, \ldots, x_T\right)}{q\left(x_{1: T} \mid x_0\right)}\right]$

$=\mathbb{E}_{x_T \sim q\left(x_T \mid x_0\right)}\left[-\log \frac{p_\theta\left(x_{0 ; T}\right)}{q\left(x_{1 ; T} \mid x_0\right)}\right]$

이다. 이제 $p_\theta\left(\boldsymbol{x}_{0: T}\right):=p_\theta\left(\boldsymbol{x}_T\right) \prod_{t=1}^T p_\theta\left(\boldsymbol{x}_{t-1} \mid \boldsymbol{x}_t\right) \quad q\left(\boldsymbol{x}_{\mathbf{1}: T} \mid \boldsymbol{x}_0\right):=\prod_{t=1}^T q\left(\boldsymbol{x}_t \mid \boldsymbol{x}_{t-1}\right)$인 Markov property를 적용하면 (어떤 시간에 특정 state에 도달하든 그 이전에 어떤 state를 거쳐왔든 다음 state로 갈 확률은 항상 같다는 성질)

\begin{aligned}
&=\mathbb{E}_{x_T \sim q\left(x_T \mid x_0\right)}\left[-\log \frac{p_\theta\left(\boldsymbol{x}_T\right) \prod_{t=1}^T p_\theta\left(\boldsymbol{x}_{\boldsymbol{t}-1} \mid \boldsymbol{x}_{\boldsymbol{t}}\right)}{\prod_{t=1}^T q\left(\boldsymbol{x}_{\boldsymbol{t}} \mid \boldsymbol{x}_{\boldsymbol{t}-1}\right)}\right]\\
&=\mathbb{E}_{x_{1: T} \sim q\left(x_{1: T} \mid x_0\right)}\left[-\log p_\theta\left(\boldsymbol{x}_T\right)-\sum_{t=1}^T \log \frac{p_\theta\left(x_{t-1} \mid x_t\right)}{q\left(x_t \mid x_{t-1}\right)}\right]
\end{aligned}

으로 증명된다. 이 loss function의 우항을 좀 더 정리하면

$\mathbb{E}_q[\underbrace{D_{\mathrm{KL}}\left(q\left(\mathbf{x}_T \mid \mathbf{x}_0\right) \| p_\theta \left(\mathbf{x}_T\right)\right)}_{L_T}+\sum_{t>1} \underbrace{D_{\mathrm{KL}}\left(q\left(\mathbf{x}_{t-1} \mid \mathbf{x}_t, \mathbf{x}_0\right) \| p_\theta\left(\mathbf{x}_{t-1} \mid \mathbf{x}_t\right)\right)}_{L_{t-1}} \underbrace{-\log p_\theta\left(\mathbf{x}_0 \mid \mathbf{x}_1\right)}_{L_0}]$

와 같은 최종적인 loss function을 얻을 수 있다.

이제 loss의 각각의 항에 대해 설명을 해본다. 먼저 첫 번째 항인 $L_T=D_{K L}\left(q\left(x_T \mid x_0\right) \| p_\theta \left(x_T\right)\right)$는 $p_\theta $가 생성하는 노이즈 이미지, $x_0$로부터 $q$가 생성하는 노이즈 이미지 간의 분포 차이이다. 물론 각 분포는 아래와 같이 정의된다.

\begin{aligned}
& q\left(x_t \mid x_0\right)=\mathcal{N}\left(x_t ; \sqrt{\bar{\alpha}_t} x_0,\left(1-\bar{\alpha}_t\right) \mathrm{I}\right) \\
& p_\theta\left(x_T\right)=\mathcal{N}\left(x_T ; 0, \mathrm{I}\right)
\end{aligned}

하지만 일반적으로 $q\left(x_T \mid x_0\right)=p_\theta\left(x_T\right)$이기 때문에 (이를 위해 논문은 $\beta_t$를 상수로 둔다.) 이 loss term은 항상 0에 가까운 상수이며, 학습과정에서 무시된다.

두 번째로 $L_{T-1}$는 $p_\theta$와 $q$ 의 reverse, forward process의 분포 차이를 의미한다. 모델은 이들을 최대한 비슷하게 만드는 방향으로 학습된다. $p_\theta$는 모델 출력 부분이니 넘어가고 $q\left(x_{t-1} \mid x_t, x_0\right)$은 $P\left(x_{t-1} \mid x_t\right)=\frac{P\left(x_t \mid x_{t-1}\right) P\left(x_{t-1}\right)}{P\left(x_t\right)}$를 이용하면 $q\left(x_{t-1} \mid x_t, x_0\right)=q\left(x_t \mid x_{t-1}, x_0\right) \frac{q\left(x_{t-1} \mid x_0\right)}{q\left(x_t \mid x_0\right)}$임을 알 수 있다. 마지막으로 역 조건부 확률(inverse conditional probability)에 의해

$q\left(x_{t-1} \mid x_t, x_0\right)=N\left(x_{t-1} ; \tilde{\mu}\left(x_t, x_0\right), \tilde{\beta}_t \mathrm{I}\right)$

\begin{aligned}
& \tilde{\mu}_t\left(x_t, x_0\right):=\frac{\sqrt{\bar{\alpha}_{t-1}} \beta_t}{1-\bar{\alpha}_t} x_0+\frac{\sqrt{\alpha_t}\left(1-\bar{\alpha}_{t-1}\right)}{1-\bar{\alpha} t} x_t, \tilde{\beta}_t:=\frac{\left(1-\bar{\alpha}_{t-1}\right)}{1-\bar{\alpha}_t} \beta_t
\end{aligned}

로 계산할 수 있다.

이제 $L_{T-1}$의 KL divergence를 계산하면

$L_{t-1}=\mathbb{E}_{\mathbf{x}_0 \sim q\left(\mathbf{x}_0\right), \epsilon \sim \mathcal{N}(\mathbf{0}, \mathbf{I})}\left[\frac{\beta_t^2}{2 \sigma_t^2\left(1-\beta_t\right)\left(1-\bar{\alpha}_t\right)}\left\|\epsilon-\epsilon_\theta\left(\sqrt{\bar{\alpha}_t} \mathbf{x}_0+\sqrt{1-\bar{\alpha}_t} \epsilon, t\right)\right\|^2\right]$

로 가능하다.

마지막으로 $L_0$는 $x_1$으로부터 $x_0$를 추정하는 likelihood이다. 모델은 이를 maximize하는 방향으로 학습된다.

이제 전체 loss function을 epsilon에 대한 식의 형태로 simplify가 가능한데 simplify 된 형태가 더 학습이 잘된다고 한다. 식은 다음과 같다.

$L_{\text {simple }}(\theta):=\mathbb{E}_{t, \mathbf{x}_0, \boldsymbol{\epsilon}}\left[\left\|\boldsymbol{\epsilon}-\boldsymbol{\epsilon}_\theta\left(\sqrt{\bar{\alpha}_t} \mathbf{x}_0+\sqrt{1-\bar{\alpha}_t} \boldsymbol{\epsilon}, t\right)\right\|^2\right]$

따라서 학습 부분은 아래와 같이 간단하게 표현된다.

반대로 이미지 생성 (sampling 부분은)

와 같이 표현된다.

Object-Centric Learning with Slot Attention

hydragon — Sat, 25 Mar 2023 18:29:14 +0900

이 논문에서는 CNN을 사용하여 복잡한 장면의 객체 중심 표현(object-centric representation)을 학습하는 새로운 방법을 소개한다. 이 방법 슬롯이라고 하는 task-dependent abstract representation을 생성하는 slot attention module을 사용한다. 이러한 슬롯은 반복적인 attention 과정을 통해 업데이트가 가능하며 모든 입력 feature와 상호작용한다. 이 논문은 slot attention이 unsupervised object discovery 및 supervised property prediction task에 대해 학습할 때 보이지 않는 구성에 대한 일반화를 가능하게 하는 객체 중심 표현을 추출할 수 있음을 보여준다. 또한 이 논문에서는 이 방법을 객체 표현을 위한 기존의 딥러닝 접근 방식과 비교하고 향후 연구 방향을 제시한다.

1. Object-centric learning

객체 중심 학습은 장면이나 환경에 있는 객체의 표현을 학습하는 데 중점을 두는 딥러닝의 한 유형이다. 이 task의 목표는 장면에서 개별 개체를 식별하고 표현함으로써 low-level perceptual feature으로부터 abstract reasoning을 가능하게 하는 것이다. 이 접근 방식은 시각적 추론, 구조화된 환경 모델링, 다중 에이전트 모델링, 상호 작용하는 물리적 시스템 시뮬레이션 등 다양한 애플리케이션 영역에서 머신러닝 알고리즘의 샘플 효율성과 일반화를 개선할 수 있는 잠재력을 가지고 있다. 그러나 이미지나 비디오와 같은 raw perceptual 입력에서 객체 중심의 표현을 얻는 것은 어렵고 supervision 학습 또는 task-specific architecture가 필요한 경우가 많다.

2. Slot attention

슬롯 어텐선의 구현은 아래와 같다. (https://github.com/lucidrains/slot-attention)

import torch
from torch import nn
from torch.nn import init

class SlotAttention(nn.Module):
    def __init__(self, num_slots, dim, iters = 3, eps = 1e-8, hidden_dim = 128):
        super().__init__()
        self.num_slots = num_slots
        self.iters = iters
        self.eps = eps
        self.scale = dim ** -0.5

        self.slots_mu = nn.Parameter(torch.randn(1, 1, dim))

        self.slots_logsigma = nn.Parameter(torch.zeros(1, 1, dim))
        init.xavier_uniform_(self.slots_logsigma)

        self.to_q = nn.Linear(dim, dim)
        self.to_k = nn.Linear(dim, dim)
        self.to_v = nn.Linear(dim, dim)

        self.gru = nn.GRUCell(dim, dim)

        hidden_dim = max(dim, hidden_dim)

        self.mlp = nn.Sequential(
            nn.Linear(dim, hidden_dim),
            nn.ReLU(inplace = True),
            nn.Linear(hidden_dim, dim)
        )

        self.norm_input  = nn.LayerNorm(dim)
        self.norm_slots  = nn.LayerNorm(dim)
        self.norm_pre_ff = nn.LayerNorm(dim)

    def forward(self, inputs, num_slots = None):
        b, n, d, device, dtype = *inputs.shape, inputs.device, inputs.dtype
        n_s = num_slots if num_slots is not None else self.num_slots
        
        mu = self.slots_mu.expand(b, n_s, -1)
        sigma = self.slots_logsigma.exp().expand(b, n_s, -1)

        slots = mu + sigma * torch.randn(mu.shape, device = device, dtype = dtype)

        inputs = self.norm_input(inputs)        
        k, v = self.to_k(inputs), self.to_v(inputs)

        for _ in range(self.iters):
            slots_prev = slots

            slots = self.norm_slots(slots)
            q = self.to_q(slots)

            dots = torch.einsum('bid,bjd->bij', q, k) * self.scale
            attn = dots.softmax(dim=1) + self.eps

            attn = attn / attn.sum(dim=-1, keepdim=True)

            updates = torch.einsum('bjd,bij->bid', v, attn)

            slots = self.gru(
                updates.reshape(-1, d),
                slots_prev.reshape(-1, d)
            )

            slots = slots.reshape(b, -1, d)
            slots = slots + self.mlp(self.norm_pre_ff(slots))

        return slots

기본적으로 "query", "key", "value" 기반의 어텐션 메커니즘을 사용한다. 우선 입력 feature를 key, value로 만들고 랜덤 초기화된 슬롯들을 query로 사용한다. 슬롯 어텐션은 "iters" 만큼 반복되면서 (논문의 경우 3) 슬롯을 점진적으로 업데이트 한다. 입력 및 출력의 크기는 아래 코드를 참고하면 된다.

import torch
from slot_attention import SlotAttention

slot_attn = SlotAttention(
    num_slots = 5,
    dim = 512,
    iters = 3   # iterations of attention, defaults to 3
)

inputs = torch.randn(2, 1024, 512)
slot_attn(inputs) # (2, 5, 512)

논문은 object-centric learning 기반의 세그멘테이션 작업을 수행한다. 결과는 아래와 같다.

각각의 슬롯에는 개별의 물체에 대한 정보가 저장되며 이 과정은 모두 unsupervised로 이루어진다. 이 세그멘테이션 과정이 슬롯으로 부터 어떻게 이루어 지는지는 아래 코드를 보면 쉽게 알수있다. (https://github.com/evelinehong/slot-attention-pytorch)

# Slot Attention module.
slots = self.slot_attention(x)
# `slots` has shape: [batch_size, num_slots, slot_size].

# """Broadcast slot features to a 2D grid and collapse slot dimension.""".
slots = slots.reshape((-1, slots.shape[-1])).unsqueeze(1).unsqueeze(2)
slots = slots.repeat((1, 8, 8, 1))

# `slots` has shape: [batch_size*num_slots, width_init, height_init, slot_size].
x = self.decoder_cnn(slots)
# `x` has shape: [batch_size*num_slots, width, height, num_channels+1].

# Undo combination of slot and batch dimension; split alpha masks.
recons, masks = x.reshape(image.shape[0], -1, x.shape[1], x.shape[2], x.shape[3]).split([3,1], dim=-1)
# `recons` has shape: [batch_size, num_slots, width, height, num_channels].
# `masks` has shape: [batch_size, num_slots, width, height, 1].

# Normalize alpha masks over slots.
masks = nn.Softmax(dim=1)(masks)
recon_combined = torch.sum(recons * masks, dim=1)  # Recombine image.
recon_combined = recon_combined.permute(0,3,1,2)
# `recon_combined` has shape: [batch_size, width, height, num_channels].

처음 모델 그림에서 슬롯 개수 만큼의 여러개의 디코더를 사용하는 것 처럼 표현되어있지만 실은 batch_size x num_slots로 슬롯을 배치 단위로 묶어 연산한다. 모델은 오토 인코더와 유사하게 구성되며 이렇게 하면 3채널의 recons 이미지와 각각에 대한 마스크가 알파 채널로써 생성되는데, recon_combined = torch.sum(recons * masks, dim=1)으로 원래 이미지를 재구성하여 입력 이미지와 loss를 계산한다. 결과적으로 unsupervised로 masks 학습이 가능해진다.

SuperPoint: Self-Supervised Interest Point Detection and Description

hydragon — Wed, 9 Mar 2022 18:27:15 +0900

SuperPoint를 설명하기 앞서 이미지 특징점 (keypoint)란 무엇인지 알아야 한다.

이미지 keypoint이란 말 그대로 이미지에서 특징이 되는 부분을 의미한다. 이미지 매칭 시, 즉 이미지끼리 서로 매칭이 되는지 확인을 할 때 각 이미지에서의 특징이 되는 부분끼리 비교를 한다. 보통 특징점이 되는 부분은 물체의 모서리나 코너인데, 그래서 대부분의 특징점 검출을 코너 검출을 바탕으로 하고 있다.

이러한 keypoint는 크게 samantic keypoint와 interset point로 나뉘는데, samantic keypoint는 그림과 같이 사람의 골격, 물체의 의미론적인 특정 위치를 기반으로 하기 때문에 정의하기가 쉽지만 interset point의 경우 모서리, 꼭짓점과 같은 low-level point들로 의미론적인 정의가 어려워 이를 supervised learning으로 다루는 것이 어렵다.

따라서 이러한 interset point를 러닝으로서 학습하는 SuperPoint는 아래와 같은 단계의 self-supervised learning을 이용해 이러한 문제를 해결한다.

먼저 MagicPoint를 찾는 모델을 pre-training 한다.

먼저 위 그림과 같이 간단한 파이썬 코드를 사용하여 정육면체 선 별 및 바둑판과 같은 간단한 기하학적 모양을 포함하는 합성 데이터 세트를 생성한다. 이 과정으로 label과 함께 기하학적 모양 이미지를 만든다. 이러한 점들을 이용해 MagicPoint라 불리는 Base Detector를 학습시킨다.

문제는 이러한 방법으로 학습된 모델은 합성된 이미지에서는 잘 동작하지만 실제 이미지에서는 일반화가 어렵다는 문제가 있다. 이러한 일반화 문제를 해결하기 위해 저자들은 Homographic Adaptation이라 불리는 multi-scale, multi-transform 기술을 적용한다.

Homographic Adaptation은 Homography에 강인한 interest point를 찾기 위한 과정으로 psuedo ground truth interest point를 찾는 방법이다. 위 그림과 같이 unlabeled 이미지를 다양한 homography를 적용하여 이미지를 변형 시킨다. 이 다음 pre-train된 MagicPoint에 집어넣어 예측 interest point들을 뽑고 이 결과들을 모두 합쳐 (원래 이미지로 역변환을 시킨다.) psuedo ground truth interest point를 생성한다.

이 과정을 합치면 아래 그림과 같다. 이렇게 생성된 interest point들은 MagicPoint 학습에 다시 사용된다.

이제 모델의 전체 구조는 아래와 같다.

SuperPoint는 다수의 이미지 페어들에서 좋은 keypoint matching이 되는 것을 목적이기 때문에 matching이 잘 되는 keypoint만을 추출하는 것이 중요하다.

우선 Keypoint matching을 하기 위해서는 keypoint의 2D location을 추출해주는 keypoint detector와 keypoint의 매칭을 위한 정보를 추출해주는 keypoint descriptor가 필요하다. 여기서, 같은 keypoint를 다른 각도에서 바라보아도 비슷한 keypoint descriptor가 뽑히며, 다른 keypoint의 descriptor와는 차이가 나타나야한다.

위 과정을 요약하자면 keypoint detector는 keypoint label을 supervised learning으로 학습하였으며 keypoint detector로 찾은 keypoint location에서 descriptor를 추출하여 비교한 후 descriptor 학습을 수행한다. 이때 keypoint descriptor 학습은 contrastive loss를 이용한 metric learning 기법을 사용한다.

Neural Ordinary Differential Equations (Neural ODE) [작성 중]

hydragon — Wed, 9 Mar 2022 11:45:22 +0900

https://arxiv.org/abs/1806.07366

Neural Ordinary Differential Equations

We introduce a new family of deep neural network models. Instead of specifying a discrete sequence of hidden layers, we parameterize the derivative of the hidden state using a neural network. The output of the network is computed using a black-box differen

arxiv.org

Neural Ordinary Differential Equations (이하 Neural ODE)는 2018년도 NeurIPS에서 best paper award를 받은 논문이다. 수식적으로 이해하기 상당히 어렵지만 이해해두면 좋을 것 같아 틈틈이 정리해볼까 한다.

먼저 ResNet으로 유명한 residual block의 구조를 다시 한번 봐보자. ResNet는 전에 정리해둔 글이 있다.

https://hydragon-cv.info/entry/Deep-Residual-Learning-for-Image-Recognition

Deep Residual Learning for Image Recognition

Abstract Deep neural networks의 단점은 그 깊이가 깊어질수록 더 학습하기 어렵다는 것이다. ResNet은 이전의 학습 방법들과 달리 residual(어떤 과정이 끝나고 난 뒤에 남은, 잔여[잔류]의)을 학습하는 방

hydragon-cv.info

위 그림을 논문 수식 형태로 다시 표현하면 아래와 같다.

$h _ { t+1 } =h _ { t } + F \left ( h _ { t } , \theta _ { t } \right )$

따라서 $h _ { t+1 } -h _ { t } =F \left ( h _ { t } , \theta _ { t } \right )$인데, t의 변화량이 매우 작다면 다음과 같이 표현할 수 있을 것이다.

$\frac{ dh \left ( t \right ) } { dt } =f \left ( h \left ( t \right ) ,t, \theta \right )$

뉴럴 네트워크에서 $t$의 변화량이 매우 작다는 것은 일반적이지 않지만 위와 같은 레이어가 네트워크에 무수히 많이 쌓여있다고 생각하면 고려할 수 있다. 다시 말해 일반적엔 네트워크가 layer를 통과하면서 값이 이산적으로 변화하겠지만 이를 연속적인 변화로 간주할 수 있다는 것이다.

저자들은 위 식이 상미분 방정식 (ordinary differential equations, 독립 변수를 하나만 포함하며, 하나 이상의 도함수를 가지고 있는 미분방정식)와 형태가 유사하다는 것에 주목하는데, 실제로 상미분 방정식의 일반 형태는 $\frac{ dz } { dt } =f \left ( z,t \right )$로 매우 유사하다.

결과적으로 이산적이지 않은, 연속적인 뉴럴 네트워크의 임의의 지점에서의 값을 계산하기 위해서는 위 상미분 방정식의 해를 구하는 것과 동일한다. 아래 그림을 보면 이해가 편하다.

위 그래프의 파란색 곡선이 실제 연속적인 레이어를 통과하면서 변화하는 값이라고 가정하자. 일반적인 함수의 경우 초기값 $A _{0}$를 알고 있다면 상미분 방정식의 해는 유일함이 알려져 있는데, 위 상미분 방정식을 풀 수만 있다면 파란색 곡선을 도출하는 것이 가능하다. 이를 근사하는 유명한 방법 중 하나가 바로 오일러 (Euler) 방법이다. 오일러 방법은 아래와 같다.

$y _{i+1} =y _{i} +f \left( t _{i} ,y _{i} \right) h$

위와 같은 방법으로 $t_i$에서의 함수 값을 알면 위 과정을 반복하여 그래프를 근사하는 것이 가능하다. (이 전 그래프의 $A_0$, $A_1$, $A_2$, $A_3$, $A_4$와 유사하며, 단점은 오일러 방법은 뒤로 갈수록 오차가 누적된다는 점이다.) 오일러 방법을 반복해서 그래프를 근사하는 자세한 방법은 아래 글을 참고하면 된다.

https://angeloyeo.github.io/2021/04/30/direction_fields.html

방향장과 오일러 방법 - 공돌이의 수학정리노트

angeloyeo.github.io

어쨌든 이러한 방식을 사용하면 네트워크의 출력 값들을 근사할 수는 있겠지만 이러한 방식은 큰 메모리 비용이 발생하여 비효율적이다. 따라서 저자들은 이러한 상미분 방정식의 해를 효과적으로 계산할 수 있는 adjoint sensitivity method를 이용한다.

먼저 지금까지의 과정을 수식으로 정리하면 아래와 같다. (논문에서 $h$가 $z$로 바뀌었다.)

$z \left ( t _ { 1 } \right ) =z \left ( t _ { 0 } \right ) + \int _ { t _ { 0 } } ^ { t _ { 1 } } { \frac{ dz \left ( t \right ) } { dt } dt } =z \left ( t _ { 0 } \right ) + \int _ { t _ { 0 } } ^ { t _ { 1 } } { f \left ( z \left ( t \right ) ,t, \theta _ { t } \right ) dt }$

그래프를 그려보면 당연한 수식이다. 이 값을 참값과 비교해야 하기 때문에 이를 loss function $L$에 집어 넣으면

$L \left ( z \left ( t _ { 1 } \right ) \right ) =L \left ( z \left ( t _ { 0 } \right ) + \int _ { t _ { 0 } } ^ { t _ { 1 } } { f \left ( z \left ( t \right ) ,t, \theta _ { t } \right ) dt } \right )$

와 같다. 네트워크를 학습하기 위해서는 위 loss function의 에러 값을 최소화하는 방향으로, 즉 $L \left ( z \left ( t _ { 1 } \right ) \right )$를 최소화 하는 방향으로 학습한다.

일반적인 역전파 연산은 parameter에 대한 gradient $\frac{ \partial L } { \partial \theta }$를 계산하는 것임을 알고 있을 것이다. 결국에 우리가 계산하고 싶은 것은 주어진 loss function $L$과 model parameter $\theta$ 에 대해서 gradient $\frac{ \partial L } { \partial \theta }$를 계산하고 싶은 것인데, adjoint sensitivity method는 이를 계산하기 위해서 adjoint $a \left ( t \right ) = \frac{ \partial L } { \partial z \left ( t \right ) }$를 정의하게 된다.

리눅스 SSH 방화벽 포트 설정 방법

hydragon — Thu, 3 Feb 2022 11:29:34 +0900

SSH를 설치하면 기본적으로 22번 포트로 접속이 가능하나 가끔 접속이 안되는 경우가 있다. 이 경우 아래와 같이 수동으로 22번 포트의 방화벽을 해제하면 된다.

sudo ufw enable

sudo ufw allow 22

sudo ufw reload

숫자 22 자리에 다른 포트 번호를 입력하면 해당하는 포트도 방화벽 해제가 가능하다. 현재 방화벽 상태를 확인하려면

sudo ufw status

와 같이 입력하자

LATEX 유용한 코드 모음

hydragon — Mon, 31 Jan 2022 11:06:35 +0900

논문용 LATEX를 사용할때 유용한 코드들을 모아봤다.

1. 그림 삽입

\begin{figure}
	\setlength{\belowcaptionskip}{-24pt}
	\begin{center}
		\includegraphics[width=\linewidth]{이미지 경로}
		\caption{캡션}
		\label{label 이름}
	\end{center}
\end{figure}

2. 수식 삽입

\begin{equation}
	수식 입력
\end{equation}

3. 글자 색 변경

\usepackage{color}

\textcolor{red}{red colored text}

WACV 2022 학회 참석기 (하와이 여행기) #4

hydragon — Sun, 30 Jan 2022 00:00:03 +0900

WACV 2022 학회 참석기 (하와이 여행기) #3

WACV 2022 학회 참석기 (하와이 여행기) #2 WACV 2022 학회 참석기 (하와이 여행기) #2 WACV 2022 학회 참석기 (하와이 여행기) #1 WACV 2022 학회 참석기 (하와이 여행기) #1 최근에 IEEE/CVF Winter..

hydragon-cv.info

사실 하와이 방문 목적이 WACV 학회 참석이었지만 지금까지 너무 여행 위주로 글을 쓴 것 같다. 이번에는 학회 참석기를 써볼까 한다.

https://goo.gl/maps/tQkZ5RiU8gMscqx89

와이콜로아 비치 매리엇 리조트 & 스파 · 69-275 Waikōloa Beach Dr, Waikoloa Beach, HI 96738 미국

★★★★☆ · 호텔

www.google.co.kr

학회는 와이콜로아 비치 바로 옆의 매리엇 리조트에서 열렸다. 학회는 1월 5일부터 7일까지 3일간 열렸다. 학회 특성상 전체 논문 제출자는 Oral 발표를 진행해야 하고 추가로 포스터 발표를 진행해야 했다. 다만 코로나 때문에 발표는 하이브리드로 진행됐다.

학회장 뷰, 역시 하와이에서 열리는 학회장 답다.

Oral 발표 세션

첫번째 포스터

두번째 포스터

총 2편의 논문을 제출하여 포스터도 2편이다. 발표자는 1명인데 포스터는 2개라 포스터 발표 때 좀 바빴다.

포스터 발표 세션. 사람이 정말 많았는데 거의 유일한 한국인을로 현대자동차 연구원님 3분이 필자의 발표를 들었다.

감사하게도 필자의 연구에 많은 사람들이 관심을 보여주었는데, 영어를 잘 못해서 좀 걱정했지만 전공 분야라 그런지 대화하는 데는 크게 문제가 없었다.

Oral 세션이 끝나고 발표자들이 모두 모여 저녁을 먹었다. 초면이지만 대부분 연구 분야 이야기를 하며 시간을 보냈다.

대학원에 들어가고 첫 번째 논문이자 첫 번째 해외학회 참석이라 더욱 의미가 있었다. 한국에서는 해볼 기회가 없었던 외국 연구자들과 영어로 대화해볼 수 있어서 좋았고 내 연구를 다른 사람들에게 설명해볼 수 있어서 기뻤다. 논문을 쓰는 것도 좋지만 이러한 자리에 참석해서 연구원이나 기업들과 연구 분야를 공유하는 자리를 앞으로도 자주 가졌으면 좋겠다.

WACV 2022 학회 참석기 (하와이 여행기) #3

hydragon — Fri, 28 Jan 2022 23:58:43 +0900

WACV 2022 학회 참석기 (하와이 여행기) #2

WACV 2022 학회 참석기 (하와이 여행기) #1 WACV 2022 학회 참석기 (하와이 여행기) #1 최근에 IEEE/CVF Winter Conference on Applications of Computer Vision (WACV 2022)에 1 저자 논문 2편이 accept 되..

hydragon-cv.info

이번에는 하와이에서 방문했던 맛집 위주로 글을 써볼까 한다.

https://goo.gl/maps/EoiQ9E9hfHzxwNEi9

Tommy Bahama Restaurant, Bar & Store · Shops at Mauna Lani 68, 1330 Mauna Lani Dr #102, Waimea, HI 96743 미국

★★★★★ · 음식점

www.google.co.kr

Tommy Bahama는 예약 시간 때문에 저녁 8시 30분쯤 늦게 갔는데 사람이 정말 많았던 기억이 있다. 가게 분위기도 좋았다.

메인 메뉴가 나오기 전에 나왔던 식전 빵이다.

마히마히라는 하와이의 유명한 생선으로 만든 스테이크이다. 개인적으로는 레스토랑 메뉴중 원픽이다.

디저트로 먹은 파인애플이 들어간 케이크

https://goo.gl/maps/tgyWBTLDNN99Jrxt8

Kona Crust · 74-5586 Palani Rd, Kailua-Kona, HI 96740 미국

★★★★★ · 피자 전문점

www.google.co.kr

Kona Crust는 와이콜로아에서 코나를 방문했을 때 방문했었다. 코나 방문기는 기회가 되면 써볼까 한다. 피자로 매우 유명한 가게라는데 코나 방문 당시 우버 기사가 극찬을 했던 가게였다.

가게 내부, 코로나 시국 전에는 홀 장사도 했던 것 같다.

가게 메인 메뉴인 kona supreme. 맛도 좋았고 한국 처럼 토핑이 과하지 않아서 좋았다.

5달러짜리 사이드 메뉴인 garlic knots

킹스 샵스안에 로이 야마구치(Roy Yamaguchi)라는 유명한 셰프가 운영하는 식당에 방문했다. (로이 야마구치는 고든 램지의 헬스 키친에 심사위원(?)으로 출연했었다 한다.) 거의 한 달 전부터 예약을 하여 호수 뷰의 좋은 자리를 얻었다.

https://goo.gl/maps/pm4HaHXiz9hb9vh48

Roy's Waikoloa Bar & Grill · 69-250 Waikōloa Beach Dr, Waikoloa Village, HI 96738 미국

★★★★☆ · 하와이 레스토랑

www.google.co.kr

식당 외부

에피타이저, 보기보다 맛은 괜찮았다.

메인 메뉴 3종류, 직원이 메뉴 추천을 해줬다.

이 식당의 시그니쳐 디저트 메뉴인 초콜릿 수플레, 꼭 먹어봐야하는 디저트로 유명하다.

Pyinstaller 사용시 selenium의 chromedriver 콘솔창 제거하는 방법

hydragon — Fri, 28 Jan 2022 23:32:49 +0900

selenium으로 만든 프로젝트를 pyinstaller로 프로그램을 만들 때 --noconsole 옵션을 주어도 검은색 콘솔창이 계속 나오는 경우가 있다. 이 경우에는 먼저

C:\Users\[사용자 이름]\anaconda3\envs\[가상환경 이름]\Lib\site-packages\selenium\webdriver\common

경로의 service.py를 찾아서 열어준다.

service.py 중간에 다음과 같은 항목이 보일것이다.

try:
    cmd = [self.path]
    cmd.extend(self.command_line_args())
    self.process = subprocess.Popen(cmd, env=self.env,
                                    close_fds=system() != 'Windows',
                                    stdout=self.log_file,
                                    stderr=self.log_file,
                                    stdin=PIPE,
                                    creationflags=self.creationflags)
except TypeError:
    raise

이 부분을

try:
    cmd = [self.path]
    cmd.extend(self.command_line_args())
    self.process = subprocess.Popen(cmd, stdin=PIPE, 
                                    stdout=PIPE,
                                    stderr=PIPE, 
                                    shell=False, 
                                    creationflags=0x08000000)
except TypeError:
    raise

이렇게 수정하면 된다. 그러면 더 이상 콘솔창이 보이지 않는다.