301 Agency

Neural ODE를 이용한 연속적인 계층을 가진 신경망 모델링

2023-08-11T11:18:10+00:00

Prerequisites
1. Euler Method
Paper Review
Related Works
1. Augmented Neural ODE
2. Normalizing Flow

Prerequisites

Euler Method

Euler method는 미분방정식이 주어질 때 함수의 함숫값을 구하는 한 방법이다.

이 논문에서는 hidden state의 연속적인 mapping을 위해서 상미분방정식을 사용하는데, 이 때 foward 와 backward 과정 모두에서 Euler method를 통해 식을 전개하게 된다.

Paper Review

Neural Ordinary Differential Equations (2019.12.14.)

paper link:

Neural Ordinary Differential Equations

Introduction

대부분의 인공지능 모델이 이산적인 시간에 대한 데이터를 다룬다. 심층 신경망 모델의 Layer 자체가 이산적인 형태이기도 하고, 데이터도 이산적인 형태의 것이기 때문이다.

이 논문에서는 hidden state가 변화하는 과정을 상미분방정식으로 모델링하여 연속적인 깊이를 가진 모델을 구성하였다. 계층 구조가 이산적인 계산 형태에서 탈피하여 연속적인 모델링이 가능해지고, 연속적인 잠재 함수를 모델링하는 것에 대한 표현력이 증가함을 밝혔다.

hidden state를 나타내는 함수의 derivative를 구하는 과정을 Ordinary Differential Equation(ODE)로 표현하였으며, 어떠한 ODE solver에 대해서도 Backpropagation을 수행할 수 있는 Black-box 모델을 통해 출력을 생성하게 된다.

Idea

residual network, recurrent network 등을 생각해보면 모델에 들어온 입력에 Transformation을 가하는데, 이는 시간 $t$에 대해 이산적인 sequence를 생성한다. 이를 hidden state $\mathbf{h}_t$와 model parameter $\theta_t$에 관한 식으로 나타내면 다음과 같다.

$\mathbf{h}_{t+1}=\mathbf{h}_t+f(\mathbf{h}_t, \theta_t)$

하지만 만약에 hidden state를 계속 추가해서, 연속적인 시간에 대해 $\mathbf{h}_t$를 구할 수 있다면 어떨까? 이를 위해 다음과 같은 ODE를 구성한다.

$\frac{d\mathbf{h}_t}{dt}=f(\mathbf{h}(t), t, \theta)$

이를 이용하면 어떠한 연속적인 시점 $t$에 대해서도 model output $\mathbf{h}$를 구할 수 있을 것이다.

Continuous Backpropagation

Neural ODE 모델의 Backpropagation은 Euler method를 이용한 function approximation의 과정이다. 이 과정에서 gradient를 편리하게 계산할 수 있도록 Adjoint sensitivity method를 사용한다.

위 그림과 같이 hidden state가 $\mathbf{z}(t_0)$에서 $\mathbf{z}(t_N)$로 mapping되는 과정을 보자. ODE solver을 통해 최종적으로 도출해야 하는 것은 dynamic parameter $\theta$에 대한 Loss의 gradient인 $\frac{\partial{L}}{\partial{\theta}}$와 $\mathbf{z}(t_0)$보다 이전 계층으로의 gradient 전파를 위한 $\frac{\partial{L}}{\partial{\mathbf{z}(t_0)}}$이다.

Loss는 scalar function이고, $f$는 neural network로 parameterize 되어 있다는 것에 주의하라.

(1). $L(\mathbf{z}(t_N))=L(\mathbf{z}(t_0)+\int_{t_0}^{t_N}f(\mathbf{z}(t),t,\theta)dt)$

Derivation of (1)

이제 $\frac{\partial{L}}{\partial{\mathbf{z}(t_0)}}$와 $\frac{\partial{L}}{\partial{\theta}}$를 구해야 하는데, 이를 단번에 유도하기는 복잡하므로, adjoint $\mathbf{a}(t)=\frac{dL}{d\mathbf{z}(t)}$를 정의한다. adjoint $\mathbf{a}$는 어떤 시점 $t$에서의 상태 $\mathbf{z}$에 대한 Loss이다. adjoint는 다음과 같은 ODE를 통해 표현한다.

(2). $\frac{d\mathbf{a}(t)}{dt}=-\mathbf{a}^T\frac{\partial{f(\mathbf{z}(t), t, \theta)}}{\partial{\mathbf{z}(t)}}$

Derivation of (2)

위의 adjoint 식 (2)를 Euler method에 적용시키면, $\frac{\partial{L}}{\partial{\mathbf{z}(t_0)}}$를 구할 수 있다.

(3). $\frac{\partial{L}}{\partial{\mathbf{z}(t_0)}}=\frac{\partial{L}}{\partial{\mathbf{z}(t_N)}}-\int^{t_0}_{t_N}\mathbf{a}(t)^T\frac{\partial{f(\mathbf{z}(t), t, \theta)}}{\partial{\mathbf{z}}(t)}dt$

Derivation of (3)

마지막으로, 결국 optimize 해야 하는 것은 model parameter $\theta$이므로, $\frac{dL}{d\theta}$를 구한다.

(4). $\frac{dL}{d\theta}=-\int_{t_N}^{t_0}\mathbf{a}(t)^T\frac{\partial{f(\mathbf{z}(t), t,\theta)}}{\partial{\theta}}dt$

Derivation of (4)

이로써 완전한 $f$의 update와 Loss backpropagation을 위한 모든 gradient를 얻을 수 있게 되었다.

Benefits of Neural ODE

Continuous time-series model을 만들 수 있다.

일정한 시간 간격을 가진 obeservation이 필요했던 기존의 모델과는 달리, arbitrary-time observation을 사용할 수 있게 되면서 데이터 손실을 최소화 할 수 있고, latent를 더 잘 모델링할 수 있게 된다.

계산의 정확도를 쉽게 조절할 수 있다

오랜 기간 연구되어온 ODE solver인 Euler method를 사용하기 때문에 오차를 필요한 수준으로 감소시키는 작업이나, 계산을 가속화하는 것이 용이하다.

Continuous Normalizing Flow 모델 구현

Neural ODE를 이용한 Normalizing Flow 모델은 continuous해지며, 계산이 간편해진다. NF 모델에 관한 내용은 다음을 참고하라.

메모리 효율성

scalar Loss를 사용하는 Neural ODE 모델은 중간 과정의 값을 저장할 필요가 없기 때문에, 모델의 깊이에 관계없이 일정한 메모리를 차지한다.

Conclusion

Neural ODE는 기존의 이산적인 모델 구조에서 벗어나 연속적인 계층을 가진 Neural Network를 구현한 점에서, 해당 분야의 길을 열었다고 평가받고 있다.

실제로 Neural ODE의 등장 이후로 Continuous Normalizing Flow 등의 생성 모델 연구가 이루어지고 있으며, Neural ODE로 모든 함수의 근사가 불가능하다는 것이 밝혀지며 Augmented Neural ODE 모델이 등장하기도 하였다.

연속적인 시간에 대한 sampling과 학습이 가능하고, 따라서 continuous function에 대한 latent가 더 높은 정확도로 생성되므로, 시간의 연속적인 정보가 데이터에서 중요한 기상, 경제 지표, 의료 등의 데이터 분야에서 큰 활약을 할 수 있을 것으로 보인다.

Augmented Neural ODE

Augmented Neural ODEs

Normalizing Flow

Variational Inference with Normalizing Flows

이미지와 텍스트의 표현 공간을 통합한 CLIP 논문 리뷰

2023-08-04T17:13:45+00:00

Paper Review

Paper Review

Paper Link:

Learning Transferable Visual Models From Natural Language Supervision

CLIP의 주요 포인트 몇가지를 위주로 리뷰해보려고 합니다.

먼저 CLIP이 어떤 연구인지에 대하여 대략적으로 살펴본 후, 어떤 Encoder들을 사용했는지, 어떤 Loss를 사용했는지를 소개하겠습니다. 마무리로 간단하게 CLIP Official Repository에 있는 소스코드를 살펴보겠습니다.

Introduction

CLIP은 이미지와 텍스트를 같은 표현 공간(representation space)에 임베드(embed)하는 학습 기법입니다.

기존 연구의 한계

CLIP이 나오기 이전의 연구에서는 정해진 단어 집합(vocabulary)에 속한 단어들에 대하여 이미지들과의 관련도를 예측할 수 있도록 학습시켰습니다.

이를 위해서는 학습하고자 하는 모든 단어들에 대하여 라벨링이 된 데이터셋(labeled dataset)을 마련해야 한다는 문제점이 있었습니다.

CLIP 연구진들은 이로 인해 학습 가능한 데이터셋의 규모(scale)가 제한되며, 성능(performance)에도 제한이 있으리라고 보았습니다.

또한, 각 단어들을 단어 집합 내에서의 순서에 따라 0, 1, 2, … 과 같은 숫자로만 치환해놓고 학습하는 경우에는, 해당 단어의 의미와 관련된 지식을 이용하기에 어렵다는 문제점이 발생했습니다.

Why CLIP?

CLIP 연구진은 학습 가능한 데이터셋의 크기를 효과적으로 늘리기 위해서, 이미지와 그에 대응하는 캡션(caption) 또는 제목이 이미 매칭되어 있는 상태의 raw data를 수집했습니다. 예를 들어 인스타그램에서 이미지와 그에 대한 설명 또는 파일제목을 얻어 이를 데이터셋으로 사용했습니다.

이미지 캡션, 제목과 같은 텍스트를 인코딩(encode)할 때는 BPE Tokenizer를 사용했으며, Transformer를 이용하여 임베딩을 구했습니다. 이 덕분에 규모가 클 뿐더러 사전에 포함되지 않는 단어가 등장하기도 하는 raw data를 학습하기에 용이했을 것입니다.

CLIP은 기존보다 훨씬 큰 규모(scale)의 데이터셋(dataset)으로 학습할 수 있었으며, 따라서 학습에 사용한 데이터셋 (pretrained dataset)에 포함되지 않은 텍스트에 대해서도 더 잘 일반화할 수 있었다는 점에서 획기적인 연구였습니다.

CLIP의 이미지 및 텍스트 인코더

CLIP에서는 텍스트 인코더와 이미지 인코더를 따로 두되, 두 인코더가 같은 표현 공간 (representation space)에서 임베딩(embedding)을 만들어내도록 학습했습니다.

텍스트 인코더로는 masked attention을 포함한 Transformer를 사용했습니다. 앞서 언급했듯이 토크나이징(tokenizing)에는 BPE를 사용했습니다.

이미지 인코더로는 두 가지 옵션을 두었습니다. 수정된 ResNet (modified ResNet)과 Vision-Transformer (ViT)입니다.

CLIP의 학습 방법; “Contrastive Learning”

Contrastive Learning은 유사한 두 오브젝트의 쌍(pair)들로 이루어진 데이터셋(paired datset)을 필요로 합니다. 유사도(similarity)를 계산하기 위한 metric을 정해 두고, 쌍을 이루는 유사한 두 오브젝트 간의 유사도가 최대가 되도록 학습(maximize)합니다.

CLIP은 이러한 Contastive Loss를 사용하는 Contrastive Learning입니다. CLIP에서 사용한 Loss는 그 중에서도 ‘Multi-class N-pair Loss’라고 불립니다.

Multi-class N-pair Loss

CLIP에서는 각 Batch마다 서로 유사한 텍스트-이미지 쌍을 N쌍씩 학습시킵니다. 즉, 텍스트-이미지 쌍 N개가 나오도록 텍스트 N개와 이미지 N개씩을 준비해야 합니다.

이러한 텍스트 N개와 이미지 N개로부터 나올 수 있는 모든 조합의 텍스트-이미지 쌍을 만들면 N×N개의 쌍이 생깁니다. 이는 서로 유사한 텍스트-이미지 N쌍과 서로 유사하지 않은 텍스트-이미지 N×(N-1)쌍으로 이루어질 것입니다.

아래 그림을 보는 것이 이해를 도울 것입니다. 그림에서 파란색으로 표시된 쌍들은 서로 유사한 Positive Pair이며, 표시되지 않은 쌍들은 서로 유사하지 않은 Negative Pair입니다.

유사도 메트릭 (similarity metric)으로는 코사인 유사도 (cosine similarity)를 사용합니다.

N개의 Positive Pair에 대해서는 코사인 유사도를 Maximize하고 N×(N-1)개의 Negative Pair에 대해서는 코사인 유사도를 Minimize하도록 학습합니다.

구체적으로, Symmetric Cross Entropy Loss를 사용합니다. 위 그림 상에서 Row별로, Column별로 각각 Binary Cross Entropy Loss를 구한 후, 두 Loss 값의 산술평균한 것을 Final Loss로 삼아 학습시킵니다.

논문에 첨부된 아래 Pseudo Code를 참고해서 이해할 수 있습니다.

Code Review

Official Code Link:

GitHub - openai/CLIP: CLIP (Contrastive Language-Image Pretraining), Predict the most relevant text snippet given an image

마지막으로 위 Repository의 clip/model.py 소스코드를 리뷰해보겠습니다.

CLIP의 Main Code

CLIP 클래스

forward 메서드을 보면, 아래 코드와 같이, 먼저 이미지와 텍스트를 각자의 인코더를 이용해 임베딩합니다.

이 임베딩에 Normalization을 거친 후, 이미지와 텍스트를 각각 기준으로 잡고 코사인 유사도를 구합니다.

  def forward(self, image, text):
  	**image_features = self.encode_image(image)**
  	**text_features = self.encode_text(text)**

  	# normalized features
  	image_features = image_features / image_features.norm(dim=1, keepdim=True)
  	text_features = text_features / text_features.norm(dim=1, keepdim=True)

  	# cosine similarity as logits
  	logit_scale = self.logit_scale.exp()
  	**logits_per_image = logit_scale * image_features @ text_features.t()
  	logits_per_text = logits_per_image.t()**

  	# shape = [global_batch_size, global_batch_size]
  	return logits_per_image, logits_per_text

encode_image와 encode_text는 각각 사용할 인코더를 호출하는 메서드입니다.

encode_image는 아래 코드와 같이, ModifiedResNet과 VisionTransformer 중 하나로 지정된 Visual Encoder를 호출합니다.

  if isinstance(vision_layers, (tuple, list)):
  	vision_heads = vision_width * 32 // 64
  	self.visual = **ModifiedResNet**(
  	    layers=vision_layers,
  	    output_dim=embed_dim,
  	    heads=vision_heads,
  	    input_resolution=image_resolution,
  	    width=vision_width
  	)
  else:
  	vision_heads = vision_width // 64
  	self.visual = **VisionTransformer**(
  	    input_resolution=image_resolution,
  	    patch_size=vision_patch_size,
  	    width=vision_width,
  	    layers=vision_layers,
  	    heads=vision_heads,
  	    output_dim=embed_dim
  	)

encode_text는 아래 코드와 같이, token_embedding과 positional_embedding을 더하고 Transformer에 넣은 후 Laynorm과 Linear Projection을 거칩니다.

  def encode_text(self, text):
    x = self.token_embedding(text).type(self.dtype)  # [batch_size, n_ctx, d_model]

    x = x + self.positional_embedding.type(self.dtype)
    x = x.permute(1, 0, 2)  # NLD -> LND
    x = self.transformer(x)
    x = x.permute(1, 0, 2)  # LND -> NLD
    x = self.ln_final(x).type(self.dtype)

    # x.shape = [batch_size, n_ctx, transformer.width]
    # take features from the eot embedding (eot_token is the highest number in each sequence)
    x = x[torch.arange(x.shape[0]), text.argmax(dim=-1)] @ self.text_projection

    return x

Encoders

ModifiedResNet 클래스

기존 ResNet과 다른 점이 3가지 있습니다. 기존 ResNet 구현은 아래 이미지를 참고하면 됩니다.

Residual Layer들 이전 stem layer가 다릅니다.

아래 코드의 모듈들을 순서대로 적용합니다.

 # __init__ 내부

 self.conv1 = nn.Conv2d(3, width // 2, kernel_size=3, stride=2, padding=1, bias=False)
 self.bn1 = nn.BatchNorm2d(width // 2)
 self.relu1 = nn.ReLU(inplace=True)
 self.conv2 = nn.Conv2d(width // 2, width // 2, kernel_size=3, padding=1, bias=False)
 self.bn2 = nn.BatchNorm2d(width // 2)
 self.relu2 = nn.ReLU(inplace=True)
 self.conv3 = nn.Conv2d(width // 2, width, kernel_size=3, padding=1, bias=False)
 self.bn3 = nn.BatchNorm2d(width)
 self.relu3 = nn.ReLU(inplace=True)
 self.avgpool = nn.AvgPool2d(2)

 # ------------

 def forward(self, x):
 	  def stem(x):
 	      x = self.relu1(self.bn1(self.conv1(x)))
 	      x = self.relu2(self.bn2(self.conv2(x)))
 	      x = self.relu3(self.bn3(self.conv3(x)))
 	      x = self.avgpool(x)
 	      return x

Average Pooling을 사용합니다.

기존 ResNet과 달리, stem layer의 마지막과 각 residual layer의 마지막에서 Average Pooling을 사용합니다. (BottleNeck 클래스에서 확인 가능)

Attention Pooling을 사용합니다.

ModifiedResNet의 마지막 layer는 Attention Pooling입니다. 그 구현은 아래 코드를 참고할 수 있습니다. 이는 multi-head attention을 포함하고 있습니다.

 class AttentionPool2d(nn.Module):
     def __init__(self, spacial_dim: int, embed_dim: int, num_heads: int, output_dim: int = None):
         super().__init__()
         self.positional_embedding = nn.Parameter(torch.randn(spacial_dim ** 2 + 1, embed_dim) / embed_dim ** 0.5)
         self.k_proj = nn.Linear(embed_dim, embed_dim)
         self.q_proj = nn.Linear(embed_dim, embed_dim)
         self.v_proj = nn.Linear(embed_dim, embed_dim)
         self.c_proj = nn.Linear(embed_dim, output_dim or embed_dim)
         self.num_heads = num_heads

     def forward(self, x):
         x = x.flatten(start_dim=2).permute(2, 0, 1)  # NCHW -> (HW)NC
         x = torch.cat([x.mean(dim=0, keepdim=True), x], dim=0)  # (HW+1)NC
         x = x + self.positional_embedding[:, None, :].to(x.dtype)  # (HW+1)NC
         x, _ = F.multi_head_attention_forward(
             query=x[:1], key=x, value=x,
             embed_dim_to_check=x.shape[-1],
             num_heads=self.num_heads,
             q_proj_weight=self.q_proj.weight,
             k_proj_weight=self.k_proj.weight,
             v_proj_weight=self.v_proj.weight,
             in_proj_weight=None,
             in_proj_bias=torch.cat([self.q_proj.bias, self.k_proj.bias, self.v_proj.bias]),
             bias_k=None,
             bias_v=None,
             add_zero_attn=False,
             dropout_p=0,
             out_proj_weight=self.c_proj.weight,
             out_proj_bias=self.c_proj.bias,
             use_separate_proj_weight=True,
             training=self.training,
             need_weights=False
         )
         return x.squeeze(0)

Transformer 클래스

Transformer는 ResidualAttentionBlock 여러 층을 쌓은 것입니다.

  class Transformer(nn.Module):
      def __init__(self, width: int, layers: int, heads: int, attn_mask: torch.Tensor = None):
          super().__init__()
          self.width = width
          self.layers = layers
          self.resblocks = nn.Sequential(*[ResidualAttentionBlock(width, heads, attn_mask) for _ in range(layers)])

      def forward(self, x: torch.Tensor):
          return self.resblocks(x)

ResidualAttentionBlock은 아래 코드와 같이 먼저LayerNorm → (Masked) Multi-Head Attention을 하면서 Residual Connection을 한 번 넣은 후, LayerNorm → MLP를 하면서 Residual Connection을 한 번 넣는 연산입니다.

  class ResidualAttentionBlock(nn.Module):
      def __init__(self, d_model: int, n_head: int, attn_mask: torch.Tensor = None):
          super().__init__()

          self.attn = nn.MultiheadAttention(d_model, n_head)
          self.ln_1 = LayerNorm(d_model)
          self.mlp = nn.Sequential(OrderedDict([
              ("c_fc", nn.Linear(d_model, d_model * 4)),
              ("gelu", QuickGELU()),
              ("c_proj", nn.Linear(d_model * 4, d_model))
          ]))
          self.ln_2 = LayerNorm(d_model)
          self.attn_mask = attn_mask

      def attention(self, x: torch.Tensor):
          self.attn_mask = self.attn_mask.to(dtype=x.dtype, device=x.device) if self.attn_mask is not None else None
          return self.attn(x, x, x, need_weights=False, attn_mask=self.attn_mask)[0]

      def forward(self, x: torch.Tensor):
          x = x + self.attention(self.ln_1(x))
          x = x + self.mlp(self.ln_2(x))
          return x

VisionTransformer 클래스

Convolution으로 Image Feature를 얻고, positional embedding도 더하며, 이후 위에서 소개한 Transformer로 처리합니다.

  class VisionTransformer(nn.Module):
      def __init__(self, input_resolution: int, patch_size: int, width: int, layers: int, heads: int, output_dim: int):
          super().__init__()
          self.input_resolution = input_resolution
          self.output_dim = output_dim
          self.conv1 = nn.Conv2d(in_channels=3, out_channels=width, kernel_size=patch_size, stride=patch_size, bias=False)

          scale = width ** -0.5
          self.class_embedding = nn.Parameter(scale * torch.randn(width))
          self.positional_embedding = nn.Parameter(scale * torch.randn((input_resolution // patch_size) ** 2 + 1, width))
          self.ln_pre = LayerNorm(width)

          self.transformer = Transformer(width, layers, heads)

          self.ln_post = LayerNorm(width)
          self.proj = nn.Parameter(scale * torch.randn(width, output_dim))

      def forward(self, x: torch.Tensor):
          x = self.conv1(x)  # shape = [*, width, grid, grid]
          x = x.reshape(x.shape[0], x.shape[1], -1)  # shape = [*, width, grid ** 2]
          x = x.permute(0, 2, 1)  # shape = [*, grid ** 2, width]
          x = torch.cat([self.class_embedding.to(x.dtype) + torch.zeros(x.shape[0], 1, x.shape[-1], dtype=x.dtype, device=x.device), x], dim=1)  # shape = [*, grid ** 2 + 1, width]
          x = x + self.positional_embedding.to(x.dtype)
          x = self.ln_pre(x)

          x = x.permute(1, 0, 2)  # NLD -> LND
          x = self.transformer(x)
          x = x.permute(1, 0, 2)  # LND -> NLD

          x = self.ln_post(x[:, 0, :])

          if self.proj is not None:
              x = x @ self.proj

          return x

CLIP의 Training Code

CLIP의 학습에 관해서는 위에 링크를 걸어놓은 Official Repo에서 공개해놓은 코드가 따로 없어서 아래 링크에 누군가 올려놓은 코드를 잠시 살펴보겠습니다.

CLIP Training Code · Issue #83 · openai/CLIP

아래 코드에서는 CLIP에서 얻은 텍스트, 이미지 사이의 코사인 유사도에 대하여 Ground Truth와의 Cross-Entropy Loss를 계산했습니다. 그렇게 구한 두 가지 Loss 값을 평균낸 것을 최종 Loss로 사용하여 학습합니다.

loss_img = nn.CrossEntropyLoss()
loss_txt = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=5e-5,betas=(0.9,0.98),eps=1e-6,weight_decay=0.2) #Params from paper

for batch in train_dataloader :
    optimizer.zero_grad()

    list_image,list_txt = batch #list_images is list of image in numpy array(np.uint8)

    images= torch.stack([preprocess(Image.fromarray(img)) for img in list_image],dim=0)
    texts = clip.tokenize(list_txt)

    logits_per_image, logits_per_text = model(images, texts)

    ground_truth = torch.arange(BATCH_SIZE).to(device)
    total_loss = (loss_img(logits_per_image,ground_truth) + loss_txt(logits_per_text,ground_truth))/2
    total_loss.backward()

    convert_models_to_fp32(model)
    optimizer.step()
    clip.model.convert_weights(model)

Repo에 CLIP 사용 예제 cookbook도 포함되어 있던데, CLIP을 어떻게 이용할 수 있을지 궁금하다면 참고하면 되겠습니다 (Interesting 하더라구요 ~~)

이상, CLIP Paper Review를 마치겠습니다. 읽어주셔서 감사합니다~!

Evolutionary Search를 통해 찾아낸 새로운 Optimizer, Lion.

2023-08-03T05:48:43+00:00

Paper Review
Related Works

Paper Review

Symbolic Discovery of Optimization Algorithms

Introduction

이 논문은 AutoML-Zero 와 상당히 유사한 내용을 가지고 있다. 하단 링크 참고

AutoML-Zero: Evolving Machine Learning Algorithms From Scratch

AutoML-Zero는 최대한 사람의 개입 없이 ML Architecture 를 구성하는 것에 대한 논문인데, 미분같은 복잡한 연산은 제외하고 65가지의 연산, 함수(instruction이라 한다.)를 조합하여 program flow를 구성하는 것을 목표로 program space를 search하였다고 한다. 사용된 방법은 evolutionary search로, genetic algorithm에 기반하여 instruction을 넣거나 빼고, 대체하는 등의 mutation 연산, 그리고 한 time-step(=generation)이 지날 때마다 N개의 top rated program을 parents로 하여 copy + mutation하는 절차를 통해 다양한 program을 만들어냈다고 한다.

본 논문도 마찬가지로 program search를 통해 최적의 optimizer를 찾고자 했다. 본 논문에서는 algorithm을 개발하는 데에 있어 program을 symbolic representation으로 사용하는 것에 대한 3가지 장점을 밝히고 있다.

(1). 어차피 계산 하려면 프로그램으로 나타내야 한다 (2). 분석하기 편하고 다른 분야로 transfer가 용이하다 (3). 프로그램의 길이를 알고리즘의 복잡도를 추정하는데 사용할 수 있어, 더 간단하고 일반적인 알고리즘을 찾는데 도움이 된다.

Program search space designing

해당 논문에서는 program search space를 설계할 때 고려할 점을 3가지 밝힌다.

(1). 신박한 알고리즘을 얻기 위해 충분히 넓어야 한다

(2). ML의 workflow에 적합해야 한다

(3). high-level design에만 집중한다

다음은 program search를 위한 4가지 구성이다.

`train` function

input으로 weight $w$, gradient $g$, learning rate $lr$을 받아 weight update를 output 하는 main objective이다. 즉, search의 객체이다.

historical value를 저장하는 extra variable을 둘 수 있다

building blocks

train function은 statement와 local variable 개수에 제약을 받지 않는다. 본 논문에서는 45개의 commom math function을 채택하였고, program의 간결성을 위해 linear interpolation function $interp(x, y, a)=(1-a)x+ay$ 등을 정의하였다.

또한 기존의 연구에서는 반복문, 조건문 등의 complex feature를 도입하였었는데 유의미한 성능 진전이 없었으므로 본 연구에서는 제외하였다고 한다.

차원에 맞지 않는 데이터 연산은 automatically casted되도록 했다고 한다.(ex. matrix + scalar)

mutations and redundant statements

3가지 mutation operation을 정의한다

random function을 random location에 삽입
randomly chosen statement 삭제
random function의 argument를 수정

random variable이나 constant는 normal distribution에서 추출하며, constant들은 차후에 tunable hyperparameter로 기능할 수 있다.

infinite and sparse search space

internal arguments, state, function의 개수에 제약을 두지 않고, mutation연산의 존재 때문에 program search space가 infinite하다.

high-performing program은 search space상에 sparse하게 존재하기 때문에, 이를 빠르게 search하기 위해 low-cost proxy task를 설정하여 evaluation하는 것으로 보인다.

Efficient search techniques

high-performing algorithm이 너무 sparse하게 존재하는 문제점 때문에 본 논문에서는 각종 search technique를 도입한다.

Evolution with warm-start and restart

warm-start: search acceleration을 위해 AdamW에서 시작

restart:
- exploration: start from initial program
- exploitation: start from best program
Pruning through abstract execution

별 건 아니고 에러 나는 거 없애주고, program 마다 hash값 만들어서 똑같은 program 삭제하는 것
Proxy tasks and search cost

low-cost proxy task로 search 진행. funnel selection과 연관.

Program selection methodology

매우 큰 program space를 search하기 때문에 proxy task를 필연적으로 이용하게 되는데, proxy task와 target task의 차이, 그리고 다양한 domain에 적용될 수 있는 generalization 능력을 원하기 때문에, 학습과 활용에 큰 차이가 발생한다고 밝히고 있다. 이에 본 논문에서는 2가지 해결책을 사용한다.

Funnel selection

funnel selection은 proxy task를 통해 generalization power를 검증하는 방법이다.
- proxy task A를 통해 problem set $S_1$을 평가한다 → selection → $S_2$
- A보다 10배 더 큰 task B로 $S_2$의 평가를 진행한다 → selection → $S_3$
- $S_3$를 A보다 100배 더 큰 task C로 평가한다 → selection
이러한 과정을 통해 generalization performance가 떨어지는 program을 낙오시킨다.
Simplification

더 간단할 수록 generalization 능력이 높을 것이라는 직관에 의해, input과 output이 identical하거나, 없어져도 거의 영향을 미치지 않는 statement, function을 제거한다.

Proposition: Lion (EvoLved Sign Momentum) Optimizer

~~너무 억지 작명인 것 같다~~

해당 논문에서 찾아낸 Lion Opimizer이다.

Sign update and regularization

sign 함수를 이용하기 때문에, 모든 dimension에서 uniform magnitude를 가진다고 한다. 이 특성이 noise를 일으켜 regularization 처럼 기능한다고 설명한다.

cf. sign 함수가 noise를 일으키는 이유? → Lion은 RMSprop이나 Adam처럼 EMA를 사용하는데(linear interpolation 부분), 여기에 sign을 취해버려서 magnitude는 반영을 안하고 tendency만 반영하게 되어서 update가 non-smooth하게 되어서 noisy하다는 것 같음
Momentum tracking

$\beta_1, \beta_2$를 이용하는데, 2개를 써야하는 이유는 appendix의 ablation study에서 증명했다.(사실 evolutionary search로 찾아낸 것이기 때문에 사후 정당화에 가깝다)
Hyperparameter and batch size choices

Lion Optimizer의 성능은 Batch size가 커질 수록 비례하여 증가한다.
Memory and runtime benefits

task에 따라 AdamW 보다 2-15% 가량의 속도 향상을 보였다.

Evaluation of Lion

ViT, LiT, Autoregressive Model 등 다양한 task에 적용했는데 AdamW보다 항상 낫거나 비슷했다고 한다. benchmark table이 너무 많으니까 논문 참조.

AutoML

Denoising Diffusion Probabilistic Models(DDPM)

2023-08-01T01:19:40+00:00

Denoising Diffusion Probabilistic Models(DDPM)
Paper Review
1. Denoising Diffusion Probabilistic Models (DDPM)
2. Other source

Denoising Diffusion Probabilistic Models(DDPM)

Paper Review

Denoising Diffusion Probabilistic Models (DDPM)

Denoising Diffusion Probabilistic Models

Diffusion model introduction

Diffusion model은 물질의 확산에 기반한 diffusion process의 inverse process를 학습하는 과정을 통해 데이터를 생성하는 generative model이다.

Diffusion model의 process는 크게 2개로 나뉘는데, 첫 번째는 diffusion mechanism을 통해 각 time step마다 데이터에 infinitesimal한 noise를 가해 결국에는 데이터와 independent한 noise를 만드는 과정이고, 두 번째는 diffusion의 reverse process를 모델링하여 random noise로부터 noise를 제거하여 원하는 데이터를 생성해내는 과정이다.

그림에서 $q(\bold{x}t\vert \bold{x}{t-1})$은 원본 데이터인 $\bold{x}0$에 noise를 가하는 diffusion process이며, $p\theta(\bold{x}_{t-1}\vert \bold{x}_t)$는 forward diffusion process의 reverse process로써 학습의 대상이다.

각각의 process는 finite time 안에 이루어지는 discrete한 과정이며, parameterized Markov chain이라고 할 수 있다.

Idea of reverse process & forward process

Loss derivation (Appendix A)

Approximation of $q(x_t\vert x_0)$

proof

What are Diffusion Models?

Parameterization of $p_{\theta}(x_{t-1}\vert x_t)$

$\sum_{\theta}(x_t, t)$
- when
  
  or (similar results)
$\mu_{\theta}(x_t, t)$

when parameterized

then

thus, $\mu_{\theta}(x_t, t)$ is parameterized to

using this, $L_{t-1}-C$ can be simplified to
- 메모
  
  $\mu$를 근사하기 위하여 $\mu_{\theta}$를 학습하는 것인데, parameterization을 수정함으로써 $\epsilon$를 학습하도록 훈련할 수 있다는 것.
  - model object가 $q(x_{t-1}\vert x_t, x_0)$와 $p_{\theta}(x_{t-1}\vert x_t)$의 분포를 유사하게 하는 것인데, 이는 곧 $\mu_{\theta}$와 $\tilde{\mu}$의 MSE를 최소화하는 것. 이때 $\tilde{\mu}$는 $x_0, x_t$에 대한 함수임.
  - 여기에서 새로운 parameter $\epsilon$을 등장시킴. 앞서서 $x_t$를 $x_0$으로부터 sampling한 것으로 볼 수 있다고 했는데, 이에 reparameterization trick을 적용했을 때, 표준정규분포로부터 sampling한 noise의 값이 $\epsilon$.
  - $\epsilon_{\theta}$와 $\epsilon$ 사이의 MSE를 최소화하도록 loss를 simplify할 수 있음
To sample $x_{t-1}$~$p_{\theta}(x_{t-1}\vert x_t)$

compute

→ reparameterization trick, z는 N(0, I)

Other source

Helo

Diffusion Model 입문하기

Denoising Diffusion Probabilistic Models 논문 리뷰 (DDPM 설명, DDPM 증명)

Concept. Diffusion Models ( with. DDPM )

Unpaired Image-to-Image Translation using Cycle-Consistent Adversarial Networks

2023-07-30T07:49:21+00:00

Paper Review

Unpaired Image-to-Image Translation using Cycle-Consistent Adversarial Networks

Unpaired Image-to-Image Translation using Cycle-Consistent…

Introduction

기존의 pix2pix model은 image mapping에 있어 generalizable하다는 특성이 있으나, 반드시 paired dataset이 필요하다는 단점이 있었다.

실제로 많은 양의 paired dataset을 구축하기는 어렵기 때문에, cycleGAN은 unpaired dataset으로 image translation을 하는 방법을 제안한다.

Model Architecture

structure

cycleGAN의 구조이다. $X→Y$를 mapping하는 $G$, 그리고 $Y→X$를 mapping하는 $F$가 있고, 각각이 생성한 데이터를 평가하는 Discriminator $D_Y, D_X$가 있다. 이들은 기존의 GAN과 마찬가지로 Adversarial Loss를 이용하여 학습하는데, $X, Y$가 paired 되어있지 않으므로, $G, F$가 $D_Y, D_X$를 속이기 위한 데이터를 생성해 input과는 irrelevant한 데이터를 생성하는 문제인 mode collapse가 발생했다고 한다. 그래서 도입된 것이 cycleGAN의 cycle-consistancy loss이다.
- cycle-consistency loss
cycle-consistency loss의 요점은 $X$를 $Y$에 mapping한 데이터를 다시 inverse mapping하였을 때 input data를 reconstruction 할 수 있게 loss를 구성하는 것이다. 즉, 이 과정에서 input의 content를 파괴하지 않는 mapping이 학습될 것이다.
loss

cycleGAN의 loss term은 GAN의 Adversarial loss + cycle-consistency loss 이다

full loss term

$\lambda$는 $L_{GAN}$과 $L_{cyc}$ 사이의 중요도를 반영하는 값이다.

Code review

https://github.com/junyanz/pytorch-CycleGAN-and-pix2pix

대부분이 GAN과 유사하기 때문에 차이점이 있는 부분만 보겠다.

def optimize_parameters(self):
        self.forward()
        self.set_requires_grad([self.netD_A, self.netD_B], False)
        self.optimizer_G.zero_grad()  
        self.backward_G()      
        self.optimizer_G.step()    
        self.set_requires_grad([self.netD_A, self.netD_B], True)
        self.optimizer_D.zero_grad() 
        self.backward_D_A()   
        self.backward_D_B()      
        self.optimizer_D.step()  

Generator와 Discriminator가 각각 2개 있기 때문에 optimizing하는 코드에 반영이 되어있다. forward(), backward_G() method는 각각 2개의 Generator model에 관해 작동한다.

def backward_G(self):
        lambda_idt = self.opt.lambda_identity
        lambda_A = self.opt.lambda_A
        lambda_B = self.opt.lambda_B
        if lambda_idt > 0:
            self.idt_A = self.netG_A(self.real_B)
            self.loss_idt_A = self.criterionIdt(self.idt_A, self.real_B) * lambda_B * lambda_idt
            self.idt_B = self.netG_B(self.real_A)
            self.loss_idt_B = self.criterionIdt(self.idt_B, self.real_A) * lambda_A * lambda_idt
        else:
            self.loss_idt_A = 0
            self.loss_idt_B = 0

        self.loss_G_A = self.criterionGAN(self.netD_A(self.fake_B), True)
        self.loss_G_B = self.criterionGAN(self.netD_B(self.fake_A), True)
        self.loss_cycle_A = self.criterionCycle(self.rec_A, self.real_A) * lambda_A
        self.loss_cycle_B = self.criterionCycle(self.rec_B, self.real_B) * lambda_B
        self.loss_G = self.loss_G_A + self.loss_G_B + self.loss_cycle_A + self.loss_cycle_B + self.loss_idt_A + self.loss_idt_B
        self.loss_G.backward()

backward_G() method에 cycle-consistency loss 가 반영되어 있다. identitiy loss는 generator의 mapping이 identity function에 가까워지도록 하는 loss term인데, target domain을 아는 경우에 사용하면 mapping consistency를 높여주는 역할을 한다.

cf) Identity loss는 **Unsupervised Cross-Domain Image Generation 에서 처음으로 사용되었다.

Encoding Recurrence into Transformers

2023-07-29T20:21:04+00:00

Paper Review

Encoding Recurrence into Transformers

Introduction

문제 상황: RNN은 구조상, recurrency 가 높은 데이터에 대해서는 학습 데이터가 적어도 효율이 나오는데, transformer는 그렇지 않다. 다만 transformer는 학습 데이터셋 크기가 크면 data의 recurrency에 관계없이 효율이 나온다. 이 점에 착안하여 RNN이 recurrence를 잘 capture하는 특징과 Transformer의 Attention 매커니즘을 결합하여 sequential data에 대한 학습 효율을 증가시키자는 것이 골자이다.

Model Architecture

용어:

RSA: Self-Attention with Recurrence, 이 논문에서 propose한 것

REM: Recurrence Encoding Matrix, 여기에 rnn의 본질인 recurrence dynamics가 positional encoding의 형태로 담겨 있다.

수식이 많은데 요점은…

RNN은 원래 병렬 처리가 안된다. → 은닉층 가중치가 지수적으로 곱해지기 때문

$W^{j}_{h}$ 이 부분이 문제임 → 하지만 Jordan Form으로 semi-diagonalize하면 손실 조금만 나면서 행렬 정리 가능

위처럼 block RNN 구조로 바꾼 다음에 Self-Attention의 form 으로 이것을 표현하기 위해 아래와 같은 masking 행렬을 정의한다.

그리고 이것을 $h^{C_1}{t}, h^{C_2}{t}$에 대해서도 똑같이 정의하고, Multi-head Self-Attention에 넣어주면 된다.

결국 RNN의 Recurrence 를 Capture하는 능력이 REM에 담기게 되지만, 계산 상 Attention과는 큰 관련이 없는데, Attention이 non-recurrent한 데이터에 대한 성능도 뛰어나니까 gated unit 하나로 REM과 conventional Self-Attention을 통합한 것이 RSA이다.

$P$가 REM이다. $\sigma(\mu)$는 learnable gate value이고, attention과 REM 을 사용하는 것의 비중을 정해준다.

(data의 reccurence가 심한 경우 이 값이 크게 학습된다.)

derivation은 밑 토글 참조.

암튼 RSA는 입력과 출력만 보았을 때 self-attention이랑 같기 때문에, 기존에 SA를 사용하던 Transformer 모델에 RSA를 대체로 넣어주기만 하면 되어서 편하다고 한다.

그리고 Introduction에 있는 그림처럼 RSA를 쓰면 그냥 SA보다 표현력이 증가해서 여러 sequential data learning tasks에서 좋은 결과를 얻었다고 한다…(대단해 O~O)

time series data를 이용한 비교이다. 본 논문에서 가장 recurrent한게 time series라고 밝혔듯이 확실히 개선된 결과를 보여준다. (prefix RSA가 붙은게 RSA를 대체로 쓴 모델이다)

이 외에도 벤치마크 몇 개 더 있는데 암튼 개선된 것 같다!

Mathmatics

REM 식을 derivation하는데 필요한 수학 지식이다.

A. Jordan form

B. Applied Theorems

추가) 어떤 행렬이 eigenvalue로 어떤 complex를 가지면 그 conjugate도 eigenvalue이다

RNN 표현

Welcome to Jekyll!

2023-07-25T14:28:26+00:00

Symbolic Discovery of Optimization Algorithms (2023.5)
AtlasYang (Gilmo Yang)
1. BIO
2. Organization
3. Contact

Symbolic Discovery of Optimization Algorithms (2023.5)

Symbolic Discovery of Optimization Algorithms

Introduction

이 논문은 AutoML-Zero 와 상당히 유사한 내용을 가지고 있다. 하단 링크 참고

AutoML-Zero: Evolving Machine Learning Algorithms From Scratch

Program search space designing

해당 논문에서는 program search space를 설계할 때 고려할 점을 3가지 밝힌다.

(1). 신박한 알고리즘을 얻기 위해 충분히 넓어야 한다 (2). ML의 workflow에 적합해야 한다 (3). high-level design에만 집중한다

다음은 program search를 위한 4가지 구성이다.

train function

input으로 weight $w$, gradient $g$, learning rate $lr$을 받아 weight update를 output 하는 main objective이다. 즉, search의 객체이다.

historical value를 저장하는 extra variable을 둘 수 있다
building blocks

train function은 statement와 local variable 개수에 제약을 받지 않는다. 본 논문에서는 45개의 commom math function을 채택하였고, program의 간결성을 위해 linear interpolation function $interp(x, y, a)=(1-a)x+ay$ 등을 정의하였다.

또한 기존의 연구에서는 반복문, 조건문 등의 complex feature를 도입하였었는데 유의미한 성능 진전이 없었으므로 본 연구에서는 제외하였다고 한다.

차원에 맞지 않는 데이터 연산은 automatically casted되도록 했다고 한다.(ex. matrix + scalar)
mutations and redundant statements

3가지 mutation operation을 정의한다
1. random function을 random location에 삽입
2. randomly chosen statement 삭제
3. random function의 argument를 수정
random variable이나 constant는 normal distribution에서 추출하며, constant들은 차후에 tunable hyperparameter로 기능할 수 있다.
infinite and sparse search space

internal arguments, state, function의 개수에 제약을 두지 않고, mutation연산의 존재 때문에 program search space가 infinite하다.

high-performing program은 search space상에 sparse하게 존재하기 때문에, 이를 빠르게 search하기 위해 low-cost proxy task를 설정하여 evaluation하는 것으로 보인다.

Efficient search techniques

high-performing algorithm이 너무 sparse하게 존재하는 문제점 때문에 본 논문에서는 각종 search technique를 도입한다.

Evolution with warm-start and restart

warm-start: search acceleration을 위해 AdamW에서 시작

restart:
- exploration: start from initial program
- exploitation: start from best program
Pruning through abstract execution

별 건 아니고 에러 나는 거 없애주고, program 마다 hash값 만들어서 똑같은 program 삭제하는 것
Proxy tasks and search cost

low-cost proxy task로 search 진행. funnel selection과 연관.

Program selection methodology

Funnel selection

funnel selection은 proxy task를 통해 generalization power를 검증하는 방법이다.
- proxy task A를 통해 problem set $S_1$을 평가한다 → selection → $S_2$
- A보다 10배 더 큰 task B로 $S_2$의 평가를 진행한다 → selection → $S_3$
- $S_3$를 A보다 100배 더 큰 task C로 평가한다 → selection
이러한 과정을 통해 generalization performance가 떨어지는 program을 낙오시킨다.
Simplification

더 간단할 수록 generalization 능력이 높을 것이라는 직관에 의해, input과 output이 identical하거나, 없어져도 거의 영향을 미치지 않는 statement, function을 제거한다.

Proposition: Lion (EvoLved Sign Momentum) Optimizer

~~너무 억지 작명인 것 같다~~

해당 논문에서 찾아낸 Lion Opimizer이다.

Sign update and regularization

sign 함수를 이용하기 때문에, 모든 dimension에서 uniform magnitude를 가진다고 한다. 이 특성이 noise를 일으켜 regularization 처럼 기능한다고 설명한다.

cf. sign 함수가 noise를 일으키는 이유? → Lion은 RMSprop이나 Adam처럼 EMA를 사용하는데(linear interpolation 부분), 여기에 sign을 취해버려서 magnitude는 반영을 안하고 tendency만 반영하게 되어서 update가 non-smooth하게 되어서 noisy하다는 것 같음
Momentum tracking

$\beta_1, \beta_2$를 이용하는데, 2개를 써야하는 이유는 appendix의 ablation study에서 증명했다.(사실 evolutionary search로 찾아낸 것이기 때문에 사후 정당화에 가깝다)
Hyperparameter and batch size choices

Lion Optimizer의 성능은 Batch size가 커질 수록 비례하여 증가한다.
Memory and runtime benefits

task에 따라 AdamW 보다 2-15% 가량의 속도 향상을 보였다.

Evaluation of Lion

ViT, LiT, Autoregressive Model 등 다양한 task에 적용했는데 AdamW보다 항상 낫거나 비슷했다고 한다. benchmark table이 너무 많으니까 논문 참조.

AtlasYang (Gilmo Yang)

BIO

Undergraduate Student majoring Computer Science & Engineering, Interested in Cognitive Architecture, Cellular Automata, and other DL, ML branches of study.

Organization

Seoul National University, Dept. of Computer Science & Engineering

AttentionX

Contact

E-mail

GitHub

Blog

You’ll find this post in your _posts directory. Go ahead and edit it and re-build the site to see your changes. You can rebuild the site in many different ways, but the most common way is to run jekyll serve, which launches a web server and auto-regenerates your site when a file is updated.

Jekyll requires blog post files to be named according to the following format:

YEAR-MONTH-DAY-title.MARKUP

Where YEAR is a four-digit number, MONTH and DAY are both two-digit numbers, and MARKUP is the file extension representing the format used in the file. After that, include the necessary front matter. Take a look at the source for this post to get an idea about how it works.

Jekyll also offers powerful support for code snippets:

def print_hi(name)
  puts "Hi, #{name}"
end
print_hi('Tom')
#=> prints 'Hi, Tom' to STDOUT.

Check out the Jekyll docs for more info on how to get the most out of Jekyll. File all bugs/feature requests at Jekyll’s GitHub repo. If you have questions, you can ask them on Jekyll Talk.

301 Agency

Neural ODE를 이용한 연속적인 계층을 가진 신경망 모델링

Prerequisites

Euler Method

Paper Review

Neural Ordinary Differential Equations (2019.12.14.)

Introduction

Idea

Continuous Backpropagation

Benefits of Neural ODE

Continuous time-series model을 만들 수 있다.

계산의 정확도를 쉽게 조절할 수 있다

Continuous Normalizing Flow 모델 구현

메모리 효율성

Conclusion

Related Works

Augmented Neural ODE

Normalizing Flow

이미지와 텍스트의 표현 공간을 통합한 CLIP 논문 리뷰

Paper Review

Introduction

기존 연구의 한계

Why CLIP?

CLIP의 이미지 및 텍스트 인코더

CLIP의 학습 방법; “Contrastive Learning”

Multi-class N-pair Loss

Code Review

CLIP의 Main Code

Encoders

CLIP의 Training Code

Evolutionary Search를 통해 찾아낸 새로운 Optimizer, Lion.

Paper Review

Introduction

Program search space designing

train function

building blocks

mutations and redundant statements

infinite and sparse search space

Efficient search techniques

Program selection methodology

Proposition: Lion (EvoLved Sign Momentum) Optimizer

Evaluation of Lion

Related Works

Denoising Diffusion Probabilistic Models(DDPM)

Denoising Diffusion Probabilistic Models(DDPM)

Paper Review

Denoising Diffusion Probabilistic Models (DDPM)

Denoising Diffusion Probabilistic Models

Diffusion model introduction

Idea of reverse process & forward process

Loss derivation (Appendix A)

Approximation of $q(x_t\vert x_0)$

Parameterization of $p_{\theta}(x_{t-1}\vert x_t)$

Other source

Helo

Diffusion Model 입문하기

Denoising Diffusion Probabilistic Models 논문 리뷰 (DDPM 설명, DDPM 증명)

Concept. Diffusion Models ( with. DDPM )

Unpaired Image-to-Image Translation using Cycle-Consistent Adversarial Networks

Paper Review

Unpaired Image-to-Image Translation using Cycle-Consistent Adversarial Networks

Unpaired Image-to-Image Translation using Cycle-Consistent…

Introduction

Model Architecture

Code review

Encoding Recurrence into Transformers

Paper Review

Encoding Recurrence into Transformers

Encoding Recurrence into Transformers

Introduction

Model Architecture

Mathmatics

Welcome to Jekyll!

Symbolic Discovery of Optimization Algorithms (2023.5)

Symbolic Discovery of Optimization Algorithms

Introduction

Program search space designing

Efficient search techniques

Program selection methodology

Proposition: Lion (EvoLved Sign Momentum) Optimizer

`train` function