LimePencil's Log

[논문 리뷰] An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale (ViT)

연두색연필 — Mon, 16 Jun 2025 17:03:12 +0900

https://arxiv.org/abs/2010.11929

An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale

While the Transformer architecture has become the de-facto standard for natural language processing tasks, its applications to computer vision remain limited. In vision, attention is either applied in conjunction with convolutional networks, or used to rep

arxiv.org

Introduction

Self-attention 기반의 구조인 Transformers는 원래 자연어 처리(NLP)를 위해 개발되었습니다. 반면, 컴퓨터 비전(CV) 작업에서는 오랜 시간 동안 convolutional neural networks (CNNs)가 지배적이었습니다.

처음에는 self-attention과 CNN을 통합하려는 시도가 좋지 않은 결과를 보였습니다. Vision Transformer (ViT)는 이미지를 패치(patch)로 나누고 (transformer의 토큰(token)과 유사)각 패치를 선형으로 embedding하여 이를 표준 Transformer에 입력하는 새로운 방식을 제시했습니다.

ViT의 문제점

ImageNet과 같은 중간 크기의 데이터셋에서 성능이 좋지 않음
CNN이 가진 inductive biases가 부족:
- Translation equivariance: 입력이 이동하면 출력도 일관되게 이동
- Locality: 공간적으로 인접한 특징을 강조

이런 문제점들은 ImageNet에 더 많은 데이터셋을 추가하여 학습을 하면 더 좋을 성능을 낼 수 있습니다.

Methodology

Architecture of ViT

Patch Embedding:
- 입력 이미지를 겹치지 않는 고정 크기 패치로 나눔
- 각 패치를 벡터로 선형 투영(linear projection)
- $\mathbf{x}_p \in \mathbb{R}^{H \times W \times C} \rightarrow \mathbf{x}_p \in \mathbb{R}^{N \times (P^2 \cdot C)}$, 여기서 $N$ 은 패치의 수
- 각 패치는 일정한 잠재 차원 $D$ 로 투영
Class Token:
- 학습 가능한 분류 토큰 ([CLS])이 입력 시퀀스 앞에 추가됨
- BERT와 유사하게 종합적인 표현을 함
Positional Embedding:
- 공간 순서를 유지하기 위해 1D 학습 가능한 positional embeddings 추가
- 2D positional embeddings는 추가적인 이점이 제한적
Transformer Encoder:
- Multi-headed Self-Attention (MSA)과 MLP 블록이 번갈아 구성
- Residual connections와 LayerNorm 포함
Classification Head:
- 최종 [CLS] 토큰 표현을 MLP를 통해 분류

Architecture

$$
z_0 = [x_{\text{class}}; x_p^1 E; x_p^2 E; \cdots; x_p^N E] + E_{\text{pos}} \tag{1}
$$
$$
E \in \mathbb{R}^{(P^2 \cdot C) \times D}, \quad E_{\text{pos}} \in \mathbb{R}^{(N+1) \times D}
$$
$$
z_{\ell}' = \mathrm{MSA}(\mathrm{LN}(z_{\ell - 1})) + z_{\ell - 1}, \quad \ell = 1, \ldots, L \tag{2}
$$
$$
z_{\ell} = \mathrm{MLP}(\mathrm{LN}(z_{\ell}')) + z_{\ell}', \quad \ell = 1, \ldots, L \tag{3}
$$
$$
y = \mathrm{LN}(z_L^0) \tag{4}
$$

ViT의 Inductive Biases

ViT는 CNN과 같은 명시적인 inductive biases가 없지만, 로컬 및 글로벌 특징을 모두 학습합니다.

MSA는 장거리 의존성(long-range dependencies)을 포착
MLP 층은 로컬 상호작용(local interactions)을 촉진

Hybrid ViT-CNN 아키텍처

낮은 해상도로 사전 학습된(pretrained) ViT는 고해상도 입력으로 Fine-tuning 가능합니다.

패치 크기는 고정되고, 시퀀스 길이가 증가
2D 보간(interpolation)으로 학습된 positional embeddings를 새 입력 해상도에 맞춤

Experimental Results

Experimental Setup

사전 학습 데이터셋:
- ImageNet (1.3M 이미지)
- ImageNet-21k (14M 이미지)
- JFT-300M (303M 이미지)
평가 벤치마크:
- ImageNet, CIFAR-10/100, VTAB (19개 작업), Oxford Pets, Flowers-102
모델 변형(variants):
- ViT-Base, ViT-Large, ViT-Huge
비교 기준:
- ResNet (BiT), Noisy Student (EfficientNet)

Key Findings

성능:
- 큰 데이터셋에서 사전 학습된 ViT는 CNN과 동등하거나 더 우수한 성능을 보임
- ViT-H/14의 성능:
  - ImageNet: 88.55%
  - CIFAR-100: 94.55%
  - VTAB: 77.63%
계산 효율성(Compute Efficiency):
- ViT-H/14는 ResNet 기반 모델보다 적은 계산 자원(2.5k vs. 9.9k TPUv3-core-days)을 사용하며 더 좋은 성능을 보임
데이터 요구 사항:
- ViT는 작은 데이터셋에서 CNN보다 성능이 낮음
- 큰 규모의 데이터로 성능이 현저히 향상됨
확장성(Scalability):
- 모델의 깊이, 너비 또는 패치 크기를 늘리면 성능이 향상됨
- 매우 큰 모델에서도 성능 포화(saturation) 징후가 없음
Few-Shot Learning:
- ViT는 대규모 사전 학습의 혜택으로 Few-shot 분류에서 강력한 성능을 보임
Self-Supervised Learning (Preliminary Results):
- Masked patch prediction은 ImageNet 정확도를 약 2% 향상
- 여전히 supervised 사전 학습에 비해 성능이 낮음
Attention 시각화:
- ViT는 로컬 및 글로벌 attention 패턴을 모두 나타냄
- Positional embeddings는 명시적 구조가 없어도 공간적 토폴로지를 포착

Conclusion

Vision Transformers는 이미지 특유의 inductive biases가 없지만, 큰 데이터셋에서 훈련될 경우 CNN과 비교하여 우수한 성능을 달성하고 있습니다. 확장성과 계산 효율성이 뛰어나며 Few-shot 및 Self-supervised 학습에서도 효과적입니다. Local and global dependency을 모델링할 수 있어 향후 CV문제들에 유망한 아키텍쳐입니다.

[논문 리뷰] Grandmaster level in StarCraft II using multi-agent reinforcement learning (AlphaStar)

연두색연필 — Sat, 13 Jul 2024 00:30:06 +0900

오늘은 학교에서 리뷰했던 논문을 블로그로 정리해보려고 한다. 이번 논문은 강화학습으로 스타크래프트 2를 학습을 하여 그랜드마스터의 MMR을 가진 agent를 만들었다. 알파고와 마찬가지로 네이쳐에 올라왔으며, 아주 복잡한 환경에서 강화학습을 어떻게 진행했는지를 아주 잘 보여주고 있다.

Grandmaster level in StarCraft II using multi-agent reinforcement learning | Nature

스타크래프트란?

스타크래프트는 고난도의 전술을 세우면서 각 유닛들을 조종해야 하는 게임이다. 3가지 종족이 있고, 작은 베이스에서 시작해서 점점 빌딩을 짓고 유닛을 만들면서 상대방의 건물들을 부수면 이기는 게임이다.

왜 DeepMind는 스타크래프트를 골랐을까

사실 간단히 생각해 보면 더욱더 challenging 한 환경이었기 때문이라고 볼 수 있다. 알파고 같은 경우에는 371개의 action space가 있고 모든 정보가 주어져있는 심플한 환경이다. 하지만 스타크래프트 2는 10^26의 action space가 있고, 모든 정보가 주어져 있지 않는 고난도의 환경이다. 스타 2에서 API를 제공해서 그렇다고 생각해 볼 수도 있지만 스타크래프트는 전술게임 중에는 상당히 난도가 높고 조작이 어려운 환경이라고 할 수 있다.

Agent Input Space

Agent Action Space

이 두 표를 보면 얼마나 어려운 일인지를 알 수 있다. 10^26의 action space는 간단한 방법으로 explore 하거나 학습을 하기에는 무리가 있고, 이렇기 때문에 특별한 방법을 사용하여야 한다 이에 대해서는 추후에 서술하도록 하겠다. 특이한 점은 이 논문이 봇들처럼 엄청나게 높은 APM(action per minute)을 주거나 카메라 밖의 시야를 주지 않았다는 것이다. 즉, 인간과 같거나 더 높은 제한을 두고 학습을 시켰기 때문에 사람의 피지컬을 가지고 어떤 전술을 만들었는지 볼 수 있다.

AlphaStar에서의 policy

정책은 deep neural network로 만들어졌고, 이 정책의 input은 그 전의 action과 observation이다. 또한 특이하게 전술 지표 z라는 것을 도입하였는데, 이는 게임 플레이어들의 처음 20개의 건물을 짓는 순서이다. 이 z를 사용하면서 초반의 비효율적인 시행착오를 스킵할 수 있다.

AlphaStar의 아키텍처

공간 정보 = feature map (CNN과 유사)

유닛 정보 = feature vectors

self-attention(transformer)을 사용하여 유닛과 attribute 사이의 관계를 프로세스 하기 위해 사용하였고, 이를 통해 다양한 관찰된 부분들을 dynamic 하게 집중할 수 있다

LSTM(Long short-term memory) = 시간의 변화에 따른 정보들을 처리한다 즉 context를 제공한다고 볼 수 있다

Hierarchical Action Representation = 액션 종류, 액션 매개변수, 그리고 auto-regressive 정책을 사용하여 순서대로 내려오면서 어떤 행동이 실행될지를 결정한다

Recurrent Pointer Network = 땅이나 유닛처럼 마우스 클릭으로 타깃을 선택해야 할 때 사용한다

Scatter Connection = 공간 정보와 비공간 정보 두 개를 합치는 방식인데, 이를 사용하여 벡터들을 공간에 흩어지게 하여 벡터들(ex 유닛들의 정보)을 위치에 corresponding 하게 바꾸어준다. 즉, 위치와 정보를 합친다고 보면 된다.

성능이 올라가는 것을 볼 수 있다

전체 아키텍쳐 구조 (상당히 다양한 종류의 모델들이 사용되었다)

Supervised Learning in AlphaStar

논문에서는 먼저 사람의 데이터를 사용하여 지도학습을 진행하였는데, 모방학습을 진행하였다고 볼 수 있다. 이렇게 하는 이유는 AlphaGo Zero 같은 경우는 action space가 그렇게 크지 않아서 그냥 학습을 진행할 수 있겠지만, 스타크래프트 같은 복잡한 환경은 그렇게 한다면 exploration에만 시간을 쓰게 되어서 성능이 좋아지지 않는다. 그래서 초반에 이런 사람이 플레이하는 것을 학습하면서 이를 해결할 수 있다.

사용된 데이터는 97만 개의 상위 22프로의 플레이들을 학습하였다. 그리고 정책은 사람이 다음 action을 어떤 것을 할지 예측하는 방식으로 학습하였다. 정책의 output은 확률분포로 나오고, KL-divergence로 사람과 agent 간의 차이를 계산한다. Adam optimizer이랑 L2 정규화가 사용되었다.

파인 튜닌은 MMR 6200 이상의 플레이어들을 사용하여 더 좋은 전략들을 학습할 수 있게 하였다.

Reinforcement Learning in AlphaStar

이렇게 initialize 된 정책들은 self-play와 league training을 통해 강화학습으로 더 학습을 진행한다. 보상 같은 경우에는 이기면 +1, 지면 -1, 동점은 0이다. 이렇게 sparse 하게 주어진 reward는 학습이 어렵기 때문에 전술 z를 따라가면 pseudo-reward를 부여한다. Temporal-difference learning을 사용하여 value-function을 학습하고, v-trace와 UPGO를 사용하여 policy function을 학습하였다. 또한, KL-divergence를 사용하여 supervised policy와 벗어나지 않도록 정책을 학습시킨다.

League training

Multi-Agent Learning: competes against various versions of itself and other agents.

League Training: AlphaStar uses a league of agents to ensure diverse and robust training.main agents: learn strategies by playing against various opponents, including its past versions, other main agents, and exploiters
main exploiters: accelerate the main agent’s learning by presenting it with difficult and targeted challenges.
league exploiters: exploit weaknesses not only in the main agent but in other agents within the league as well.

Limitation of self-play:

1. Cycle of Strategies:

can lead to cycles where the agent repeatedly switches between a set of strategies without progressing.
occurs when an agent learns a strategy to defeat its current opponent, then the opponent learns a counter-strategy, and the cycle continues without overall improvement.
Ex) In StarCraft II, the agent might oscillate between aggressive rush tactics and defensive strategies without finding a stable, superior strategy.

2. Lack of Diversity:

the agent predominantly learns to counter its own strategies.
vulnerable to novel strategies that it has not encountered during training.

Types of Self-Play

Fictitious Self-Play(FSP): avoids cycle by playing with all players in the league

too much waste of resources against agents with 100% win rate

Prioritized Fictitious Self-Play(PFSP): put weights on the matchmaking in the league to provide a good learning signal

using 2 different curricula, it can improve by fighting with hard opponents and opponents around its level

Agents in AlphaStar

Main agent is trained on 35% SP, 50% PFSP against all past players in the league, and an additional 15% of PFSP matches against forgotten main players the agent can no longer beat and past main exploiters.

copy of the main agent is added as new play in league every 2 billion steps

League exploiters are trained using PFSP and their frozen copies are added to the league when they defeat all players in the league in more than 70% of games, or after a timeout of 2 billion steps.

a 25% probability that the agent is reset to the supervised parameters.
- because league agents are not robust themselves

Main exploiters play against main agents.

50% of the time when the current probability of winning is lower than 20%, exploiters use PFSP with fvar weighting over players created by the main agents, forming curriculum that facilitates learning
Otherwise there is enough learning signal and it plays against the current main agents. These agents are added to the league whenever all three main agents are defeated in more than 70% of games, or after a timeout of 4 billion steps, then reset to the supervised parameters.

Restriction on Agents

1. Action per Minute (APM) Limits: executing at most 22 non-duplicate actions every 5 seconds.

2. Delay in Actions: Human players experience a delay between perceiving the game state and executing an action.

There is an average delay of about 110 milliseconds between the command of action and the actual execution
Also, agents decide when to observe next (avg. 370ms)

3. Camera Interface: Human players control the game through a screen interface, limited by what they can see and interact with at any given time.

could only act on information visible within the camera view.

Results

이것을 보면 Main Agent가 성능이 상당히 높은 것을 보여주고 있다. Main exploiter 같은 경우에는 성능이 오르지 않고 있는데, 이는 main agent만 상대하면 되기에 general 한 성능을 보여줄 필요가 없다. 이 논문을 통해 large-scale에서 어떻게 강화학습을 진행해야 하는지 알 수 있는 실험이었다고 생각한다.

Grandmaster-level-in-StarCraft-II-using-multi_agent.pdf

7.66MB

[SQL 배우기] Section 8. Creating Databases and Tables

연두색연필 — Tue, 12 Mar 2024 01:03:59 +0900

Data types in SQL:

Boolean
- True, False
Character
- char, varchar, text
Numeric
- integer, float
Temporal
- date, time, timestamp, interval
UUID
Array
JSON

PostgreSQL: Documentation: 16: Chapter 8. Data Types

Primary key: a column or a group of columns used to identify a row uniquely in a table\

represented by [PK] in pgAdmin

Foreign key: a field or group of fields that references the primary key of the other table

Constraint: rules enforced on data columns table

prevent invalid data
Divided into Column constraint and Table constraint:
Common Column constraint:
- NOT NULL constraint
- UNIQUE constraint
- PRIMARY Key
- FOREIGN Key
- CHECK constraint
  - ensures that all values in a column satisfy certain conditions
- EXCLUSION constraint
  - ensures that if any two rows are compared on the specified column or expression using the specified operator, not all of these comparisons will return TRUE
Common Table constraint:
- **CHECK (**condition)
  - to check conditions when inserting or updating data
- REFERENCES
  - to constrain the value stored in the column that must exist in a column in another table
- UNIQUE (column_list)
  - forces the values stored in the columns listed inside the parentheses to be unique
- PRIMARY KEY (column list)
  - allows you to define the primary key that consists of multiple columns

The general syntax for creating a table:

CREATE table table_name ( column_name TYPE column_constraint, column_name TYPE column_constraint, table_constraint table_constraint ) INHERITS existing_table_name;

SERIAL: creates a sequence object and sets the next value generated by the sequence as the default value for the column

perfect for PRIMARY key
does not adjust for deletion

INSERT: allow to add rows to a table

general syntax: INSERT INTO table (column1, column 2, …) VALUES (value1, value2, …), (value1, value2, …), ….;
SERIAL columns do not need to be provided a value

UPDATE: allows change of values of the columns

general syntax: UPDATE table SET column1 = value1, column2 = value2, … WHERE condition;
without WHERE, everything is reseted
update from another table: UPDATE tableA SET original_col = tableB.new_col FROM tableB WHERE tableA.id = tableB.id
return affected rows UPDATE table SET column=value RETURNING column1, column2

DELETE: remove rows from the table

DELETE FROM table WHERE row_id = 1
DELETE FROM tableA USING tableB WHERE tableA.id = tableB.id

ALTER: allows for changes to an existing table structure

adding, dropping, or renaming columns
changing a column’s data type
set DEFAULT values for a column
Add CHECK constraints
Rename table
General Syntax ALTER TABLE table_name action

DROP: allows the complete removal of a column in a table

General Syntax ALTER TABLE table_name DROP COLUMN col_name

CHECK: allows the creation of more customized constraints that adhere to a certain condition

[SQL 배우기] Section 6. Advanced SQL Commands

연두색연필 — Tue, 12 Mar 2024 01:02:30 +0900

The Complete SQL Bootcamp for the Manipulation and Analysis of Data | Udemy

Types of time information:

TIME: time
DATE: date
TIMESTAMP: time, date
TIMESTAMPTZ: date, time, and timezone

The time information cannot be added although it can be removed

SHOW ALL: shows all the metadata related to the database

can show other details by using other functions such as:

SHOW TIMEZONE
SELECT NOW()
SELECT TIMEOFDAY()
SELECT CURRENT_TIME
SELECT CURRENT_DATE

EXTRACT(): allows the user to obtain a sub-component of a date value

EXTRACT(YEAR FROM date_col)

AGE(): calculates and returns the current age given a timestamp

AGE(date_col)

TO_CHAR(): function to convert data types to text

TO_CHAR(date_col,’mm-dd-yyyy’)
PostgreSQL: Documentation: 12: 9.8. Data Type Formatting Functions

Mathematical functions and operators:

can be used to perform mathematical operations on columns
PostgreSQL: Documentation: 9.5: Mathematical Functions and Operators

String functions and operators:

can perform manipulations on strings
PostgreSQL: Documentation: 9.1: String Functions and Operators

Subquery: can construct complex queries, by performing a query on the result of another query

involves two SELECT statement
involves parentheses that contain a SELECT statement
EXISTS: used to test for the existence of rows in a subquery
- SELECT column_name FROM table_name WHERE EXISTS (SELECT column_name FROM table_name WHERE condition)

Self-join: joining within the same table as if the tables are different

SELECT tableA.col, tableB.col FROM table AS tableA JOIN table AS tableB ON tableA.some_col = tableB.other_col
requires the use of an alias

[SQL 배우기] Section 5. JOINS

연두색연필 — Tue, 12 Mar 2024 01:00:56 +0900

The Complete SQL Bootcamp for the Manipulation and Analysis of Data | Udemy

AS: creates an alias for a column to be called into a different name

SELECT column AS new_name FROM table
we cannot use an alias inside the WHERE operator because it gets executed at the very end of a query
useful for renaming the output of the aggregate function

JOIN: allows to combine multiple tables

main reason for different JOIN types is to decide how to deal with information only present in one of the joined tables

INNER JOIN: result with the set of records that match in both tables

SELECT * FROM tableA INNER JOIN tableB ON tableA.col_match = tableB.col_match
symmetrical
matching column is a duplicate column
in PostgreSQL, JOIN = INNER JOIN

FULL OUTER JOIN: set of records that are in either or both of the tables

SELECT * FROM tableA FULL OUTER JOIN tableB ON tableA.col_match = tableB.col_match
Symmetrical
filling empty values with null
using WHERE can be used to filter null columns

LEFT OUTER JOIN: set of records that are in the left table, and values that are not in the right table are considered null

SELECT * FROM tableA LEFT JOIN tableB ON tableA.col_match = tableB.col_match
Order matters

RIGHT OUTER JOIN: set of records that are in the right table, and values that are not in the left table are considered null

SELECT * FROM tableA RIGHT JOIN tableB ON tableA.col_match = tableB.col_match
Order matters

UNION: concatenating two tables together

SELECT column_names FROM table1 UNION SELECT column_names FROM table2
should match in length

[SQL 배우기] Section 3. GROUP BY Statements

연두색연필 — Tue, 12 Mar 2024 00:58:02 +0900

Aggregate function: take multiple inputs and return a single output

AVG(), COUNT(), MAX(), MIN(), SUM()
can only happen in the SELECT or HAVING clause
ordering result of the aggregate function requires ORDER BY reference to the entire function

GROUP BY: allows for the aggregation of columns by some category

must appear right after a FROM or WHERE statement
you can use an aggregate function with it
in the SELECT statement, columns must either have an aggregate function or be in the GROUP BY call
WHERE statement should not refer to the aggregation result

HAVING: allows for filtering after aggregation

WHERE cannot be used to filter based on aggregated results

[SQL 배우기] Section 2. SQL Statement Fundamentals

연두색연필 — Tue, 12 Mar 2024 00:56:56 +0900

The Complete SQL Bootcamp for the Manipulation and Analysis of Data | Udemy

SELECT: most common statement used to retrieve information from a table

SELECT column_name FROM table_name
- using * instead of the column name retrieves all the columns
- separate column names by a comma for multiple columns
using capital letters for SQL keywords helps with visualization

SELECT DISTINCT: used to return distinct values in columns

SELECT DISTINCT column_name FROM table_name
- parenthesis can be used around column name for better clarity

COUNT: returns the number of input rows that match a specific condition of a query

SELECT COUNT (column_name/results) FROM table_name;
- needs parenthesis
SELECT COUNT(*) FROM table_name
- returns the number of rows in a table
more useful when used with keywords like DISTINCT

SELECT WHERE: allows to specify conditions on columns for the rows to be returned (filtering

SELECT column_names FROM table_names WHERE conditions
Comparison operators
- =,>,<,>=,<=, (<> or !=)
Logical operators
- AND, OR, NOT

ORDER BY: sort rows based on a column value (ascending or descending)

SELECT columns FROM table ORDER BY columns ASC/DESC

LIMIT: limit the number of rows returned for a query

LIMIT num_of_rows
only viewing a few rows to get an idea of the table
useful with ORDER BY
goes to the end of the query

BETWEEN: used to match a value against a range of values

value BETWEEN low AND high
- inclusive
- can be used with dates when it is in YYYY-MM-DD format

IN: creates a condition to check if a value is included in a list of options

value IN (option1, option2, option3, option_n)

LIKE: pattern matching with string data using wildcard characters

%
- matches any sequence of characters
- putting % in the back of the character is looking for matching in the beginning, and vice versa
_
- matches any single character (replacing a single character)
- can use multiple underscores

ILIKE: case-insensitive version of LIKE

[SQL 배우기] Section 1. Course Introduction

연두색연필 — Tue, 12 Mar 2024 00:53:51 +0900

The Complete SQL Bootcamp for the Manipulation and Analysis of Data | Udemy

Database: systems that allow users to store and organize large amounts of data

made up of tables that consist of columns and rows

SQL(Structured Query Language): programming language used to communicate with the database

pgAdmin: a Query Tool can be used to perform queries on the database

[Kubernetes 배우기] Section 9. Kubernetes on Cloud

연두색연필 — Tue, 9 Jan 2024 15:11:22 +0900

Kubernetes for the Absolute Beginners - Hands-on | Udemy

The hosted cloud solution allows for the maintenance of VMs, which makes it easy to scale and manage.

Microsoft Azure
Amazon AWS
Google Cloud

Google Kubernetes Engine (GKE)

The cluster can be created easily by configuring it in the Google Cloud console

The load balancer is configured automatically by using Google’s load balancer.

Amazon Elastic Kubernetes Service (EKS)

Azure Kubernetes Service (AKS)

[Kubernetes 배우기] Section 8. Microservices Architecture

연두색연필 — Tue, 9 Jan 2024 15:08:29 +0900

Kubernetes for the Absolute Beginners - Hands-on | Udemy

Each stack of the applications can be separated into different containers to be individual microservices.

docker run --links: connects the docker containers by name

Service is created to connect between pods for microservices. (Use NodePort and ClusterIP)

service is not needed for ports that do not require exposed port

[Kubernetes 배우기] Section 7. Services

연두색연필 — Tue, 9 Jan 2024 12:53:04 +0900

Kubernetes for the Absolute Beginners - Hands-on | Udemy

Services enable loose coupling between microservice Kubernetes setups.

It forwards requests to a port to another port

Types of services:

NodePort: internal port accessible to external port
ClusterIP: virtual IP inside a cluster to connect applications
LoadBalancer: distribute work among different pods

NodePort

NodePort consists of 3 ports where they are connected all together

TargetPort: port of the pod
Port: port of the service
NodePort: port of the node

To link the service to the pod, the section under the “label” of the pod must go under the selector section of the service definition file.

kubectl get services: get a list of services in Kubernetes

A random algorithm balances the request load when multiple pods of the same label are assigned to the service.

when the pods are distributed across different nodes, Kubernetes automatically configures service for all the nodes

ClusterIP

Services can be created for each application so that Kubernetes will configure which pod of the service will be connected to another pod of other services.

This way, the user does not have to configure for IP address of each pod
Effective for microservices

LoadBalancer

Setting the service type as LoadBalancer automatically configures one external IP/domain for the end user to easily access cloud services like GCP, Azure, and AWS.

instead of having 4 URLs for each of the pods, a single load balancer can give the user access to a single URL.

[Kubernetes 배우기] Section 6. Networking in Kubernetes

연두색연필 — Tue, 9 Jan 2024 12:49:46 +0900

Kubernetes for the Absolute Beginners - Hands-on | Udemy

An internal IP address is assigned to a pod.

For multiple nodes, the internal network IP is the same for pods in different nodes, so custom configurations must be made for networking.

All containers can communicate with one another without NAT(using an IP address)
All nodes can communicate with all containers and vice versa without NAT

There are many solutions for networking in Kubernetes.

This allows the routing of the network to a virtual network which redirects.

[Kubernetes 배우기] Section 5. Kubernetes Concepts - Pods, ReplicaSets, Deployments

연두색연필 — Tue, 9 Jan 2024 12:38:59 +0900

Kubernetes for the Absolute Beginners - Hands-on | Udemy

Pods

The Kubernetes pod definition file contains 4 top-level fields:

apiVersion
- the version of Kubernetes version used
kind
- the kind of service that is created
  - ex) Pod, Service, ReplicaSet, Deployment
metadata
- data of the object such as name and labels
  - under label property, we can set whatever key-value pair we want
spec
- where containers are defined along with their image and name

kubectl apply -f [name of the file].yaml: creates pod according to the YAML file in the argument

Replication Controllers and ReplicaSets

Replication Controller: allows running of multiple pods of the same image for high availability

ensures a specified number of pods are running at a time
can span across multiple nodes to scale the application
in the spec section of the YAML file
- template: The YAML file of the pod is copied
- replicas: the number of replicas is specified

ReplicaSets: newer technology that is replacing replication controllers

apiVersion needs to be specified as apps/v1
spec section is almost the same except that there is one more field to it
- selector: monitors pods with specified labels unlike replication controllers
  - so if pods of the same labels are already running when ReplicaSets are created, it does not create a new one until one fails

Scaling ReplicaSet:

change the replica filed of the YAML file and run kubectl replace -f [filename]
use kubectl scale --replicas=[number of replicas] -f [filename] command

Deployment

Rolling Updates: Upgrading instances one by one to maintain availability

two ReplicaSets

Deployment: wraps around ReplicaSet to update the instance seamlessly and control changes

The definition file is almost the same as ReplicaSet except that the section for kind is changed to Deployment.

kubectl get all: lists all the objects created in the Kubernetes such as pods, ReplicaSets, deployments

Rollout is triggered when a new deployment is created.

the revision number increases when there is a newer version
- this allows us to keep track of the revision history

kubectl rollout status [deployment name]: see the current status of the rollout

kubectl rollout history [deployment name]: see the history of the deployment

Deployment strategy:

(Bad) Destroying all the instances and creating updated new instance
1. (Good) Taking down one instance and bringing up a new instance for availability (Rolling Update)

kubectl apply -f [YAML file name]: updates the current running instance to a newer version

kubectl rollout undo [deployment name]: goes back to older format by destroying the current instance

[Kubernetes 배우기] Section 4. YAML Introduction

연두색연필 — Tue, 9 Jan 2024 12:31:25 +0900

Kubernetes for the Absolute Beginners - Hands-on | Udemy

YAML: data representation format like JSON

Key-Value Pair

Fruit: Apple
Vegetable: Carrot
Liquid: Water

Array/Lists

Fruits:
- Orange
- Banana
- Apple

Dictionary/Map

Banana:
	Calories: 105
	Fat: 0.4g
	Carbs: 27g

The spacing in front of each item must be equal. If the spacing is different, it is treated as a sub-dictionary.

Order is important for arrays, unlike dictionaries.

[Kubernetes 배우기] Section 3. Kubernetes Concepts

연두색연필 — Tue, 9 Jan 2024 11:57:55 +0900

Kubernetes for the Absolute Beginners - Hands-on | Udemy

Kubernetes pods: a single instance of the application that encapsulates containers

to bring up more instances of an application, the number of pods must be increased
the smallest unit in Kubernetes

A single pod can have multiple containers of different types. It can include helper containers.

within the same pod, they can interact with each other with the local network and share the same storage space
when the pod dies, all the containers inside it die

kubectl run [name] --image [image name]: initiates single pod of an image

kubectl get pods: get the information of pods

-o wide option shows where the node is running

kubectl describe pod [name of pod]: explains in detail about a single pod

[Kubernetes 배우기] Section 2. Kubernetes Overview

연두색연필 — Tue, 9 Jan 2024 11:56:47 +0900

Kubernetes for the Absolute Beginners - Hands-on | Udemy

Node: machine where Kubernetes is installed

Cluster: Group of nodes

Master node: Another node that controls cluster(worker nodes)

kube-APIserver is installed

Worker node: where the actual computation is going on

kubelet is installed

Components of Kubernetes:

API server: where the user interacts to control the Kubernetes server
etcd: distributed key-value storage
kubelet: agent in each node that checks if the worker node is running as expected
Container Runtime: software to run container (ex. Docker)
Controller: checks for container status(whether it is down), and brings out new containers if needed
Scheduler: distributing load across nodes and containers

Container runtime and kubelet are in the worker node while other components are in the master node.

kubectl: used to deploy and manage applications on the Kubernetes cluster

kubectl run: deploy an application on the cluster

kubectl cluster-info: get information about the cluster

kubectl get nodes: get nodes in the cluster

[Docker 배우기] Section 9. Container Orchestration - Docker Swarm & Kubernetes

연두색연필 — Fri, 22 Dec 2023 00:04:20 +0900

Docker for the Absolute Beginner - Hands On - DevOps | Udemy

Container Orchestration is used to host multiple containers over multiple hosts by using scripts and codes.

Some solution scales containers automatically and even scale hosts

Famous container orchestration solutions:

Docker Swarm
Kubernetes
Mesos

Docker Swarm

Distributes containers over many hosts for higher availability and load balancing

In order to set up a docker swarm, one of the hosts must be a swarm manager while the others are workers.

Running docker swarm init in the swarm manager starts docker swarm and provides instructions to set up other workers

docker service create --replicas=[number of containers]: runs determined amount of containers distributed across worker nodes

Kubernetes

kubectl run --replicas=[number of containers]: runs replica of container across multiple nodes

kubectl scale: scales container by a determined amount

Kubernetes can automatically scale up and down based on the load.

Allows rolling back
Various authentication methods

Nodes are grouped by cluster and it is controlled by the master node.

[Docker 배우기] Section 8. Docker on Mac & Windows

연두색연필 — Thu, 21 Dec 2023 23:36:23 +0900

Docker for the Absolute Beginner - Hands On - DevOps | Udemy

Working on Docker on Windows:

Docker toolbox
1. virtual box for VM (Oracle)
Docker Desktop for Windows
1. uses Microsoft Hyper-V as a virtual box
Windows containers
1. Windows Server containers
  1. one VM for various containers
2. Hyper-V isolation
  1. running within each VM

Working on Docker on Mac:

Docker toolbox
1. virtual box for VM (Oracle)
Docker Desktop for Mac
1. use HyperKit virtualization technology

[Docker 배우기] Section 7. Docker Engine, Storage, and Networking

연두색연필 — Thu, 21 Dec 2023 23:33:14 +0900

Docker for the Absolute Beginner - Hands On - DevOps | Udemy

Docker Engine

Docker Engine is composed of:

Docker CLI: running command
- does not have to be on the same machine with other parts
  - can use the docker -H option to connect to the remote docker-engine
REST API: interact with docker Deamon
Docker Deamon: running in the background to execute tasks

PID: id for a process that is unique to the process

PID can have the same name for both the system and the container, but the PID in the container is changed into a different PID on the system

There is no limit to how much a container can utilize the resources.

using --cpus and --memory in the docker run can limit the resources used by a container

Docker Storage

By using layered architecture, it greatly reduces the storage size by reusing the existing layer.

When a container is running, a new layer called “container layer” is put on top of other layers where modifications can happen.

The container layer is read/write while image layers are read only.
- To modify a file in image layers, it is copied to the container layer before writing

docker volume: used to create volume in the docker file system which can be connected to the container layer later on

mounting volume without creating it creates the
docker run -v [local]:[internal]

Docker Network

Mapping the network of the container to the host allows it to share the same port with the host.

docker network create: used to create another internal network within the docker host.

docker network ls: lists all network

By using docker inspect, the network of a container can be checked.

Docker has a built-in DNS server that allows to access another container by name and not internal IP addresses

[Docker 배우기] Section 6. Docker Registry

연두색연필 — Thu, 21 Dec 2023 23:29:23 +0900

Docker for the Absolute Beginner - Hands On - DevOps | Udemy

Image naming convention: [User]/[Image]

ex) nginx/nginx

docker registry: where images are stored online

GCR(Google Container Registry), docker hub
private registry can be accessed using docker login
one can set up a docker registry in a private machine by running a registry container

[Docker 배우기] Section 5. Docker Compose

연두색연필 — Thu, 21 Dec 2023 22:46:34 +0900

Docker for the Absolute Beginner - Hands On - DevOps | Udemy

docker-compose: allows to run and manage multiple containers with a single YAML file

dictionary with the image name, and under each image name, put parameters as key-value pairs
putting build under the image name builds the image first before running the container
by using version 2 of docker-compose, the images are all linked
- need to specify version: 2 on the top
- can add depend_on: under the image name to show dependency between containers
by using version 3, docker swarm can be used

docker run --link [host: internal]: links containers with each other so that it is accessible within a container

networks can be set as the argument by specifying the network under the image name

docker-compose up: runs all the containers specified in the YAML file

References:

https://docs.docker.com/compose/

https://docs.docker.com/engine/reference/commandline/compose/

https://github.com/dockersamples/example-voting-app

[Docker 배우기] Section 4. Docker Images

연두색연필 — Thu, 21 Dec 2023 22:37:48 +0900

Docker for the Absolute Beginner - Hands On - DevOps | Udemy

Dockerfile can be used to make a custom docker image.

FROM: starting image from another image
RUN: executes certain commands behind it
COPY: copy certain files to the image
ENTRYPOINT: specify a command that runs when the container is started
- the parameter can be delivered by appending the parameter to docker run
ENV: specify environmental variable
- can also be used as docker run -e [variable]
CMD: specifies the command to run when docker starts, but unlike ENTRYPOINT, it can be overwritten when docker run

docker build: used to create a docker image from Dockerfile

the commands in the Dockerfile are made into layers that build on top of each other
- faster rebuild due to caching

docker push: pushes the image to the public hub

[Docker 배우기] Section 3. Docker Run

연두색연필 — Thu, 21 Dec 2023 22:28:22 +0900

Docker for the Absolute Beginner - Hands On - DevOps | Udemy

docker run with tag: by putting: after the image name allows for the specification of version/tag

if not specified, the latest tag is used

docker run -i: open the container with an interactive mode where input is possible

docker run -it: open the container with an interactive mode where input is possible and the console turns into a pseudo-terminal

docker run -p [local port]:[internal port]: maps the port to an internal port

docker run -v [local directory]:[internal directory]: maps the volume to an internal volume so that the data will not be erased even if after the container is exited

docker inspect: used to find details about a container

docker logs: allows to view the logs of a container

useful for background running container

[Docker 배우기] Section 2. Docker Commands

연두색연필 — Wed, 20 Dec 2023 19:28:59 +0900

Docker for the Absolute Beginner - Hands On - DevOps | Udemy

docker run: runs the container

downloads the image if it is not locally stored
appending a command behind allows execution of the command after running the container
running the container with -d tag allows it to run in the background and not on the console

docker ps: lists current running containers

by adding -a, it also shows stopped or exited containers

docker stop: stops a running container by ID or name

docker rm: remove a container

not able to be seen with docker ps -a

docker images: lists current downloaded images

docker rmi: removes downloaded image by name

docker pull: downloads an image without running it

The container runs as long as the process inside is running. The completed process exits the container.

docker exec: executes the command to a running container

docker attach: attaches to a running background container

[Docker 배우기] Section 1. Introduction

연두색연필 — Tue, 19 Dec 2023 22:03:49 +0900

Docker for the Absolute Beginner - Hands On - DevOps | Udemy

Docker Overview

Docker allows to run each service with its dependencies in separate containers.

Containers: a completely independent environment that runs on OS kernels

ex) Linux kernel: allows to run CentOS, Fedora, etc
Cannot run Windows container on Linux kernel

VM vs Containers

VM	Container
Uses Hypervisor	Uses container engine
Multiple OS	Single OS
Heavy Utilization and Size	Light in size and utilization
Slow Booting	Fast Booting
Resources are independent	Resources can be shared

Containers and VMs can be used together to use the good side of both.

Docker image: template of container

Like a class in programming
Can be pushed to the Docker Hub for public availability
Guarantees the environment runs in the same way everywhere

Docker container: instances of image

Like objects in programming

Docker can be installed by following the instructions below.

Install Docker Engine | Docker Docs

[The Rust Programming Language] Ch. 3: Common Programming Concepts Variables and Mutability

연두색연필 — Sun, 5 Nov 2023 22:05:11 +0900

3.1 Variables and Mutability

By default, variables are immutable.

Once the variable is set to immutable, you cannot change the value. Rust automatically finds the error and tries to fix it before compiling it.

fn main() {
    let x = 5;
    println!("The value of x is: {x}");
    x = 6;
    println!("The value of x is: {x}");
}

$ cargo run
   Compiling variables v0.1.0 (file:///projects/variables)
error[E0384]: cannot assign twice to immutable variable `x`
 --> src/main.rs:4:5
  |
2 |     let x = 5;
  |         -
  |         |
  |         first assignment to `x`
  |         help: consider making this binding mutable: `mut x`
3 |     println!("The value of x is: {x}");
4 |     x = 6;
  |     ^^^^^ cannot assign twice to immutable variable

For more information about this error, try `rustc --explain E0384`.
error: could not compile `variables` due to previous error

Rust compiler exactly pinpoints where and what the error is. This ensures bugless code.

fn main() {
    let mut x = 5;
    println!("The value of x is: {x}");
    x = 6;
    println!("The value of x is: {x}");
}

adding mut in front of the variable’s name makes it so that the value of the variable can be changed.

Constants

const THREE_HOURS_IN_SECONDS: u32 = 60 * 60 * 3;

constants: values that are bound to a name and not allowed to change. It is stated by const statement.

mut is not able to be used with consts
convention of the naming is to use uppercase and underscore between words.
valid for the entire time a program runs, within the scope in which they were declared.

Shadowing

Shadowing: declaring a new variable with the same name as a previous variable

fn main() {
    let x = 5;

    let x = x + 1;

    {
        let x = x * 2;
        println!("The value of x in the inner scope is: {x}");
    }

    println!("The value of x is: {x}");
}

When applying shadowing in the inner scope, the variable only temporarily shadows the variable of the outer scope.

It is different with mut because shadowing is creating a new variable by using the let keyword.

3.2 Data Types

Rust is a statically typed language, which means that it must know the types of all variables at compile time.

the compiler usually can infer the data type, but for some cases like parse, the type of the variable must be explicitly stated with :.
let guess: u32 = "42".parse().expect("Not a number!");

Data type subsets in Rust:

Scalar
1. Integers
2. Floating-point numbers
3. Booleans
4. Characters
Compound
1. Tuples
2. Arrays

Scalar Types - Integers

Length	Signed	Unsigned
8-bit	i8	u8
16-bit	i16	u16
32-bit	i32	u32
64-bit	i64	u64
128-bit	i128	u128
architecture	isize	usize

The size of usize and isize is dependent on whether the computer’s architecture is 32-bit or 64-bit.

Integer literal can be written in many forms. (Refer to table below)

Number literals	Example
Decimal	98_222
Hex	0xff
Octal	0o77
Binary	0b1111_0000
Byte (u8 only)	b'A'

To avoid overflow and underflow, the following methods can be used.

Wrap in all modes with the wrapping_* methods, such as wrapping_add.
Return the None value if there is an overflow with the checked_* methods.
Return the value and a boolean indicating whether there was overflow with the overflowing_* methods.
Saturate at the value’s minimum or maximum values with the saturating_* methods.

Scalar Types - Floating-Point Types

Rust’s floating-point types are f32 and f64, which are 32 bits and 64 bits in size.

IEEE-754 standard

Scalar Types - The Boolean Type

Specified by bool, the possible values are true and false.

Scalar Types - The Character Type

char type is the alphabetic type of Rust. Char literal can be specified by using a single quote.

Compound Types - The Tuple Type

fn main() {
    let tup: (i32, f64, u8) = (500, 6.4, 1);
}

A tuple is a general way of grouping together a number of values with a variety of types into one compound type

fixed in size
wrapped in brackets and separated by comma

fn main() {
    let tup = (500, 6.4, 1);

    let (x, y, z) = tup;

    println!("The value of y is: {y}");
}

Pattern matching can be used to destructure a tuple.

fn main() {
    let x: (i32, f64, u8) = (500, 6.4, 1);

    let five_hundred = x.0;

    let six_point_four = x.1;

    let one = x.2;
}

A tuple element directly by using a period (.) followed by an index

unit: tuple with empty value

returned by expression if it does not return any other value

Compound Types - The Array Type

Array: collection of values with the same type.

used inside a comma-separated square bracket
have fixed length

let a: [i32; 5] = [1, 2, 3, 4, 5];

An array’s type is written using square brackets with the type of each element, a semicolon, and then the number of elements in the array

let a = [3; 5]; //let a = [3, 3, 3, 3, 3];

Initializing with the same value for all values in an array.

// accessing element with index
fn main() {
    let a = [1, 2, 3, 4, 5];

    let first = a[0];
    let second = a[1];
}

Trying to access an index that is not within the length of the array will result in a **runtime error**.

3.3 Functions

fn main() {
    println!("Hello, world!");

    another_function();
}

fn another_function() {
    println!("Another function.");
}

fn keyword is used to declare a function.

snake case is the normal convention for naming a function
a function with the name main is an entry point for most programs.

Parameters

fn main() {
    print_labeled_measurement(5, 'h');
}

fn print_labeled_measurement(value: i32, unit_label: char) {
    println!("The measurement is: {value}{unit_label}");
}

Parameters are separated by comma.

Statements and Expressions

Statements are instructions that perform some action and do not return a value.

Expressions evaluate to a resultant value.

fn main() {
    let y = {
        let x = 3;
        x + 1
    };

    println!("The value of y is: {y}");
}

curly bracket is an expression, and it can be assigned to another value.

Functions with Return Values

fn five() -> i32 {
    5
}

fn main() {
    let x = five();

    println!("The value of x is: {x}");
}

return keyword can be used to return a value early

the returned value must not end with a semicolon

3.4 Comments

// hello, world

two slashes are used to represent comments

3.5 Control Flow

if Expressions

fn main() {
    let number = 3;

    if number < 5 {
        println!("condition was true");
    } else {
        println!("condition was false");
    }
}

operations under if is performed when the condition returns true

if else keyword is used, it is executed when condition in if returns false

fn main() {
    let number = 6;

    if number % 4 == 0 {
        println!("number is divisible by 4");
    } else if number % 3 == 0 {
        println!("number is divisible by 3");
    } else if number % 2 == 0 {
        println!("number is divisible by 2");
    } else {
        println!("number is not divisible by 4, 3, or 2");
    }
}

multiple conditions can be used with else if

Using if in a let Statement

fn main() {
    let condition = true;
    let number = if condition { 5 } else { 6 };

    println!("The value of number is: {number}");
}

to use the style above, the return type must be matched.

Repetition with Loops

fn main() {
    loop {
        println!("again!");
    }
}

loop keyword executes a block of code over and over.

continue keyword is used to skip to the next iteration without executing the rest of the code

Returning Values from Loops

fn main() {
    let mut counter = 0;

    let result = loop {
        counter += 1;

        if counter == 10 {
            break counter * 2;
        }
    };

    println!("The result is {result}");
}

Put the value to return after the break statement to return a value.

Loop Labels to Disambiguate Between Multiple Loops

fn main() {
    let mut count = 0;
    'counting_up: loop {
        println!("count = {count}");
        let mut remaining = 10;

        loop {
            println!("remaining = {remaining}");
            if remaining == 9 {
                break;
            }
            if count == 2 {
                break 'counting_up;
            }
            remaining -= 1;
        }

        count += 1;
    }
    println!("End count = {count}");
}

loop labels can be used to break specific loops

Conditional Loops with while

fn main() {
    let mut number = 3;

    while number != 0 {
        println!("{number}!");

        number -= 1;
    }

    println!("LIFTOFF!!!");
}

Looping Through a Collection with for

fn main() {
    let a = [10, 20, 30, 40, 50];

    for element in a {
        println!("the value is: {element}");
    }
}

similar to for-each statement in Python.

[The Rust Programming Language] Ch. 2: Programming a Guessing Game

연두색연필 — Sun, 5 Nov 2023 20:14:33 +0900

https://rust-book.cs.brown.edu/ch02-00-guessing-game-tutorial.html

Programming a Guessing Game - The Rust Programming Language

Let’s jump into Rust by working through a hands-on project together! This chapter introduces you to a few common Rust concepts by showing you how to use them in a real program. You’ll learn about let, match, methods, associated functions, external crat

rust-book.cs.brown.edu

Setting Up a New Project

$ cargo new guessing_game
$ cd guessing_game

cargo new creates a new cargo project with a name as the argument.

Processing a Guess

use std::io; can be used to process the input.

println! is a macro for printing string to a screen

Storing Values with Variables

let can be used to create a variable.

mut makes the variable to be mutable. Every object in Rust is mutable by default

Associated function is a function that’s implemented on a type. :: is used to describe the associated function.

ex) String::new()

Receiving User Input

io::stdin().read_line(&mut guess) can be used to harness user input.

guess is where the value read will be stored and it is referenced by &. &mut references and mutates the data.

Handling Potential Failure with Result

Result is used to handle error

Ok indicates the operation was successful, and it contains the generated value
Err means that the operation failed, and it contains information about how or why the operation failed.
using expect method allows for the handling of Err without needing for program to crash

Printing Values with println! Placeholders

{} can hold value in place.

a variable can go into the place
println!("You guessed: {guess}");
if the brackets are left blank, a comma-separated list can be followed to go in place of curly brackets
let x = 5; let y = 10; println!("x = {x} and y + 2 = {}", y + 2);

Testing the First Part

cargo run can be used to run the rust file.

Using a Crate to Get More Functionality

Since Rust does not provide a standard library for randomness, rand crate must be used.

library crate: code that is intended to be used in other programs and can’t be executed on its own

binary crate: code that is executable

[dependencies]
rand = "0.8.5"

Adding line above in Cargo.toml file can add dependencies to the programs.

Running cargo build after adding rand crate to the file downloads and compiles the dependencies.

Running the code once again does nothing because Rust knows that nothing has been changed

**Cargo.lock** file records all the dependencies’ versions used in the program, and this is for reproducibility.

Generating a Random Number

let secret_number = rand::thread_rng().gen_range(1..=100);

gen_range function takes in range as input and returns a random number in that range.

1..=100 is used to represent a range of numbers between 1 and 100, inclusive

Comparing the Guess to the Secret Number

by using std::cmp::Ordering type, can be used to get variants Less, Greater, Equal.

match guess.cmp(&secret_number) {
    Ordering::Less => println!("Too small!"),
    Ordering::Greater => println!("Too big!"),
    Ordering::Equal => println!("You win!"),
}

cmp compares a variable to another variable.

match expression decides what operation to execute based on the patterns of the return value

parse method converts numbers automatically based on Rust’s default inference of value.

only work on characters that can logically be converted into numbers and so can easily cause errors

Allowing Multiple Guesses with Looping

loop keyword creates an infinite loop. It works the same as while True in Python.

break keyword exits the loop when the statement is executed.

[논문 리뷰] Asynchronous Methods for Deep Reinforcement Learning (A3C)

연두색연필 — Sun, 3 Sep 2023 17:11:57 +0900

이번 논문에서는 강화학습을 비동기적이게 학습을 하게 만든 논문을 들고 왔다. 이 논문의 특이점이라고 한다면 보통의 학습에서 쓰이는 GPU를 사용하지 않고 CPU 코어들을 통한 병렬학습을 한다는 것이다. 이를 통해 Atari 벤치마크에서 새로운 기록을 세웠고 다른 도메인에서도 좋은 결과를 보여주는 모습이다.

[1602.01783] Asynchronous Methods for Deep Reinforcement Learning (arxiv.org)

Asynchronous Methods for Deep Reinforcement Learning

We propose a conceptually simple and lightweight framework for deep reinforcement learning that uses asynchronous gradient descent for optimization of deep neural network controllers. We present asynchronous variants of four standard reinforcement learning

arxiv.org

Introduction

보통의 online RL알고리즘은 DNN(Deep Neural Network)과 합쳐지면 안정적이지 않았다. 이는 온라인으로 들어오는 데이터들 간의 상관관계가 높았기 때문인데, 이를 DQN에서는 Experience Replay라는 방식을 사용해 데이터를 먼저 저장을 하고 랜덤 하게 학습을 하는 방식을 취했다. 이 방법의 단점은 off-policy RL만 가능하고 메모리와 computation power을 많이 쓴다는 단점이 있다. 또한 옛날 데이터를 학습한다는 문제도 있다.

이 논문에서는 이 문제를 agent들을 parallel로 학습시키는 방법을 사용하여 해결했다. 여러 개의 agent를 사용하면 한 state와 연관된 데이터가 아니라 각각의 agent마다 다른 데이터를 만들어내기 때문에 더 안정적이게 학습을 할 수 있다. 이 아이디어는 다양한 RL 알고리즘에 적용할 수 있는데, 심지어 off-policy 알고리즘에도 적용할 수 있다.

Related Work

General Reinforcement Learning Architecture(Gorilla)에서는 비동기적인 학습을 환경, Replay Memory, learner을 각각의 agent마다 복제해서 학습하였다. Gradient 값을 asynchronous 하게 중앙 서버로 보내어서 모델을 업데이틀 하고 이를 주기적으로 하위 learner에 보내주는 방식을 사용하였다.

Parallelism을 사용하여 matrix operation의 속도를 늘리거나 SARSA를 가속하는 연구도 있었다. 또한, evolutionary 메서드를 병렬화 하여 여러 개의 thread와 node에 나누어서 시뮬레이션을 돌려 학습을 가속화하는 방법도 있다

Reinforcement Learning Background

Value-based RL

앞부분에서는 RL의 원리를 전반적으로 설명하고 있기 때문에 넘어가겠다 (앞에 있는 다른 블로그 글을 참조하자). n-step return에 대해서 잠깐 설명하고 있는데, 이는 일반의 DRL의 one-step return인 $$r + \gamma \max_{a'} Q(s', a'; \theta)$$ 대신에 n개의 step에 걸친 $$r_{t} + \gamma r_{t+1} +... + \gamma^{n-1} r_{t+n-1} + \max_{a} \gamma^n Q(s_{t+n}, a)$$을 사용하는 것이다. 나중에 이 논문도 리뷰를 할 예정이다. 이 방식의 장점은 하나의 reward가 n개의 state-action에 영향을 준다는 것이다. 즉, 더 효율적인 학습이 가능하다.

Policy-based RL

Value-based와 다르게 policy 자체를 평가하는 방식이다. 이 방식도 많이 사용되어서 곧 policy-based RL에 관한 리뷰를 할 예정이다. Policy $\pi (a|s;\theta)$가 있을 때 $\mathbb {E}[R_t]$에 대한 경사상승을 진행한다. 간단한 policy-based RL인 REINFORCE는 $\theta$를 $\nabla_\theta \log \pi(a_t|s_t;\theta) R_t$으로 업데이트를 한다. 이는 $\nabla_\theta \mathbb {E}[R_t]$의 추정값이다.

여기서 이제 variance를 줄이기 위해 baseline인 $b_t(s_t)$를 빼주면 결과 gradient는 $$\nabla_\theta \log \pi(a_t|s_t;\theta)(R_t-b_t(s_t))$$ 이 된다. 이 baseline을 value function으로 사용하면 $$b_t(s_t) \approx V^\pi(s_t)$$가 된다. 이 $R_t-b_t(s_t)$를 advantage의 estimation라고 볼 수 있는데 이는 $$A(a_t, s_t) = Q(a_t, s_t) - V(s_t)$$이다. $R_t$가 $Q(a_t, s_t)$의 estimate이고 $b_t$가 $V(s_t)$의 estimate인데 이 방법론을 actor-critic architecture로 볼 수 있다 ($\pi$가 actor, $b_t$가 critic).

Asynchronous RL Framework

이제 multi-thread로 학습하는 asynchronous RL에 대해 이야기를 해보겠다. 이 논문에서는 one-step Sarsa, one-step Q-learning, n-step Q-learning, 그리고 A2C(Advantage actor-crtic)의 asynchronous version에 대해서 다룬다. 두 가지 방법을 사용하여 이 알고리즘들을 asynchronous 하게 바꾼다.

1. Asynchronous actor-learner 사용

각각의 서버에 agent를 할당하고 파라미터 서버를 두지 않고, 하나의 서버에서 여러 개의 cpu 코어를 사용한다. 이를 사용하면 gradient를 보낼 때 서버 간에 필연적으로 발생할 수밖에 없는 communication delay를 획기적으로 감소시킨다.

2. 여러 개의 actor이 병렬적으로 돌면 각각 환경의 다른 부분을 explore 한다

Asynchronous : 평행우주의 나의 경험이 합쳐진다면? https://namu.wiki/w/%ED%8F%89%ED%96%89%EC%9A%B0%EC%A3%BC

즉, replay memory처럼 state 간의 correlation을 해결할 수 있는 메커니즘을 도입을 하지 않아도 된다. 각각 online으로 여러 가지의 경험이 한 번에 학습되기 때문에 diversity의 증가와 데이터 간의 correlation의 저하가 이루어진다. 또한 agent마다 다른 exploration scheme을 사용시켜 학습의 폭을 넓힐 수 있다. 즉, 학습을 상당히 안정적으로 진행할 수 있다.

다른 장점은 agent의 수에 따라 비례하여 학습시간이 줄어든다. 또한, replay memory를 사용하지 않기 때문에 on-policy RL을 사용할 수 있다 (Sarsa, actor-critic). 저장할 필요가 없기 때문에 메모리가 줄어드는 것은 덤이다.

이제는 각각에 알고리즘에 어떻게 asynchronous를 적용했는지 보겠다.

Asynchronous one-step Q-learning

thread 하나당 각각의 environment과 interact 한다. 각 step마다 gradient를 계산하나 target network에는 gradient들이 accumulate 되어서 update 된다(supervised learning에서 minibatch 방식과 비슷). 또한 각각의 thread마다 다른 exploration strategy를 주면 더 robust 하다. 여기서는 $\epsilon$-greedy에서 $\epsilon$을 어떤 distribution에서 sampling 하는 방식으로 차이를 주었다.

Asynchronous one-step Sarsa

이 방식은 위에 있는 one-step Q-learning과 비슷하나 차이점은 target value를 $$Q(s, a)=r+\gamma Q(s', a';\theta^-)$$를 사용한다($\max_a$를 사용하는 Q-learning과 다름).

Asynchronous n-step Q-learning

Forward view를 사용하여 eligibility traces 방식과 다르게 explicit 하게 n-step return을 계산한다. 이 방식이 momentum 기반의 학습 방식과 backprogration through time 방식에 적합하다고 한다. action을 $t_max$ step 또는 terminal state가 나올 때까지 고르고 n-step update를 진행한다. n-step update를 할 때는 제일 긴 step update를 사용하는데, 즉, 마지막 state는 one-step update를 진행하고, 두 번째 마지막 state는 two-step update... 이 방식으로 n-step까지 계산한 후 모아서 한 번에 gradient update를 진행한다.

Asynchronous advantage actor-critic (A3C)

A3C는 policy $\pi(a_t|s_t;\theta)$와 value function의 estimation인 $V(s_t;\theta_v)$를 사용하여 학습한다. n-step Q-learning과 비슷하게 forward view를 사용한다. $\theta$와 $\theta_v$의 parameter은 어느 정도 공유되는데, CNN의 output을 softmax를 통햇 policy $\pi$에 넣어주고 linear output을 value function $V$에 넣어준다. 또한, 정책 $pi$에 entropy를 도입하면 초반에 optimal 하지 않은 정책으로의 수렴을 막아준다.

Experiments

이 논문에서는 Arcade Learning Environment, TORSC 3D car racing simulator, Mujoco, Labyrinth를 사용하여 실험을 진행했다(마지막 두 개는 A3C에서만 사용).

Atari 2600

https://arxiv.org/pdf/1602.01783.pdf

K40 CPU를 사용한 DQN보다 16개의 CPU 코어를 사용해서 Asynchronous 하게 학습한 알고리즘은 더 빨랐다. 또한, A3C 같은 경우에는 위에 나온 3가지의 value-based 방식보다 더 좋은 성능을 내었다. 실험에 사용한 hyperparameter은 6개의 game에서 search를 통해 찾은 후에 다른 57개의 게임에 같은 것을 적용하였다. 또한, feed-forward 방식과 LSTM을 사용한 recurrent agent 방식도 실험하였다. A3C 같은 경우에는 SOTA를 뛰어넘는 성능을 가지면서 학습 시간은 반으로 줄이는 모습을 보여줬다.

TORCS Car Racing Simulator

https://sourceforge.net/projects/torcs/

https://arxiv.org/pdf/1602.01783.pdf

TORCS의 장점은 Atari보다 더 나은 그래픽을 가지고 있어서 조금 더 realistic 한 테스팅이 가능하다. 이 게임에서 reward는 트랙 중간에서의 속도와 비례한다. 위의 그래프를 보면 알겠지만 A3C가 제일 좋은 성능을 내었고 대충 인간 실험자의 75%~90%의 성능을 내었다.

Continuous Action Control Using the MuJoCo Physics Simulator

Continuous 한 환경인 MuJoCo에서는 policy 기반인 A3C가 적합해서 실험을 하였는데, visual input이나 physical state를 input으로 주었을 때 24시간 안에 좋은 설루션을 찾아내었다.

Labyrinth

이 미로 환경에서는 계속 랜덤 하게 생성되는 미로에서 길을 찾는 게 목표이다. 각 episode마다 랜덤 한 미로가 생성되기에 general 한 전략이 필요하다. 도착점에 들어가면 10점을 주고 episode당 60초가 소모되는데, 50 정도의 점수를 agent가 달성하였기 때문에 3D maze를 visual input만으로 풀 수 있다는 것을 알 수 있다.

https://arxiv.org/pdf/1602.01783.pdf

CPU의 스레드 수가 늘어날수록 학습 속도가 비례해서 빨라지는 것을 알 수 있는데, 특이하게 Q-learning과 SARSA는 super-linear 한 상승을 보여준다. 이는 아마 multi-thead덕분에 bias가 줄어서 그런 것이다. Asychronous 하게 적용한 알고리즘들은 lr이나 랜덤 한 시작에 강한 모습을 보여준다.

Conclusions and Discussion

Asynchronous 하게 학습하는 것은 다양한 종류의 도메인에서 좋은 성능을 보여준다. 이 방식은 value-based, policy-based, off-policy, on-policy처럼 다양한 곳에 적용될 수 있다. A3C는 절반의 시간으로 SOTA를 달성하였고 이는 CPU만으로만 학습한 결과이다. Paralle actor을 사용하면 one-step 방법인 다양한 value-based 알고리즘들에 stabilizing 하는 효과를 가져다준다.

Experience replay를 적용해서 예전의 데이터를 다시 학습할 수 있겠으나, 이런 활용은 학습하는 것보다 환경에서 action을 취하는 시간이 더 긴 TORCS 같은 곳에 적용을 할 수 있겠다. 또한 알고리즘의 변형인 Dueling DQN 같은 것도 이 아키텍처를 적용해 볼 수 있다. 이 논문은 GPU로만 학습했던 기존의 알고리즘을 병렬처리라는 개념을 사용하여 성공적으로 학습속도를 올렸다.

[논문 리뷰] Rainbow: Combining Improvements in Deep Reinforcement Learning (Rainbow DQN)

연두색연필 — Mon, 31 Jul 2023 17:20:07 +0900

[1710.02298] Rainbow: Combining Improvements in Deep Reinforcement Learning (arxiv.org)

Rainbow: Combining Improvements in Deep Reinforcement Learning

The deep reinforcement learning community has made several independent improvements to the DQN algorithm. However, it is unclear which of these extensions are complementary and can be fruitfully combined. This paper examines six extensions to the DQN algor

arxiv.org

https://templeofgeek.com/infinity-stones-method-of-the-mad-titan-infinity-war-spoilers/

이 논문을 마지막으로 DQN series의 끝이다. 몇 개의 글에 걸쳐서 다양한 DQN의 변형을 읽고 리뷰를 하였다. 논문들에는 이런 발전을 합쳐서 성능 결과를 낸 연구도 있지만, 이 논문은 6개의 DQN에서 발전한 것들을 다 합쳐서 성능을 대폭 끌어올린 논문이다. 이것을 Rainbow DQN이라고 부르는데 위에 있는 타노스의 인피니티 건틀렛과 비슷한 느낌이라 짤을 하나 만들어 보았다. 이것으로 이제 DQN은 끝이고 다른 RL 논문을 다뤄볼 예정이다.

Introduction

Deep Q-Network (리뷰: https://limepencil.tistory.com/38)이 RL에 가져온 혁신으로 인해 많은 발전들이 그 뒤를 따랐는데, 이들 중에 큰 몇 가지를 이야기해 보자면

Double DQN https://limepencil.tistory.com/41
Dueling DQN https://limepencil.tistory.com/42
Prioritized Experience Replay https://limepencil.tistory.com/43
Multi-step target(A3C)
Distributional Q-learning
NoisyNet https://limepencil.tistory.com/43

이다. 이들은 DQN에 큰 성능 향상을 이루었고, 이중에 몇 가지를 섞어 진행한 실험도 있다. 이 논문에서는 더 나아가 이 모든 것을 합쳐서 성능을 올리는지 연구하고, 또한 어떤 factor이 가장 성능 향상에 도움이 되거나/되지 않거나를 탐색한다.

Background & Extensions to DQN & The Integrated Agent

DQN의 대한 설명이나 각 extension에 대한 깊은 설명은 위에 링크들을 참고해 주면 되고, 여기서는 각 extension이 무엇을 하는지 짤막하게 설명하겠다.

Double Q-Learning: addresses overestimation by decoupling maximization for bootstrap target and maximization in selecting an action
Prioritized Replay: replays memory based on particular priority measured by absolute TD error
Dueling Network: divide the layer into value stream and action stream and aggregate them later
Multi-step learning: use $n$-step return from a given state
Distributional RL: network learns to approximate the distribution of returns instead of the expected return
NoisyNet: introduce random noise into the network to replace the normal exploration strategy

이들을 기존의 DQN을 뼈대로 두고, 각각 히 다른 부분을 바꾼다. 더 자세한 부분은 논문을 참조하자.

Experimental Methods

이를 실험하기 위해서 보통의 DRL을 실험하기 위해서 쓰이는 Atari 2600게임을 사용하였다. 전 논문들처럼 agent의 점수들은 normalized 되었다.

다양한 extension들을 합치기 위해서 hyperparameter을 기존 DQN에서 조금 변형하게 되었다.

PER을 사용한 덕분에 learning update를 시작하는 frame을 200k 에서 80k로 바꾸게 되었다.
NoisyNet을 사용하기 위해 $\epsilon$-greedy 정책에서 $\epsilon$을 0으로 바꾸고 NoisyNet의 parameter인 $\sigma_0$을 0.5로 바꾸었다.
Optimizer을 RMSProp에서 Adam으로 바꾸어 learning rate의 sensitivity를 낮추었다.
PER에서 proportional variant를 사용하였고 priority exponent $\omega = 0.5$, 그리고 importance sampling exponent인 $\beta$를 0.4에서 1로 linear 하게 증가시켰다
multi-step learning에서는 $n = 3$ 일 때에서 전체적으로 좋은 결과를 보여주었다.

Analysis

https://arxiv.org/pdf/1710.02298.pdf

Rainbow의 성능과 데이터 효율성은 어떤 single-extension baseline들보다 더 좋다. 학습 시간은 각 연구마다 다른 setup을 사용하였기 때문에 정확한 속도 향상은 비교하기 어렵다.

https://arxiv.org/pdf/1710.02298.pdf

Rainbow에서 extension을 하나씩 빼보면서 성능 차이를 비교한 실험에서는 PER과 multistep learning이 가장 중요한 요소였다고 하고 있다. 이들을 뺀다면 초반성능과 후반 성능 전체에 영향을 미친다. DDQN과 Dueling DQN은 그렇게 큰 영향은 미치지 않았으나, 각각의 게임마다 성능차이는 달랐다. DDQN 같은 경우에는 support of distribution이 늘어나서 overestimation을 하게 된다면 성능이 오를 것으로 보인다.

Discussion

이 논문에서는 여러 가지의 extension들이 DQN에 모두 다 합쳐질 수 있는지 확인하였고, 거의 모든 component들이 성능 향상에 도움을 주었다는 것을 보았다. Policy-based network 같은 다른 유형의 RL은 다른 연구가 더 필요하다.

[논문 리뷰] Noisy Networks for Exploration (NoisyNet)

연두색연필 — Sun, 23 Jul 2023 22:58:05 +0900

[1706.10295] Noisy Networks for Exploration (arxiv.org)

Noisy Networks for Exploration

We introduce NoisyNet, a deep reinforcement learning agent with parametric noise added to its weights, and show that the induced stochasticity of the agent's policy can be used to aid efficient exploration. The parameters of the noise are learned with grad

arxiv.org

이번 논문에는 DQN에 있는 fully connected layer에 parametric 한 noise를 넣어서 유도된 stochasticity가 agent의 성능을 올려준다는 연구를 한 논문이다. 지금까지 여러 가지 DQN의 변형을 다뤘는데 아마 이 글이 Rainbow DQN전의 마지막 글이지 않을까 싶다. DQN에 관한 논문 리뷰는 아래 글을 참조하자.

[논문 리뷰] Playing Atari with Deep Reinforcement Learning (DQN) — LimePencil's Log (tistory.com)

[논문 리뷰] Playing Atari with Deep Reinforcement Learning (DQN)

이제부터 이 블로그에 논문을 하나씩 읽으면서 리뷰를 해보려고 한다. 아마 분야마다 시간을 순서대로 큰 영향을 미친 논문을 읽을 것 같다. 이번 논문은 강화학습에 DL을 적용한 첫 번째 성공적

limepencil.tistory.com

Introduction

Optimism in the face of uncertainty이나 intrinsic motivation 같은 common heuristic reinforcement learning method 같은 경우에는 generalization과 exploration을 다른 방법을 사용한다는 것이다. Intrinsic reward 같은 경우를 예로 들면 metric을 사람이 결정하기 때문에 optimal 하다고 보기는 어렵다. 제일 좋은 방법은 exploration in the policy itself이나, 이 방법은 환경과 긴 interaction이 필요하다(not data-efficient and require simulator).

이 논문에서는 다른 대안을 제안하는데, 이는 바로 네트워크의 weight 자체에다가 perturbation을 주어서 exploration을 하게 만드는 방법이다. 이 perturbation은 noise distribution에서 sampling이 되고 이 variance hyperparameter 자체를 손실함수를 통해 학습을 하게 시키는 방법이다. 즉, 네트워크가 스스로 noise의 level 크기를 결정하는 방식이다. 이 방식이 computationally expensive 하다고 볼 수 있으나 사실 affine transformation이기 때문에 큰 영향은 없다.

또한 NoisyNet은 다른 DQN의 변형인 알고리즘 (Dueling, Double 등등)에 쉽게 implement 시킬 수 있다.

NoisyNet for Reinforcement Learning

NoisyNet이란 네트워크의 weight이나 biases를 parametric function으로 만든 noise를 입히는 것인데, 이 파라미터는 경사하강법으로 최적의 값을 찾을 수 있다. noisy parameter $\theta$를 다음과 같이 정의하는데 $$ \theta \stackrel {\text {def}}{=} \mu + \sigma \odot \epsilon$$ 여기서 $\mu, \Sigma$은 학습 가능한 파라미터이고, $\epsilon$은 평균이 0인 노이즈 벡터이다.

평소의 neural network의 linear layer을 다음과 같이 표현한다면 $$y = wx +b$$ noisy linear layer은 $$y \stackrel {\text {def}}{=} (\mu^w + \sigma^w \odot \epsilon^w) x + \mu^b + \sigma^b \odot \epsilon^b$$ 으로 표현할 수 있다.

Noise Distribution의 종류:

Independent Gaussian noise: noise per output
1. Initialization: uniform distribution of $ \mu_{i,j} = \textit{U} \left[ - \sqrt{\frac{3}{p}}, \sqrt{\frac{3}{p}} \right]$ 이고 ($p$는 input의 크기), $\sigma_{i,j} = 0.017$
Factorized Gaussian noise: noise per input
1. Initialization: uniform distribution of $\mu_{i,j} = \textit{U} \left[ - \frac{1}{\sqrt{p}}, \frac{1}{\sqrt{p}} \right]$ 이고 ($p$는 input의 크기), $\sigma_{i,j} = \frac{\sigma_0}{\sqrt{p}} | \sigma_0=0.5$

weight와 biase의 개수 차이를 보자  :  https://towardsdatascience.com/whats-the-role-of-weights-and-bias-in-a-neural-network-4cf7e9888a0f

Factorized Gaussian noise를 쓰는 이유는 random number을 generate 하는 compute시간을 줄이기 위해서 그렇다. $p$를 input, $q$를 output으로 정의한다면 Independent Gaussian noise는 $pq + q$의 noise variable을 가지고 있고 Factorised Gaussian noise는 $p+q$의 noise variable을 가지고 있다. Independent Gaussian noise는 곱셈을 가지고 있기 때문에 $p$와 $q$가 커지면 더 많은 계산이 필요하다. Factorized Gaussian noise는 $p$와 $q$가 덧셈 관계이기 때문에 수가 그렇게 빨리 커지지는 않는다. Factorized Gaussian noise가 작은 이유는 Independent Gaussian noise처럼 모든 weight에 대한 random noise를 만드는 게 아니라 input과 output의 수만큼 random noise를 만들고 weight는 이 두 값을 곱한 것으로 사용하기 때문이다.

Noise는 RL에서 중요한 exploration을 담당하게 되는데, 이를 통해 어떠한 stochasticity를 부여한다. NoisyNet에서는 자동으로 이 노이즈의 정도를 NoisyNet에서 조절하게 된다. 즉, 주입되는 noise의 정도를 agent가 자동적으로 맞춘다는 것이다.

DQN과 Dueling DQN에는 epsilon-greedy 방식을 쓰지 않고 NoisyNet으로 대체한다. 위에서 설명한 Factorized Gaussian Noise를 사용하고 noise sample은 각 action 전에 항상 다시 샘플 된다. DQN에서 target network와 online network의 noise를 각각 따로 생성하여 어떠한 correlation이 생기는 것을 막는다. 또한, action을 고를 때에도 다른 노이즈 샘플을 사용하고 greedy 하게 action을 선택한다. Dueling 같은 경우에도 DQN과 비슷하게 구성한다.

A3C 같은 경우에는 policy network의 entropy bonus를 없애고 fully connected layer을 NoisyNet으로 대체한다. A3C는 DQN과 다르게 Independent Gaussian noise를 사용한다. Entropy loss를 사용하는 이유가 deterministic 하게 하는 것을 방지하기 위해서인데, 이를 NoisyNet으로 해결했기 때문에 필요가 없어졌다. N-step return을 사용하기 때문에 n step마다 noise parameter가 새로 sampling 된다.

Results

https://arxiv.org/pdf/1706.10295.pdf

성능은 그전의 논문들과 같이 57개의 Atari게임으로 비교하였다. 비교 대상은 DQUN, Dueling DQN, 그리고 A3C이다. 점수는 그 전 논문과 같게 human normalized score로 계산되었다.

https://arxiv.org/pdf/1706.10295.pdf

위에 있는 표와 그래프를 보면 NoisyNet이 전반적으로 성능 향상에 기여를 했다는 것을 볼 수 있다. 또한 $\sigma^w$를 학습동안 계속 추적해 봤을 때에 0으로 수렴하여 deterministic solution으로 바뀌지 않았고 증가하는 게임도 있었다. 이는 NoisyNet이 problem-specific exploration strategy를 만들었다는 모습이다.

Conclusion

이 논문에서는 NoisyNet이라는 새로운 탐색 기법을 소개하고 있고, 성능이 올라간 것은 optimization효과 일수도 있지만 이는 exploration과 optimization을 따로 보는 후속 연구가 필요하다. NoisyNet의 다른 장점은 noise의 정도를 RL algorithm이 결정한다는 것인데, 이는 hyperparamenter tuning의 필요를 줄여준다. NoisyNet은 다양한 FC layer이 있는 RL algorithm에 적용을 할 수 있는 좋은 기법이다.

[논문 리뷰] On the detection of synthetic images generated by diffusion models

연두색연필 — Thu, 6 Jul 2023 22:01:55 +0900

저번 글에 이어 이번에는 GAN에 한정하지 않고 어떻게 diffusion 모델들도 진짜 이미지인지 가짜 이미지인지 판별할 수 있는지에 대한 논문을 리뷰할 것이다. GAN과 diffusion은 아키텍처 구조적으로 다르기 때문에 이를 어떻게 다루는지를 보자.

[2211.00680] On the detection of synthetic images generated by diffusion models (arxiv.org)

On the detection of synthetic images generated by diffusion models

Over the past decade, there has been tremendous progress in creating synthetic media, mainly thanks to the development of powerful methods based on generative adversarial networks (GAN). Very recently, methods based on diffusion models (DM) have been gaini

arxiv.org

Abstract & Introduction

With this work, we seek to understand how difficult it is to distinguish synthetic images generated by diffusion models from pristine ones and whether current state-of-the-art detectors are suitable for the task.

이 논문에서는 diffusion model에 대한 detection이 현재 어디까지 왔는지에 대해 연구를 하고 있다. 이 논문에서는 특히 다음을 중점적으로 다루고 있다:

finding forensic traces left by diffusion model
현재의 detector의 성능 측정 및 resize와 compression이 있는 환경에서의 성능

Synthetic image의 특징은 인간의 눈으로 보기에는 완벽하더라도 생성 시에 남아있는 trace 때문에 판별할 수 있다. 각각의 architecture에 따라 다른 trace들을 가지고 있고, 이를 통해 소스를 추적할 수 있다. GAN이 가진 특이한 fingerprint 때문에 GAN architecture은 detect 하기 쉬운 편에 속하고 있다. 하지만, 현재의 SOTA도 새로운 모델에 generalize 하는 것에는 어려움을 보여주고 있다. 특히, 이미지에 손실이 있으면 상당한 성능 하락을 보여주고 있다.

그래서, 이 논문은 diffusion 모델들도 GAN처럼 숨겨진 fingerprint가 있는지와 현재의 SOTA detector이 이런 유형의 이미지를 판별하는 데에 어느 정도의 성능을 보여주는지를 탐구한다.

Background

이전의 연구들은 GAN이 생성이미지 분야의 majority를 차지하고 있었기 때문에 GAN detection에 관한 것이 많았다. 이런 생성이미지의 detection의 중요한 부분은 augmentation(blurring & compression)이다. 이를 통해 generalization과 robustness를 올릴 수 있다. 또한 training set의 다양성도 성능을 올리는 데에 도움을 준다. 이것들은 조금 더 자세히 이전의 논문 리뷰에 썼기 때문에 이를 참고하면 좋을 것이다.

[논문 리뷰] Are GAN generated images easy to detect? A critical analysis of the state-of-the-art — LimePencil's Log (tistory.com)

[논문 리뷰] Are GAN generated images easy to detect? A critical analysis of the state-of-the-art

AI CONNECT에서 진행하는 Fake or Real: AI 생성 이미지 판별 경진대회를 참가하기 위해 여러 가지 논문을 뒤적이던 중에 괜찮은 논문이 있어서 리뷰를 해보려고 한다. https://arxiv.org/abs/2104.02617 Are GAN gen

limepencil.tistory.com

결국엔 중요한 trace들을 보존하기 위해서는 아래의 3가지가 중요하다.

local patch에서 학습시키기
전체 이미지를 통해 학습시키는 방안을 생각해 보기 (fusion strategy)
첫 번째 layer에서 downsampling을 피하기

pretrained 된 모델을 쓰는 것은 중요하고, 극한의 augmentation은 어느 정도의 성능 향상을 가져다준다.

Artifact Analysis

https://arxiv.org/pdf/2211.00680.pdf

이미지에서 fingerprint를 카메라에서 PRNU(Photo response non-uniformity)를 extract 하는 것 같이 extract 한다. 이에 대한 자세한 설명은 논문을 확인하면 된다. 이 noise를 extract 한 뒤에 이를 1000개의 이미지의 평균을 내고, 이를 푸리에 변환을 해주면 spectal analysis를 할 수 있다.

위의 사진을 보면 GAN은 특징이 강한 trace가 남는다. 특이하게도, 최신의 DM(Diffusion Model)들에도 trace가 남는 것을 볼 수 있다. ADM이나 DALL·E 2 같은 경우에는 이런 특징이 약하게 남는다.

Detection Performance

성능을 평가하기 위해서 진짜 이미지 데이터는 COCO, ImageNet, UCID를 사용했고, 생성이미지는 generalization을 평가하기 위해서 ProGAN와 Latent Diffusion 이 두 모델에서 50만 개의 이미지를 생성하여 사용하였다. 이 논문에서는 4가지의 detector을 평가한다.

Spec: frequency analysis
PatchForensics: local patch analysis
Wang2020: ResNet50 with blurring and compression augmentation
Grag2021: same backbone as Wang2020 but avoiding down-sampling in the first layer and intense augmentation

https://arxiv.org/pdf/2211.00680.pdf

압축하지 않은 PNG를 생성이미지 데이터로 학습을 하였을 때에는 좋은 성능을 보여주었는데, 이는 실제 이미지는 JPEG로 압축이 되었는데 이 trace가 남기 때문에 더 detect 하기 쉬운 것으로 보인다.

다른 시나리오로 생성과 진짜 이미지를 압축하고 resize 하였을 때에는 detector에 따라 성능이 떨어지는 정도가 다르긴 했으나, Grag2021은 상당이 좋은 성능을 내는 모습을 보여주었다.

https://arxiv.org/pdf/2211.00680.pdf

성능이 좋은 Grag2021을 Latent Diffusion에 학습시키고, 이를 ProGAN 데이터셋으로 학습시킨 모델과 합치고 조금의 calibration을 더하면 성능이 올라가는 것을 볼 수 있다.

Conclusion

이 논문에서는 diffusion model을 통해 만들어진 synthetic image 판별을 다루고 있다. Generalization은 아직도 해결해야 할 숙제이고 GAN으로 학습한 detector들은 DM으로 만들어진 image들을 판별하는 성능이 떨어진다. DM으로 만들어진 이미지를 training에 넣으면 그 모델에 대한 성능은 올라가지만 다른 것들은 그렇게까지 올라가지는 않는다. 미래의 연구에서는 이를 해결해야 하는 것으로 보인다.

Code

위의 논문의 코드는 아래 깃허브에 공개되어 있다.

grip-unina/DMimageDetection: On the detection of synthetic images generated by diffusion models (github.com)

GitHub - grip-unina/DMimageDetection: On the detection of synthetic images generated by diffusion models

On the detection of synthetic images generated by diffusion models - GitHub - grip-unina/DMimageDetection: On the detection of synthetic images generated by diffusion models

github.com

[논문 리뷰] Are GAN generated images easy to detect? A critical analysis of the state-of-the-art

연두색연필 — Thu, 29 Jun 2023 16:24:43 +0900

AI CONNECT에서 진행하는 Fake or Real: AI 생성 이미지 판별 경진대회를 참가하기 위해 여러 가지 논문을 뒤적이던 중에 괜찮은 논문이 있어서 리뷰를 해보려고 한다.

https://arxiv.org/abs/2104.02617

Are GAN generated images easy to detect? A critical analysis of the state-of-the-art

The advent of deep learning has brought a significant improvement in the quality of generated media. However, with the increased level of photorealism, synthetic media are becoming hardly distinguishable from real ones, raising serious concerns about the s

arxiv.org

Abstract & Introduction

이 논문에서는 생성 이미지를 판별하는 SOTA method를 분석하고 비교해 본다. 어떤 factor이 detection에 큰 도움을 주는지, 그리고 현재의 generative architecture들에 이 방법이 얼마나 효용이 있는지를 다뤘다.

https://arxiv.org/pdf/2104.02617.pdf

GAN은 특별한 trace를 생성된 이미지에 남기는데, 이를 이용하여 detection이 가능하다. 기술이 발전함으로써 이것이 줄어들겠지만, 이 trace는 생성 모델의 구조 그 자체와 관계가 있다. 각각의 GAN architecture마다 특정한 artificial fingerprint가 있다. 이를 Fourier transform으로 찾을 수 있는데 (위에 있는 파란색 사진) 데이터에 따라서도 이 fingerprint가 바뀌기 때문에 다른 방법을 찾아야 한다.

요즘에는 deep neural network만을 사용하여 detection을 하기도 하는데, 그렇다면 이 task자체가 쉬워 보이나 사실 상당히 어렵다. 원본의 이미지를 가지고 있을 때는 이런 trace들을 찾기가 쉽지만 compression과 distortion이 흔한 인터넷상에서는 이런 흔적들이 사라지기 때문에 더 challenging 해진다. 또한, 계속 새로운 생성모델이 만들어지고, 이에 대한 데이터를 구하기가 어려워지고 있다.

State-of-the-art-methods

이 논문에서는 현재 SOTA를 3가지로 나누어서 설명하고 있는데

Learning spatial domain features
1. 예전에 사용한 방법은 이미지의 기원을 찾는 방법이나 위에서 말했던 fingerprint를 찾는 방법이다.
2. GAN의 특성을 exploit 하여 색의 intensity value의 한계, saturated or underexpose region 존재 유무, color band 간의 상관관계 등등을 이용하여 판단을 한다
Learning frequency domain features
1. Fourier domain에 있는 trace들을 활용하여 upsampling시에 남은 흔적이나, 여러 가지 achitiecture만의 흔적을 찾는다
2. Fourier spectra를 활용한 CNN-based classifier 활용
3. 생성 이미지와 진짜 이미지와의 energy spectral distribution을 비교
Learning feature that generalize
1. 위에 제기된 방법들은 training data가 test data와 같을 때 유효하지만 generalization이 약하다. 이를 위해 few-shot learning 방법들이 제시되었다(autoencoder-based)
2. Augmentation(gaussian blurring)을 활용하여, 더 generalize 한 feature을 학습하도록 하는 방법이 있다. 이를 쓰면 하나의 GAN architecture만으로도 학습을 하여도 높은 generalization 성능을 보여주었다.
3. fully convolutional patch-based classifier을 활용하여 patch에 집중함으로써 더 좋은 성능을 보여줄 수 있다

Datasets

https://arxiv.org/pdf/2104.02617.pdf

이 실험에서 사용한 데이터는 36만 장의 LSUN 데이터셋에서 가져온 진짜 이미지와 각각 다른 cateogry에서 학습한 20개의 ProGAN 모델을 사용하여 36만 장의 생성 이미지를 만들었다. Generalization을 테스트하기 위해서 testing phase에서는 training때 보지 못한 low-resolution(256x256)과 high-resolution(1024x1024) 이미지가 섞인 7개의 다른 GAN 모델에서 생성한 이미지를 사용하였다. 또한 ImageNet, COCO, RAISE 데이터를 진짜 이미지로 사용하였다.

Experimental Results

이 논문에서는 다양한 detector(Xception, SRNet, Spec, M-Gb, Co-Net, Wang2020, PatchForensics)를 시험을 했다. 논문에서는 SRNet이 noise residual에 관련된 feature들을 보존하는 데다가 downsampling이 없어서 좋다고 한다. Generalization을 테스트한 실험에서는 AUC는 높지만 accuracy 같은 경우에는 좀 낮은 부분이 있다고 한다. 또한 compression을 진행했을 때 augmentation을 사용해서 학습한 모델이 좋은 결과를 보여주고 있다고 한다. 어떤 상황에서라도 2x downsampling을 하면 성능이 낮아진다. 이는 GAN의 artifact를 소실시켜 주는 역할을 하기 때문이다.

https://arxiv.org/pdf/2104.02617.pdf

또한, contributing factor을 찾기 위해 실행한 실험에서는 다음과 같이 variable을 바꾸어 보면서 진행했는데 no downsampling이 큰 역할을 한다는 것을 알 수 있다. 논문에서는 15%의 accuracy와 14%의 Pd@5%의 증가를 가져왔다고 한다.

Conclusion

아직 GAN image detection을 하기 위한 reliable tool은 없다
downsampling을 하지 않는 것이 성능을 올려준다

[논문 리뷰] Prioritized Experience Replay (PER)

연두색연필 — Mon, 22 May 2023 17:42:41 +0900

[1511.05952] Prioritized Experience Replay (arxiv.org)

Prioritized Experience Replay

Experience replay lets online reinforcement learning agents remember and reuse experiences from the past. In prior work, experience transitions were uniformly sampled from a replay memory. However, this approach simply replays transitions at the same frequ

arxiv.org

이 논문은 DQN의 uniformly sampled experience replay를 중요도에 따라 prioritized experience replay로 바꾸어서 성능 향상을 이루어 냈다. DQN논문의 마지막에 prioritized sweeping에 대해 이야기를 하면서 성능 향상의 가능성의 제기하는데 이 논문이 그것을 이루어낸 논문이다.

[논문 리뷰] Human-level Control through Deep Reinforcement Learning (DQN) — LimePencil's Log (tistory.com)

[논문 리뷰] Human-level Control through Deep Reinforcement Learning (DQN)

Human-level control through deep reinforcement learning | Nature 이번에는 Nature지에 발표된 DQN관련된 논문을 리뷰해보고자 한다. Playing Atari with Deep Reinforcement Learning과 거의 같은 저자들이 작성을 했는데 이는

limepencil.tistory.com

Introduction

Online RL은 바로 들어온 데이터를 이용해 파라미터를 업데이트하는데 이는 두 가지의 문제가 있다.

RL에서는 연속되는 데이터 간의 상관관계가 아주 크기 때문에 기존의 stochastic gradient algorithm에 부적합하다.
rare 한 경험을 나중에 사용하지 못하고 잊어버리게 된다

이를 해결하기 위해 experience replay가 나왔고 덕분에 예전의 데이터와 최신의 데이터를 같이 학습하여 위에 제기된 문제들을 모두 해결하였다. DQN에서는 이것을 사용하여 가치함수의 학습을 안정화시켰다. DQN에서는 large sliding widnow replay memory를 사용하였는데 이는 필요한 데이터를 줄이고 이를 더 많은 계산과 메모리로 대체하였다.

하지만 위의 방법에서는 같은 확률로 모든 데이터를 사용하기 때문에 더 좋은 데이터와 덜 좋은 데이터의 차이를 구분하지 못한다는 단점이 있다 이를 염두의 두고 만든 게 prioritized experience replay (PER)이다. 이 논문에서는 temporal-difference(TD) error의 크기를 기준으로 삼아 priority를 정의하였다.

TD error은 value function의 예측값과 실제 $V$의 차이의 크기이다.

Background

많은 뇌과학적인 studies를 통해 쥐의 hippocampus에서 experience replay가 되고 있다는 사실이 밝혀졌다. 또한, 보상과 관련된 sequence는 더 자주 replay 되었다. 또한, TD error이 높은 sequence도 자주 replay 되었다. 이를 강화학습의 알고리즘에 적용을 하려고 prioritized sweeping이라는 기법이 소개되었고(1999), TD error을 이 priority의 기준으로 적용한 연구가 있었다(2013). 이 논문에서는 이 아이디어를 사용하여 model-free RL에 맞추어 변형을 시켰고 stochastic sampling을 사용하여 function approximator에 더 잘 맞도록 하였다.

Prioritized Replay

Using a replay memory leads to design choices at two levels: which experiences to store, and which experiences to replay (and how to do so). This paper addresses only the latter: making the most effective use of the replay memory for learning, assuming that its contents are outside of our control.

Replay memory를 사용하기 위해서 고려해야 할게 두 가지가 있는데:

어떤 experience를 저장할지
어떤 experince를 학습할지

이 논문에서는 1번은 컨트롤 밖이라고 생각하여 2번에 집중한다.

https://arxiv.org/pdf/1511.05952.pdf

이 논문에서는 Blind Cliffwalk라는 환경을 예를 들어 왜 중요한지 설명한다. 이 환경에서는 reward를 random 한 방식으로 얻는데 $2^{-n}$만큼의 step이 필요한데 이를 기존의 experience replay를 사용한다면 너무 많은 실패에 성공한 experience가 묻힐 것이다. 위의 그래프를 보면 어떠한 strategy를 가지고 replay를 선택한 방법이 랜덤 하게 고르는 것보다 훨씬 더 빠른 학습 속도를 보여준다.

priority의 기준을 TD error으로 잡으면 agent가 이 experience가 얼마나 unexpected 했는지, 즉 배울 점이 많은지를 어느 정도 측정할 수 있다. 이것은 특히 online RL에 적합하지만 reward가 noisy 한 경우에는 잘 작동을 하지 않을 수 있다. TD error 순서대로 나열하고 이대로 학습을 하는 greedy TD-error prioritization은 위에 얘기했었던 환경에서 상당한 속도 향상을 보여줬다.

하지만 이 방식에는 여러 가지의 문제가 있는데:

TD error 순서대로 replay가 되기 때문에 TD-error이 낮은 sequence는 한 번도 replay가 안될 수도 있다.
stochastic reward 같은 noise에 취약하다
너무 한정된 experience만 반복해서 학습한다.

이것을 해결하기 위해 이 논문에서는 stochastic sampling을 제안한다. Stochastic prioritization을 사용하면 priority의 순서는 maintain 되나 모든 experience에 대해 0이 아닌 sampling 확률을 보장한다. 확률은 다음과 같은 식으로 정의된다. $$P(i) = \frac {p_i^\alpha}{\sum_k p_k^\alpha}$$

여기에서 $p_i$는 priority이고 $\alpha$는 얼마만큼의 prioritization을 사용하는지에 대한 hyperparameter이다 ($\alpha$ = 0일 때 uniform).

이 논문에서는 $p_i$에 대해서 두 가지를 제시하는데:

Proportional prioritization: $p_i = |\delta_i| + \epsilon$ ($\epsilon$ is to have non-zero priority)
Rank-based prioritization: $p_i = \frac {1}{\text {rank}(i)}$

https://arxiv.org/pdf/1511.05952.pdf

이 논문에서는 rank-based가 outlier에 영향을 받지 않기 때문에 더 robust 하다고 설명하고 있다. 실제로 위의 그래프를 보면 Blind Cliffwalk 환경에서 더 빠른 속도로 학습하고 있는 것을 알 수 있다.

하지만 prioritization을 사용하면 expected distribution에서 멀어지기 때문에 bias가 생긴다. 이는 수렴해야 하는 정해진 정답에서 멀어지도록 된다. 이를 해결하기 위해 importance-sampling(IS)을 도입하여 해결하고자 했다.

$$w_i = \left(\frac {1}{N} \cdot \frac {1}{P(i)}\right)^{\beta}$$

이 weight을 Q-learning update때에$\delta_i$대신 $w_i \delta_i$로 사용하면 된다 ($\frac {1}{\max_i w_i}$를 사용하여 normalize 해준다). $\beta$를 어떤 값에서 시작하여 1로 anneal 하게 만들면 처음에는 크게 update가 반영이 되다가 점점 안정적으로 변한다. 이 방식의 장점은 high-error인 transition을 자주 보게 만들면서 그의 따른 gradient magnitude를 줄일 수 있는 방법이다.

Atari Experiments

https://arxiv.org/pdf/1511.05952.pdf

DRL에서는 빼놓을 수 없는 Atari benchmark에서 DQN과 DDQN에 PER을 결합하여 state-of-the-art를 달성하였다. 이번 논문에서 나온 hyperparameter인 $\alpha$와 $\beta_0$는 coarse grid search를 사용하여 적절한 값을 찾았다. 이 방법은 성능을 올릴뿐더러 더 빠르게 학습을 진행시킬 수 있다. 또한 DDQN의 예시를 통해 DQN의 improvements들과 complementary 하다는 것이 증명되었다.

Discussion & Conclusion

Rank-based가 예상과는 다르게 그렇게 robust 한 성능을 보여주지 않았는데 이는 relative error scale을 없애면서 performance drop이 생기기 때문이다. 또한 과도한 clipping이 두 가지의 방법이 비슷한 결과를 가지고 오게 하는 이유일 수도 있다. PER을 supervised learning에도 적용시키는 방법을 말하고 있고, 또한 prioritized memory 같은 맨 처음에 말했었던 방법을 제시하고 있다. 결론적으로, PER은 학습 속도를 2배를 향상하면서 성능을 높였고 이는 RL 학습을 효율적으로 하는데에 기여했다.

[논문 리뷰] Dueling Network Architectures for Deep Reinforcement Learning (Dueling DQN)

연두색연필 — Sat, 13 May 2023 10:15:53 +0900

[1511.06581] Dueling Network Architectures for Deep Reinforcement Learning (arxiv.org)

Dueling Network Architectures for Deep Reinforcement Learning

In recent years there have been many successes of using deep representations in reinforcement learning. Still, many of these applications use conventional architectures, such as convolutional networks, LSTMs, or auto-encoders. In this paper, we present a n

arxiv.org

이번 논문에서는 두 개의 estimator 즉 state value function과 action advantage function 두 개를 DQN에서 변형한 논문에 대해 리뷰할 것입니다. DQN에 대한 리뷰는 아래 글을 참조하시면 됩니다.

[논문 리뷰] Playing Atari with Deep Reinforcement Learning (DQN) — LimePencil's Log (tistory.com)

[논문 리뷰] Playing Atari with Deep Reinforcement Learning (DQN)

limepencil.tistory.com

Introduction

Here, we take an alternative but complementary approach of focusing primarily on innovating a neural network architecture that is better suited for model-free RL.

논문에서는 현존하는 model-free RL의 neural network에 complementary 한 improvement를 적용한 방법론을 설명하고 있다. 이 방법의 장점은 다른 RL 알고리즘과 간단하게 통합해서 작동할 수 있다. 이것을 논문에서는 dueling architecture이라고 하고 있는데, state value의 표현과 action advantage의 표현을 따로 분리해서 학습한다.

같은 CNN feature을 받아서 state value와 action advantage network로 나누고 이를 다시 special aggregating layer을 통해 합쳐서 state-action value function $Q$를 구할 수 있다. 즉, 기존의 DQN의 single stream에서 dual stream으로 교체한다고 생각하면 된다. 이 네트워크는 자동으로 state value와 action advantage를 인간의 supervision 없이 학습한다.

이 아키텍처는 어떤 state가 중요한지의 대한 것을 action과 관련 없이 판단할 수 있다. 즉 무슨 행동을 하는지 중요하지 않은 state 같은 경우를 판단할 수 있다는 것이다. Redundant 한 action인지 아닌지를 판단할 수 있는 좋은 방법이다.

Background

이 논문의 배경지식으로는 Q-function, DQN(https://limepencil.tistory.com/38), DDQN(https://limepencil.tistory.com/41), PER 등이 나오는데 priotized experience replay를 제외한 나머지는 리뷰 글을 이미 썼고 PER도 곧 쓸 것이다(2023.04.15).

The Dueling Network Architecture

https://arxiv.org/pdf/1511.06581.pdf

Dueling DQN의 구조는 다음과 같다. 위에 있는 그림처럼 single sequence의 fully-connected layer이 있는 것과 대비해서 two sequence의 fully-connected layer이 있고 이들을 합쳐서 하나의 $Q$ fuction이 나오게 된다. 즉 output자체의 형식은 DQN과 같기 때문에 DDQN이나 PER 같은 다른 DQN의 improvement들을 적용하기에 용이하다.

마지막에 합쳐주는 aggregating layer을 $$ Q(s, a;\theta,\alpha,\beta) = V(s, a;\theta,\beta) + A(s, a;\theta,\alpha)$$처럼 그냥 합친다고 생각할 수 있지만 그러면 $V$와 $A$의 차이를 identify 할 수 없기 때문에 다른 수식을 사용해야 한다.

$$ Q(s, a;\theta,\alpha,\beta) = V(s, a;\theta,\beta) + (A(s, a;\theta,\alpha) - \underset {a' \in |A|}{max} A (s, a';\theta, \alpha))$$

이 수식을 사용하면 optimal action인 $$a^* = \mathrm {argmax}_{a' \in \mathcal {A}} Q(s, a';\theta,\alpha,\beta) = \mathrm {argmax}_{a' \in \mathcal {A}} A(s, a';\theta,\alpha)$$ 에서는 $Q(s, a';\theta,\alpha,\beta) = V(s;\theta,\beta)$가 성립한다.

다른 방식으로는 평균을 사용하는 방법이 있는데, 수식은 다음과 같다. $$ Q(s, a^*;\theta,\alpha,\beta) = V(s, a;\theta,\beta) + \Biggl(A(s, a;\theta,\alpha) - \frac {1}{|\mathcal {A}|} \sum_{a'} A (s, a';\theta, \alpha)\Biggl)$$ 이 방법은 $V$의 의미를 잃어버리지만 그 대신 $a^*$에 맞춰 update 하는 것보다 stable 하다. 그래서 이 논문에서는 이 수식을 채용하였다. 어떠한 값을 빼더라도 relative rank는 변하지 않기 때문에 정보의 손실은 일어나지 않는다. 또한 이 계산은 따로 하는 것이 아닌 네트워크의 일부분이기 때문에 auto backpropagation이 가능하다.

Experiments

The results show that with 5 actions, both architectures converge at about the same speed. However, when we increase the number of actions, the dueling architecture per forms better than the traditional Q-network.

https://arxiv.org/pdf/1511.06581.pdf

실험 결과에 따르면 Corridor이라는 실험 환경에서 Dueling DQN은 그냥 DQN보다 action의 개수가 많을 때 더 빠른 convergence를 보여주었다. 이는 공유되는 $V(s;\theta,\beta)$가 general 한 값을 학습하기 때문이다.

https://arxiv.org/pdf/1511.06581.pdf

또한, Atari 벤치마크에서는 DQN, DDQN, Dueling DDQN, 그리고 PER을 적용한 성능을 비교하여 Dueling architecture이 실제 향상이 있다는 것을 증명하였다. 이 논문에서는 다른 hyperparameter은 다 같게 하고 learning rate를 조금 낮게 조정한 후에 convolution layer의 gradient을 $\frac {1}{\sqrt {2}}$로 rescale 하였다. 그리고 10 이상의 gradient를 clipping을 적용하였다. 실제로 모든 성능 향상 방법을 다 채택한 Dueling DDQN with PER이 제일 좋은 성능을 보여주는 것으로 보인다.

https://arxiv.org/pdf/1511.06581.pdf

Saliency map을 계산해서 각 value network과 advantage network이 어떤 것을 집중해서 보고 있는지를 확인해 보면 value network는 앞에 오고 있는 장애물에 집중을 하고(이 state 자체를 판단) advantage network는 곧 닥쳐올 장애물에 집중을 하고 있는 것으로 보인다(이 상황에서 어떤 action을 취해야 하는지 판단). 즉 두 가지의 다른 network가 이 논문에서 제안한 역할을 하고 있는 것이다.

Discussion & Conclusion

이 dueling network의 장점은 보통 single network에서는 한 action에 대하여 update가 진행이 된다면 여기에서는 공통된 $V$가 update가 되기 때문에 더 efficient 하다고 볼 수 있다. 또한 기존의 DDQN은 Q-value 간의 크기 차이가 Q-value자체의 magnitude와 scale차이가 커서 noise를 발생시킬 수 있는데 dueling network는 이런 부분을 해결한다.

마무리를 하자면, 이 논문에서는 기존의 DQN의 network를 value network와 advantage network로 나누어서 Atari benchmark에서 state-of-the-art를 달성하였다.

[논문 리뷰] Deep Reinforcement Learning with Double Q-learning (DDQN)

연두색연필 — Thu, 4 May 2023 19:19:02 +0900

[1509.06461] Deep Reinforcement Learning with Double Q-learning (arxiv.org)

Deep Reinforcement Learning with Double Q-learning

The popular Q-learning algorithm is known to overestimate action values under certain conditions. It was not previously known whether, in practice, such overestimations are common, whether they harm performance, and whether they can generally be prevented.

arxiv.org

이번 논문은 DQN에서의 target을 변형시켜서 overestimation을 해결한 Double DQN에 대해 리뷰할 것이다. DQN에 대한 리뷰는 아래 블로그 글을 참조하면 된다.

[논문 리뷰] Playing Atari with Deep Reinforcement Learning (DQN) — LimePencil's Log (tistory.com)

[논문 리뷰] Playing Atari with Deep Reinforcement Learning (DQN)

limepencil.tistory.com

Abstract

The popular Q-learning algorithm is known to overestimate action values under certain conditions. It was not previously known whether, in practice, such overestimations are com mon, whether they harm performance, and whether they can generally be prevented.

이 논문에서는 Q-learning의 하나의 단점을 언급한다. Q-learning에서 action value를 overestimate 하는 경향이 있는데 이것을 해결할 수 있는지 탐색해 본다고 한다. 또한 제한된 환경에서만 쓸 수 있는 Double Q-learning을 generalize 하게 바꾸어서 DQN의 변형으로 사용하는 연구를 이 논문에 담았다. 이를 통해 기존 벤치마크보다 성능 향상을 보여준다고 한다.

Overestimation이 생기는 이유는 target을 계산할 때 max를 사용하기 때문에 그런데, uniformly overestimating 하다면 이 자체는 문제가 아니지만, 균일하지 않고 학습하고 싶은 state에 집중되어 있지 않다면 이는 성능에 영향을 줄 수 있다.

실제로 DQN에서 overestimation이 관찰되었고 이를 해결할 방안은 이 논문에서 제시한다.

Background

The max operator in standard Q-learning and DQN, in (2) and (3), uses the same values both to select and to evaluate an action. This makes it more likely to select overestimated values, resulting in overoptimistic value estimates. To prevent this, we can decouple the selection from the evaluation. This is the idea behind Double Q-learning.

Double DQN을 위해서는 두 가지의 사전 지식이 필요한데 이는 DQN과 Double Q-learning이다. DQN은 위에 있는 논문 리뷰에 잘 정리되어 있기 때문에 Double Q-learning에 조금 더 집중할 것이다.

Q-learning에서는 $Y_t^Q \equiv R_{t+1} + \gamma \underset{a}{\max}Q(S_{t+1},a;\theta_t)$이라는 타깃을 사용한다.

여기에서 DQN은 target network를 사용하여 $\theta$대신에 $\theta^-$을 사용하여 업데이트한다.

기존의 Q-learning은 같은 max operator이 action을 고르고 평가하는 데에 쓰이기 때문에 이것이 overestimation을 일으킬 수 있다. Double Q-learning은 이 두 개를 나누어서 계산한다. Double Q-learning에는 두 개의 weight $\theta$와 $\theta'$이 사용되는데 이 두 개 중에 하나를 랜덤 하게 골라서 업데이트한다. 하나는 greedy policy를 결정하는 데에 사용하고 나머지 하나는 그의 가치를 계산하는 데 사용한다.

식은 $Y_t^{DoubleQ} \equiv R_{t+1} + \gamma Q(S_{t+1},\underset{a}{\mathrm{argmax}}Q(S_{t+1},a;\theta_t);\theta_t')$ 과 같고 online weight인 $\theta_t$만 업데이트된다. 두 개의 가중치를 바꾸어서 사용하면서 symmetrical 하게 업데이트할 수 있다.

Overoptimism due to estimation errors

In this section we demonstrate more generally that estimation errors of any kind can induce an upward bias, regardless of whether these errors are due to environmental noise, function approximation, non-stationarity, or any other source.

https://arxiv.org/pdf/1509.06461.pdf

이 파트에서는 estimation error이 environmental noise, function approximation, non-stationarity 등 때문에 생길 수 있다고 하고 upward bound와 lower bound를 구한다. 논문에서는 action의 개수가 올라갈수록 그냥 Q-learning은 error이 늘어나는 것을 볼 수 있다. 하지만 Double Q-learning을 사용하면 error이 action의 개수에 비례하지 않는다. 또한 특정한 value function에만 국한되는 현상이 아니기 때문에 이를 해결하는 게 accurate 하게 value function을 근사하는 방법이다.

Double DQN

We therefore propose to evaluate the greedy policy according to the online network, but using the target ne twork to estimate its value. In reference to both Double Q-learning and DQN, we refer to the resulting algorithm as Double DQN.

Double DQN은 Double Q-learning + DQN이라고 보면 된다. target이 $Y_t^{DoubleDQN} \equiv R_{t+1} + \gamma Q(S_{t+1},\underset {a}{\mathrm {argmax}}Q(S_{t+1}, a;\theta_t);\theta_t^-)$로 바뀌는 것 빼고 다른 것이 없다. 여기서 주목할 점은 target 네트워크로 evaluation을 하고 online network는 action selection을 한다는 것이다. 이 방식은 DQN의 장점을 가져가면서도 computationally expensive 하지 않게 성능을 올릴 수 있는 방법이다.

Empirical results

If seen in isolation, one might perhaps be tempted to think the observed instability is related to inherent instability problems of off-policy learning with function approximation. However, we see that learning is much more stable with Double DQN, suggesting that the cause for these instabilities is in fact Q-learning’s overoptimism.

Double DQN은 DQN보다 확실한 성능 향상을 보여준다. 같은 hyperparameter로 학습을 시켜도 더 좋은 결과를 보여주고, fine-tuning을 진행했을 때에는 더욱더 좋은 성능을 보여주었다. 이는 저자들이 말한 overoptimism이 성능을 저하시키는 원인이라는 것을 보여준다.

Discussion & Conclusion

Q-learning은 큰 환경의 문제에서 overoptimistic 하는 경향이 있고 이를 저자들은 Double Q-learning을 DQN에 접목한 DDQN이라는 새로운 아키텍처를 제안한다. DDQN은 overestimation을 줄이고, Atari 2600 벤치마크에서 SOTA를 기록하는 결과를 보여주었다. 또한 DDQN은 DQN을 크게 바꾸지 않기 때문에 periority experience replay나 dueling DQN 같은 다른 향상 방법을 적용할 수 있다.

[논문 리뷰] Deep Recurrent Q-Learning for Partially Observable MDPs (DRQN)

연두색연필 — Sun, 23 Apr 2023 00:53:30 +0900

[1507.06527] Deep Recurrent Q-Learning for Partially Observable MDPs (arxiv.org)

Deep Recurrent Q-Learning for Partially Observable MDPs

Deep Reinforcement Learning has yielded proficient controllers for complex tasks. However, these controllers have limited memory and rely on being able to perceive the complete game screen at each decision point. To address these shortcomings, this article

arxiv.org

이번 논문은 DQN에 LSTM을 추가해서 Partially Obervable MDP(POMDP) 상태일 때 vanilla DQN보다 성능하락을 줄여주는 연구를 리뷰할 것이다. DQN에 대한 리뷰는 아래 블로그 글을 참조하면 된다.

[논문 리뷰] Playing Atari with Deep Reinforcement Learning (DQN) — LimePencil's Log (tistory.com)

[논문 리뷰] Playing Atari with Deep Reinforcement Learning (DQN)

limepencil.tistory.com

Abstract

Deep Reinforcement Learning has yielded proficient controllers for complex tasks. However, these controllers have limited memory and rely on being able to perceive the complete game screen at each decision point. To address these shortcomings, this article investigates the effects of adding recurrency to a Deep Q-Network (DQN) by replacing the first post-convolutional fully-connected layer with a recurrent LSTM.

https://wikidocs.net/152773

이 논문에서는 DQN의 변형인 DRQN을 소개하고 있다. DRQN은 첫 번째 fully connected layer을 LSTM으로 대체하여 한번에 1개의 frame을 보고도 DQN과 비슷한 성능을 낼 수 있다. 더 중요한 것은 input이 지속적으로 주어지지 않고 flickering 할 때에 DQN보다 좋은 성능을 보여준다. 즉, Partially Obervable MDP(POMDP) 상태일 때 성능이 observability에 비례해서 증가한다.

Introduction

However, Deep Q-Networks are limited in the sense that they learn a mapping from a limited number of past states, or game screens in the case of Atari 2600.

DQN은 저번 리뷰에서도 다루었지만 4개의 frame을 stack 해서 학습한다. 이를 통해 속도와 예상 방향을 알 수 있는데 1개의 frame만 있다면 정적이기 때문에 어디로부터 와서 어디로 가는지 알 수가 없다. 즉 DQN은 4개의 frame밖에서 일어나는 상황은 기억할 수가 없다. 하지만 거의 모든 Atari2600게임은 이를 만족하기 때문에 MDP를 따른다고 볼 수 있다.

실제 세상에서는 그 이상으로 필요한 정보가 있을 수 있고 이는 MDP가 아니라 POMDP라고 정의를 해야 한다. 이때 상황에서는 evaluation 단계에서 DQN에 성능이 쭉 떨어지기 때문에 저자들은 LSTM을 DQN과 결합한 DRQN을 제시한다.

Partial Observability

POMDP는 6-tuple로 구성되어 있는데 이는 $(S, A, P, R, \Omega, O)$이다. 이는 $(S, A, P, R)$인 MDP와는 다르다. 여기서 agent는 $o \in \Omega$의 observation을 입력으로 받는다. 이의 확률은 $ o \sim O(s)$로 나타난다. 그냥 DQN과 여기서 차이가 나는데, $Q(o, a|\theta) \neq Q(s, a|theta)$이다. 즉 학습할 시에 완전한 state로 학습을 했다면, 다른 $o$가 나오는 순간 $Q$를 잘못 예측한다는 것이다. 여기서는 sequence of step으로 작동하는 recurrent network가 더 적합하다.

DRQN Architecture

https://arxiv.org/pdf/1507.06527.pdf

DRQN은 DQN의 fully connected layer을 LSTM으로 교체한 간단한 구조이다. 이 구조를 택한 이유는 fully connected layer을 적용하거나 ReLU를 같이 사용하는 것보다 LSTM을 사용하는 방식이 더욱더 효과적이기 때문이다 (그냥 LSTM이 ReLU-LSTM에 비해 709% 성능 향상을 보여준다라고 되어있다). 다른 hyperparameter는 DQN의 그것과 동일하다.

Stable Recurrent Updates

이 논문에서는 recurrent layer을 업데이트하는 두 가지 방법을 설명한다.

1. Bootstrapped sequential updates: replay memory에서 에피소드 하나를 골라 처음부터 끝까지 업데이트를 한다. RNN의 hidden state는 episode동안 전달된다.

2. Bootstrapped random updates: replay memory에서 에피소드를 고르고 랜덤 한 순간부터 한 번의 backward call까지만 update 한다. 즉, RNN의 hidden state는 update마다 0이 된다.

여기서 hidden state를 사용할 수 있는 첫 번째 방법은 DQN의 random sampling policy를 위반한다. 실험에 따르면 두 가지의 policy다 비슷한 성능을 내기 때문에 복잡도를 줄이려 두 번째 방법인 bootstrapped random updates를 사용한다.

Atari Games: MDP or POMDP? / Flickering Atari Games

https://arxiv.org/pdf/1507.06527.pdf

Atari 게임들은 4 frame을 stack 하면 게임의 모든 상황과 운동 방향을 알 수 있기 때문에 MDP라고 할 수 있다. 그래서 이 논문에서는 이 게임들을 POMDP로 만들기 위해 flickering probablity $p = 0.5$를 적용했다. 이는 각 frame마다 50%의 확률로 검은색 frame이 게임 화면 대신에 들어간다는 뜻이다. 속도를 agent가 알아내기 위해서는 여러 프레임이 필요한데 이는 flickering frame과 맞지 않는다. Convolution filter을 관찰한 결과 velocity의 예측이 conv layer위에서 일어나는 것을 볼 수 있다.

https://arxiv.org/pdf/1507.06527.pdf

하지만 DRQN은 single frame이 입력으로 주어져도 성능을 잘 내는 것을 볼 수 있는데 이는 convolution의 영향이 아닌 LSTM의 영향이라고 볼 수 있다. RNN의 특성이 velocity detection을 도와주는 것이다. 이는 frame-stacking을 대체할 method가 LSTM이라고 볼 수 있다.

Evaluation on Standard Atari Games / MDP to POMDP Generalization

https://arxiv.org/pdf/1507.06527.pdf

실험 결과를 보면 평범한 4 frame stack환경에서는 DRQN과 DQN의 성능 차이가 크게 나지 않는다. DQN이 조금 더 MDP상황에서는 좋은 성능을 내는 것을 볼 수 있다.

https://arxiv.org/pdf/1507.06527.pdf

하지만, MDP로 training을 시키고 POMDP로 evaluation을 한다면 이야기가 달라진다. 바뀌는 observable probablity에 때라 DRQN이 이 상황에서는 DQN보다 성능 저하가 줄어들었다. 이는 즉 POMDP상활일 때 DRQN이 더 robust 하게 작동한다는 것을 보여준다.

Discussion and Conclusion

이 논문에서는 DQN을 변형하여 fully connected layer 대신에 LSTM을 사용하여 POMDP상황에서 더 좋은 성능을 내는 모델을 만들었다. 또한 single frame만으로도 필요한 속도 정보를 얻을 수 있다. Observability에 비례하는 성능을 DRQN이 보여주었고 MDP로 학습하여도 POMDP로 generalize 가능하다. 하지만 MDP상황에서는 어떠한 성능 향상이나 장점이 없다.

[논문 리뷰] Human-level Control through Deep Reinforcement Learning (DQN)

연두색연필 — Thu, 30 Mar 2023 10:39:29 +0900

Human-level control through deep reinforcement learning | Nature

이번에는 Nature지에 발표된 DQN관련된 논문을 리뷰해보고자 한다. Playing Atari with Deep Reinforcement Learning과 거의 같은 저자들이 작성을 했는데 이는 그전 논문에서 여러 가지 실험이 추가된 것이다. 그래서 DQN에 관한 것을 알고 싶다면 밑에 있는 링크를 타고 들어가 읽으면 된다. 이번 리뷰에서는 추가된 실험들만 다루겠다.

[논문 리뷰] Playing Atari with Deep Reinforcement Learning (DQN) — LimePencil's Log (tistory.com)

[논문 리뷰] Playing Atari with Deep Reinforcement Learning (DQN)

limepencil.tistory.com

바뀐 점

게임의 개수

https://storage.googleapis.com/deepmind-media/dqn/DQNNaturePaper.pdf

Our DQN method outperforms the best existing reinforcement learning methods on 43 of the games without incorporating any of the additional prior knowledge about Atari 2600 games used by other approaches (for example, refs 12, 15). Furthermore, our DQN agent performed at a level that was comparable to that of a pro fessional human games tester across the set of 49 games, achieving more than 75% of the human score on more than half of the games.

게임의 개수가 그 전의 7개에 비해서 49개로 늘었다. 이는 genaralization성능을 더욱더 보여주며 다양한 환경에서 DQN이 잘 작동한다는 것을 보여준다. 또한 절반정도의 게임에서 인간의 75% 이상의 성능을 보여줬다.

정규화된 성능은 다음 수식을 통해 계산이 된다. $$\text {normalized performance} = 100 \times \frac {\text {DQN score} - \text {random play score}}{\text{human score} - \text{random play score}}$$

학습된 표현 분석

https://storage.googleapis.com/deepmind-media/dqn/DQNNaturePaper.pdf

We next examined the representations learned by DQN that underpinned the successful performance of the agent in the context of the game Space Invaders, by using a technique developed for the visual ization of high-dimensional data called ‘t-SNE’.

이 논문에서는 높은 차원의 데이터를 2차원에 축소해서 보여주는 기법인 t-SNE를 사용해서 분석을 하였다. 예상대로 비슷한 state를 가진 DQN representation을 서로 가까이 mapping 하였다. 또한, t-SNE embedding에서 다른 모양의 state지만 비슷한 expected reward를 가진 점들도 가까이 mapping하였다. 이는 DQN이 높은 차원의 데이터인 픽셀데이터를 통해 정확하게 표현을 학습하고 있다는 것을 보여준다. 인간과 agent의 데이터를 두 개 다 넣었을 때에도 t-SNE에서 확인을 하면 비슷한 위치에 mapping이 되어 자신이 학습한 policy가 아니더라도 generalization성능을 가지고 있다는 것을 보여준다.

문제점

Nevertheless, games demandingmore temporally extended planning strategies still constitute a major chal lengefor all existing agents including DQN (for example, Montezuma’s Revenge).

long-term planning이 필요한 게임은 아직은 어려워하는 모습을 보여준다. 하지만 밑에 있는 게임처럼 옆에 있는 블록만 깨서 높은 점수를 얻는 방식의 플레이도 가능하다는 것을 보여줬다. 즉, 어느 정도의 long-term planning은 가능하다.

DQN Breakout - YouTube

[논문 리뷰] Playing Atari with Deep Reinforcement Learning (DQN)

연두색연필 — Thu, 23 Mar 2023 14:49:39 +0900

이제부터 이 블로그에 논문을 하나씩 읽으면서 리뷰를 해보려고 한다. 아마 분야마다 시간을 순서대로 큰 영향을 미친 논문을 읽을 것 같다. 이번 논문은 강화학습에 DL을 적용한 첫 번째 성공적인 연구인 Playing Atari with Deep Reinforcement Learning을 읽어보려고 한다. 코드 구현은 다른 글로 해보겠다.

[1312.5602] Playing Atari with Deep Reinforcement Learning (arxiv.org)

Playing Atari with Deep Reinforcement Learning

We present the first deep learning model to successfully learn control policies directly from high-dimensional sensory input using reinforcement learning. The model is a convolutional neural network, trained with a variant of Q-learning, whose input is raw

arxiv.org

Abstract

The model is a convolutional neural network, trained with a variant of Q-learning.

여기서 배경지식이 되는 두 개의 아주 중요한 term이 나온다. 사실 이 두 개의 단어가 이 논문의 핵심이라고 생각해도 된다. 이 두 개에 대해서는 다른 글로 아마 다루겠지만 여기서 잠깐 설명하고 가겠다.

https://stanford.edu/~shervine/teaching/cs-230/cheatsheet-convolutional-neural-networks

CNN(Convolutional Neural Network)이란 이미지처리를 위한 신경망인데, 위치 관계를 잃어버리는 fully-connected neural network와 달리 공간적 관계를 감지할 수 있기 때문에 더 효과적이다. 필터를 픽셀 위로 움직여서 feature map을 만드는데, 이 필터만 학습을 시키면 된다. 그리고 필터 외에도 보통 pooling layer이 있는데 차원을 낮추어주는 역할을 한다.

https://blog.floydhub.com/an-introduction-to-q-learning-reinforcement-learning/

Q-learning이란 강화학습 알고리즘의 한 종류로, 최적의 policy를 학습하는 방법이다. 모든 단계를 거쳤을 때 받는 보상을 최적화하는 것을 목표로 한다. 각각의 action에 Q(quality) 값을 부여해서 더 좋은 행동을 취하는 방식이다.

We apply our method to seven Atari 2600 games from the Arcade Learning Environment, with no adjustment of the architecture or learning algorithm. We find that it outperforms all previous approaches on six of the games and surpasses a human expert on three of them.

이 논문의 결과가 인간을 뛰어넘는 성능을 보여줄 수 있다는 결과를 내었다고 하고 있다.

Introduction

Most successful RL applications that operate on these domains have relied on hand-crafted features combined with linear value functions or policy representations. Clearly, the performance of such systems heavily relies on the quality of the feature representation.

Recent advances in deep learning have made it possible to extract high-level features from raw sen sory data, leading to breakthroughs in computer vision and speech recognition.

이전의 RL은 인간이 직접 만든 feature로 작동했기 때문에 이 feature의 quality에 따라 성능이 좌우되었다. Object detection 같은 분야도 처음에는 hand-crafted방식이었지만 현재는 DL을 사용하는 것을 보면, RL에서도 충분히 가능한 일이다.

[Handcrafted face recognition] https://www.researchgate.net/figure/An-example-of-traditional-handcrafted-Haar-features-20_fig3_335158836

However reinforcement learning presents several challenges from a deep learning perspective.

하지만 논문에서는 DL을 RL에 바로 적용하기에는 문제가 있다고 하는데 이는

DL은 보통 많은 labeled 데이터가 필요하지만 RL은 reward 같은 scalar, sparse, noisy, and delayed 한 metric에 따라 학습한다. 즉 action과 reward가 엄청 긴 시간 사이를 지나 연관이 있을 수 있다.
DL에서는 데이터들이 independent 하지만 RL에서는 서로 연관이 되어있다.
RL에서는 데이터들이 agent가 학습하면서 바뀐다.

이 논문에서는 이를 해결할 방법으로 CNN과 experience replay mechanism을 내세운다. 이에 대한 설명은 뒤에서 하겠다.

Our goal is to create a single neural network agent that is able to successfully learn to play as many of the games as possible. The network was not pro vided with any game-specific information or hand-designed visual features, and was not privy to the internal state of the emulator; it learned from nothing but the video input.

하나의 네트워크로 다양한 게임을 할 수 있게 한다는 것은 환경에 관계없이 학습을 할 수 있다는 것이다. 이를 보여주기 위해 DeepMind 팀은 hyperparameter를 고정을 시켜 학습을 시켰다.

Background

The emulator’s internal state is not observed by the agent; instead it observes an image $x_t ∈ R^d$ from the emulator, which is a vector of raw pixel values representing the current screen.

agent는 스크린에 있는 픽셀 값만 입력으로 받고 다른 internal 한 정보를 받지 않는다. 또한 모든 sequence는 유한하기 때문에 MDP(Markov Decision Process)가 적용이 된다.

MDP를 이해하기 위해서는 Markov Property를 이해해야 한다. Markov Property는 한마디로 미래는 현재가 주어졌을 때 독립적이라는 것이다.

즉, $P [S_{t+1}|S_t]=P [S_{t+1}|S_1,..., S_t]$가 성립한다.

이 말의 뜻은 $S_t$를 알면 $S_{t+1}$을 찾기 위해 과거의 정보가 필요 없다는 뜻이다. 즉 memory-efficient 하다.

이제 Markov Decision Process라는 것은 state, action, state transition property, reward function, 그리고 discount factor들의 요소가 있는 것의 정의이다. 보통의 RL은 이것들을 포함하고 있기 때문에 알고리즘들을 적용할 수 있다.

이때 이제 $Q(s, a)$라는 $Q$함수를 정의하고 최적의 함수는 $Q^*(s, a)=\max_\pi \mathbb {E}[R_t|s_t=s, a_t=a,\pi]$로 된다.

여기에서 Bellman equation을 사용해서 최적의 Q함수를 찾는 strategy를 구할 수 있는데 이는 $Q^*(s, a)=\mathbb {E}_{s'\sim \epsilon}[r+\gamma \max Q^*(s', a')|s, a]$이다.

이 value iteration algorithm을 쓰면 $Q_i \rightarrow Q^* $ as $i \rightarrow \infty$ 에 최적의 함수로 수렴한다는 게 보장이 된다. 하지만, 이 방법을 쓰면 각 sequence마다 측정해야 하기 때문에 function approximator를 사용해서 action-value function을 근사한다 $Q(s, a;\theta) \approx Q^*(s, a)$. 이 논문에서는 non-linear 한 방식으로 neural-network를 사용한다. 이를 Q-network라고 부르는데
$$L_i(\theta_i) = \mathbb {E}_{s, a\sim \rho(\cdot)}[(y_i-Q(s, a;\theta_i))^2]$$
$$\text {where}$$
$$y_i =\mathbb {E}_{s'\sim \mathcal {E}}[r+\gamma \max Q^*(s', a';\theta_{i-1})|s, a]$$ 이 loss function을 최소화하는 것으로 구할 수 있다.

Supervised learning과는 다르게 $y_i$인 target은 $\theta_{i-1}$의 영향을 받음으로써 학습 데이터 자체가 학습 시작 전에 정해진 것이 아니라 학습을 하면서 바뀐다.

위의 손실함수를 미분해서 복잡하게 구할 수 있지만, SGD(Stochastsic Gradient Descent)를 통해서 최적화하는 게 computationally expendient 하다.

이 알고리즘은 model-free 하고($\mathcal {E}$의 estimate을 학습하는 것보다 그것에서 나온 sample만으로도 학습한다) off-policy 하다($a=\max_a Q(s, a;\theta)$ 의 그리디 전략으로만 학습하고 $\epsilon$-greedy 전략으로 충분한 state space를 탐색한다.

Related Work

http://incompleteideas.net/book/ebook/node108.html

TD-gammon: 현재의 DQN과 비슷하나 특별한 케이스에서만 작동하고 체스나 바둑 같은 게임에서는 작동하지 않는다. 또한, Q-network는 발산하기가 쉽기 때문에 linear function approximator를 이전에서는 많이 사용했다.

NFQ(Neural Fitted Q-learning): RPROP 알고리즘을 사용해서 Q-network를 업데이트하지만 batch update를 사용함으로써 높은 computational cost를 가지고 있다. 또한 DQN과 다르게 deep autoencoder를 사용해서 이 task의 representation을 먼저 학습하기 때문에 end-to-end RL인 DQN과는 차이가 있다.

Deep Reinforcement Learning

Our goal is to connect a reinforcement learning algorithm to a deep neural network which operates directly on RGB images and efficently process training data by using stochastic gradient updates.

Deepmind 팀은

TD-Gammon 같은 online approach보다 experience replay라는 mechanism을 사용해서 $e_t=(s_t, a_t, r_t, s_{t+1})$라는 데이터를 $\mathcal {D} = e_1,... e_N$라는 큐에 저장하는 방식을 채용했다. 이를 실행한 뒤에는 $\epsilon$-greedy라는 방법을 사용해서 state space를 탐색한다.

$\epsilon$-greedy를 간단하게 설명하자면 policy가 정한 action을 $1-\epsilon$의 확률로 실행하고 나머지 확률인 $\epsilon$동안에는 랜덤한 action을 실행한다. 이를 통해서 더욱더 다양한 state들을 탐색해 볼 수 있다.

이 논문에서는 이 알고리즘을 Deep Q Learning이라고 소개하고 있다.

Online Q learning보다 DQL이 우수한 이유:

한 데이터가 여러번의 update에 쓰일 수 있기때문에 데이터적으로 효율적이다.
연속적인 샘플으로 학습을 하는 것은 데이터간의 상관관계가 크기 때문에 비효율적이다. 랜덤한 데이터를 사용하는게 gradient 업데이트의 편차를 줄여준다. 만약에 연속적인 샘플로 학습을 한다면, 그 연속적인 샘플과 완전히 다른 데이터가 들어올 경우에는 gradient값이 확 튀어서 generalization 성능이 내려간다.
on-policy로 학습을 하면 현재의 parameter이 샘플에 영향을 주기 때문에 bias된 샘플만 학습이 될 수 있다. 만약에 왼쪽으로 가는 Q 값이 제일 크다면 그 값을 학습한것 때문에 다음에도 왼쪽으로만 가는 feedback loop이 생길 수 있다. 이는 weight값을 무한히 발산하게 만들 수 있는 문제를 일으킬수 있다. 이 논문에서는 off-policy인 experience replay를 사용하면서 parameter의 발산을 막았다.

하지만 이 논문에서는 이 experience replay방법은 각 step의 다른 중요성을 고려하지 않기 때문에 priortized sweeping 같은 방법을 제안한다. 나중에 나오는 논문에서 이것을 사용한다.

논문에서 사용한 전처리 방법:

Atari게임의 frame은 210 x 160 컬러 픽셀 이미지이다. 이를 그대로 학습에 사용한다면 computationally demanding 하기 때문에 전처리를 거쳐야 한다.

grey-scale로 바꾸어서 이미지의 채널을 3에서 1로 줄여준다 (RGB to black and white)
이미지를 110x84로 downsampling 한다
게임 화면만 들어올수 있게 84x84로 cropping한다. (이를 하는 이유는 2D Convolution이 정사각형만의 input을 받기 때문에
최근 4개의 전처리된 프레임을 쌓아서 Q-function의 입력으로 넣어준다

$Q$를 neural network로 구하는 방법 여러가지가 있다. 첫번째 방법은 image와 action을 신경망에 넣어서 $Q$값을 구하게 하는 방법이다. 이 방법의 문제는 각각의 action마다 forward pass를 실행해야하기에 $n$개의 가능한 action이 있다면 $O(n)$번이나 반복해야한다.

이 방법보다 더 효율적인 방법이 있는데, 이는 신경망에 마지막 출력 노드들 하나당 가능한 하나의 action으로 정의하고 그 노드에 나온 출력 값이 action에 따른 $Q$값에 대응한다. 이는 첫번째 방법보다 $O(1)$이라는 시복도로 더 효율적이고 action space가 넓어질수록 효과적이다.

모델 아키텍쳐 (Deep Q Network):

84x84x4
8x8x16 (Stride 4)
ReLU
4x4x32 (Stride 2)
ReLU
layer with 256 hidden node
output node corresponding to number of valid actions

Experiments

7개의 게임에서 실험을 하였고 각 게임마다 점수의 magnitude가 다르기 때문에

positive reward: +1

negative reward: -1

으로 설정하여 게임마다 같은 hyperparameter을 사용할 수 있게 하였다.

Hyperparameters

Optimizer: RMSProp

Batchsize: 32

$\epsilon$-greedy decay: anealling linearly from 1 to 0.1 over the timestep of 1,000,000

$k$, the frame skipping constant: 4 for most games (performing action every $k$th frame)

Model Performance Evaluation

agent가 한 에피소드당 모으는 최대의 reward (noisy)
최대 평균 $Q$값 (smooth)
- 학습시에 value function이 바뀌는 것을 볼 수 있음

다른 연구들과의 비교

Comparing with other RL algorithm

결론

This paper introduced a new deep learning model for reinforcement learning, and demonstrated its ability to master difficult control policies for Atari 2600 computer games, using only raw pixels as input. We also presented a variant of online Q-learning that combines stochastic minibatch up- dates with experience replay memory to ease the training of deep networks for RL. Our approach gave state-of-the-art results in six of the seven games it was tested on, with no adjustment of the architecture or hyperparameters.

이 논문에서는 딥러닝 모델을 사용하여 강화학습을 진행하는 연구를 진행하였다. Experience replay memory를 사용하여 Q-learning의 변형인 DQN을 만들었다. 7개의 Atari 게임 중에서 6개의 게임에서 state-of-the-art를 달성했다.

2023년도 공부 계획

연두색연필 — Thu, 16 Mar 2023 14:24:08 +0900

학기가 시작하고 2주가 지났다. 부캠이 끝난 이후에 코딩과 공부를 조금 멀리 했는데, 대충 1달 정도 쉰 것 같다.

2023년도에는 다양한 경험과 공부를 하면서 지내고 싶은데, 이에 대한 계획을 조금 써보자 한다.

Problem Solving과 Competitive Programming 실력 늘리기

대학 입시와 부스트캠프 때문에 문제풀이에 소홀한 감이 없지않아 있는데, 이번 연도에는 확실한 목표를 정해보자 한다.

Solved.ac: 다이아 4~5정도

Codeforces: 블루
또는
AtCoder: 민트 상위

아무래도 현재 파이썬의 한계를 느꼈기 때문에 C++로 1학기에 갈아타서 공부해볼까 한다. 그렇게 한다면 2학기에 있을 자료구조 수업에도 도움이 될 것 같다.

인공지능 공부

PoolC에 가입한 덕분에 이제 같이 스터디나 세미나를 들을 수 있게 되었다. 먼저 강화학습을 공부하고, 다양한 대회나 공모전을 팀을 이루어서 나가고 싶다. 이렇게 하면 같이 포폴을 쌓아서 나중에 도움이 될 수 있을 것 같다.

현재 도서관에 괜찮은 인공지능 공부 책이 많은데 이를 좀 공부해서 블로그에 포스팅을 하는 것도 목표이다.

개발 공부

아무래도 인공지능 엔지니어나 실제로 프로덕트를 배포하는 직종이라면 백엔드와 밀접한 연관이 있기 때문에 이를 더 공부하고 싶다. PoolC에서 대형 프로젝트에 들어가서 공부하거나 현재 조금 다뤄본 FastAPI를 더 공부할까 생각 중이다. 아키텍처 디자인이나 실제 현업에서 어떤 식으로 서비스를 만드는지를 배우는 게 목표이다.

가능하다면 오픈소스 기여를 배우고 하고 싶다.

학부연구생/인턴

이번 여름이나 겨울에는 연대나 한양대에서 연구 인턴을 하거나 회사에 가서 인턴을 하고 싶다. 아무래도 전자가 상대적으로 쉬울 수 있지만 일단을 둘다를 노려보고자 한다. 이를 위해서 깃허브 정리, 포폴 정리, CV 작성이 필요할 듯하다.

개인 프로젝트

이 모든 것을 하면서 개인 프로젝트 하나를 하는 것이 목표이다. 부스트캠프에서 대충 전반적인 서비스를 다루어 보았기 때문에 웬만한 것은 인터넷을 따라보면서 만들 수 있는데, 이게 무엇이 될지는 아직은 모르겠다. 1년짜리 프로젝트가 될 수도 있고 아니면 더 길어질 수도 있다. 부스트캠프 마지막 프로젝트처럼 기록도 하고 작은 것부터 완성도 있게 만들어서 계속 버전을 늘려 나가고 싶다.

이 모든 것을 이번 연도에 할 수 있다고 생각하지는 않으나 열심히 노력한다면 몇 개는 이룰 수 있다고 생각한다. 앞으로 파이팅 하기를.

*수정: 카이스트에 붙으면서 계획을 좀 수정해야겠다.

먼저 석사는 해야할것 같고 그렇다면 연구랑 논문읽기를 더 집중해야겠다.

부스트캠프 AI Tech 4기를 마치며... feat. 부캠 참가를 고려하시는 분들을 위해

연두색연필 — Wed, 1 Mar 2023 17:29:35 +0900

부스트캠프 AI Tech 4기가 2월 14일부로 끝이 났다. CV 트랙으로 들어왔고, 3개의 레벨과 2개의 팀을 지나 수료를 했다. 부캠에 대해 조금만 서술하자면 현재 대학민국에 존재하는 인공지능 전문가 양성 프로그램 중에 강사나 커리큘럼으로 봐도 1등이라고 생각한다. 네이버라는 대기업이 주는 신뢰감과 전문적인 수업들이 실제 현업과 유사하게 이루어지기 때문에 상당히 좋았다고 생각한다.

내 실험을 도와준 값비싼 친구 V100

뭐니 뭐니 해도 사실상 제일 좋았던 건 1인 1 고성능 GPU서버를 제공한다는 것이었다. V100 32Gb GPU를 한 2~3달 정도 제공했는데 저장공간이 조금 적은 것 빼고 배우는 학생에 입장에서는 최상의 장비라고 생각한다. 들어가 있던 Xeon CPU도 좋았고 램도 저장공간만큼 있었다. 개인 서버가 있다 보니 24시간 풀가동 하면서 전기세와 소음 걱정도 없었고, 리눅스 서버다 보니 다양한 커맨드를 연습해 보기도 좋았다.

사실 부캠을 하면서 느꼈던 것은 인공지능과 파이썬에 대한 지식이 없으면 들어와서 따라오기가 상당히 힘들다는 것이다. 비전공자 분들도 많이 계시지만 초반에 상당히 당황하시던 반응이었던 게 기억이 난다. 백준 알고리즘 골드 문제들을 파이썬으로 풀 수 있다면 충분하다고 생각한다. 1주 차에 거의 대학 전공 과정을 속성으로 인공지능의 처음부터 끝까지 가르쳤고, 과제들도 만만하지 않은 수준이었다. 2주 차부터는 슬슬 어려워지는데, 사실 PyTorch를 조금 다루어 보고 부캠에 들어오는 게 따라오기 좋다고 생각한다. 처음에 수학과 수식에 머리가 띵해지는데 사실 이해한다면 좋지만 이론은 사실 응용에는 큰 영향이 없기 때문에 괜찮다.

부캠은 3개의 레벨로 나누어져 있었는데:

인공지능에 대한 전반적인 이론 및 코드 작성법 (8주)
각자 분야 심화 및 대회 (8주)
최종 프로젝트 및 Product Serving (4주)

CV트랙으로 참가한 필자의 부캠에 대한 생각을 쓰자면, 일단 level 2 팀원을 모을 때 신중해야 한다는 것이다. 소통을 잘할 수 있고 어느 정도 혼자서 일을 할 수 있는 사람이 같은 팀원이어야 좋다. 같은 최종프로젝트 주제로만 모으다 보면 팀원과 불화가 생길 수 있고, 친해지기가 어려울 수 있다. 사실 베스트는 level 1 팀원들과 계속 가는 것인데, 안될 것 같다면 빠르게 마음이 맞는 팀원들을 스페셜 피어세션 같은 데서 물색해 보자.

총 4개의 대회를 진행했는데, 등수를 올리는 데에만 집중해서 많은 것을 놓친 느낌이었다. 다양한 것을 시도해 보고 논문도 읽으면서 구현하는 게 제일 좋은데, 이런 것을 하지 못한 게 아쉽다. 이 글을 읽는 부스트캠퍼가 있다면 등수나 성적에 연연하지 말고 다양한 것을 시도해 봤으면 좋겠다. 깃허브와 Jira 같은 협업 툴을 적극적으로 사용하는 것이 좋다.

부캠에서 다양한 채용 기회도 있고 하니 취업을 생각하고 온다면 좋은 선택이라고 생각한다. 하지만 실무 위주로 포커스가 맞춰져 있다 보니까 대학원 진학을 생각하시는 분들에게는 그렇게 맞는 선택은 아니라고 생각한다. 이제 필자는 대학교에 인공지능을 공부하러 들어가지만 커리어 전환을 생각하시는 분들에게는 좋은 시작이라고 생각한다. 가볍게 생각하고 들어오는 것보다는 대학 수업의 상위호환이라고 생각하시고 들어오시면 좋을 것 같다. 팀원들과 같이 일하면서 무언가를 만들어내는 경험이 상당히 중요했다고 느꼈다.

리액트 공부 정리

연두색연필 — Wed, 25 Jan 2023 16:53:55 +0900

사용한 기술 스택들:

React - 생활코딩

리액트 특징: 사용자 정의 태그 만들기

src/index.js 에서 쓰여 있는 데로 npm start가 작동됨

npm run build를 실행하면 빌드가 되고 npx serve -s build를 그다음에 실행하면 배포용 웹이 실행이 된다

태그들의 모음을 함수로 만들고 그 함수를 또 다른 태그/컴포넌트로 사용이 가능하다

prop: 우리가 만든 태그의 속성

- kwargs느낌이라고 생각하면 될듯하다

속성을 출력 하려면 중괄호 안에 넣어줘야 제대로 된다. 중괄호가 없으면 object가 아니라 string이 전달됨

자동으로 react에서 생성한 값들은 key라는 prop이 있어야지 성능이 올라간다

state를 사용해서 이미 정의된 변수의 값을 변화시켜 페이지에 반영을 할 수 있다.

primitive data type이 아니면 ...으로 복사 후 setValue하기

prop의로 받은 값은 바꾸지 못하기 때문에 update할 때는 state로 변환을 해준다

리액트를 다루는 기술

빈 태그는 그룹핑 용으로 사용 가능

- 자바스크립트 변수 안에는 하나의 태그만 들어가야함

- <Fragment> 과 동치

undefined를 return하면 오류가 생기기 때문에 조심하자

- 하지만 jsx안에서 undefined를 rendering하는 것은 가능하다.

리액트에서 DOM 요소에 스타일을 적용할 때는 문자열 형태로 넣는 것이 아니라 객체 형태로 넣어 주어야 한다.

- camelCase 적용

jsx에서 css 클래스를 사용할 때는 class attribute 대신에 className을 사용한다.

{/* */}를 사용하면 페이지에 보이지 않지만 //이나 /*을 사용하면 그대로 나타나게 된다

클래스형 컴포넌트와 함수형 컴포넌트의 차이

클래스형:

조금 더 복잡함
state 바로 사용 가능

함수형:

React에서 권장함
선언하기가 간단하다
메모리를 적게 사용한다
state와 lifecycle API 사용 불가
- Hook으로 해결 가능

React - 생활코딩 (opentutorials.org)

React - 생활코딩

리액트 입문자를 위한 수업입니다. 기본 문법과 핵심 개념을 익힐 수 있습니다. 만들게 될 것 앱 : https://egoing.github.io/react-2022-tutorial-src/ 소스코드 : https://github.com/egoing/react-2022-tutorial-src 알게

opentutorials.org

더북(TheBook): 리액트를 다루는 기술 [개정판]

리액트를 다루는 기술 [개정판]

더북(TheBook): (주)도서출판 길벗에서 제공하는 IT 도서 열람 서비스입니다.

thebook.io

자바스크립트 공부 정리

연두색연필 — Sun, 22 Jan 2023 23:57:54 +0900

사용한 기술 스택들:

html에 자바스크립트 코드를 작성하고 싶으면 <script> 태그 안에 넣는다

<input> 태그에서 on~ attribute는 javascript 코드를 이벤트가 트리거 될 때 실행시켜 준다

F12를 눌러 console로 들어가서 javascript 코드를 임의로 실행시킬 수 있다

HTML style attribute를 사용하면 css를 적용할 수 있다.

<div>: 아무 의미도 없지만 자바스크립트로 그 태그를 제어하고 싶을 때 사용한다. 줄 바꿈이 됨

<span>: div와 같지만 줄 바꿈이 없음

HTML class attribute를 사용하면 한 번에 그 클래스를 가진 태그를 제어할 수 있다. (css앞에 .을 붙인다)

HTML id attribute를 사용하면 한번에 그 아이디를 가진 태그를 제어 할 수 있다. (css 앞에 #를 붙인다)

- id는 유니크하기 때문에 클래스와 다르게 한 번만 사용해야 한다

javascript에서 querySelector으로 지정해서 불러오기 가능

querySelectorAll을 쓰면 모든 것을 array로 불러온다

자바스크립트에서 ===는 파이썬에서의 ==와 동치

this: 자바스크립트에서 자기 자신을 가르키는 변수

라이브러리: 부품을 가져오는 느낌

프레임워크: 반제품을 가져오는 느낌

WEB2 - JavaScript - 생활코딩 (opentutorials.org)

WEB2 - JavaScript - 생활코딩

수업소개 이 수업은 https://opentutorials.org 를 만들어가면서 JavaScript에 대한 지식과 경험을 동시에 채워드리기 위한 목적으로 만들어진 수업입니다. 수업대상 이 수업은 웹 페이지를 사용자와 상

opentutorials.org

HTML 공부정리

연두색연필 — Fri, 20 Jan 2023 15:49:53 +0900

사용한 기술 스택들:

HTML 태그들:

<u>: 밑줄
<strong>: 볼드
<h1>~<h6>: 제목
<br>: 줄바꿈(쌍 없음)
<p>: 단락
<img>: 이미지 넣기(쌍 없음)
- scr: 이미지의 소스 attribute
- width: 너비 조정
<li>: 리스트
<ul>: 리스트를 다른 리스트와 구분 시켜주는 parent tag
- unordered list
<ol>: 순서가 있는 리스트, 마찬가지로 parent tag
- ordered list
<title>: 웹페이지의 제목
<meta charset="utf-8">: utf-8로 해석
- 한글을 지원하는 형식
<head>: 본문을 설명하는 태그들의 parent
<body>: 본문 그 자체인 태그들의 parent
<html>: head와 body를 감싸는 태그
<!doctype html>: 이 웹페이지가 html로 만들어 졌다고 문서 제일 위에 쓰는 태그
<a>: 링크
- href: HyperText Reference
- target: 어디에서 이 링크를 열건지
  - _blank: 새로운 탭에서 열기
  - _self: 현재의 탭에서 열기 (기본값)

Web Server: 요청을 받는 컴퓨터Web Client: 요청을 하는 컴퓨터 (보통은 웹 브라우저)

웹서버 로컬 제품:

Apache
IIS
Nginx

WEB1 - HTML & Internet - 생활코딩 (opentutorials.org)

WEB1 - HTML & Internet - 생활코딩

--- 우리는 지금부터 코딩 웹 인터넷 컴퓨터라는 거대한 주제에 대한 탐험을 시작할 거예요. 이 여행을 시작하기에 앞서서 한가지 준비가 필요한데요. 바로 우리들의 상상력입니다. 지금부터 여

opentutorials.org

포트폴리오 잘 쓰는 법

연두색연필 — Wed, 11 Jan 2023 16:02:25 +0900

업스테이지 이활석 CTO님의 포트폴리오 특강을 정리한 내용이다

파일 이름:

파일 이름에 이름, 회사명, 날짜, 버전을 넣어주면 신뢰도가 늘어난다

출력본을 따로 만들어두면 좋을 수도 있다.

블로그:

블로그를 첨부한다면 최신 글들이 있는게 보기가 좋다

문서 요약:

적정한 정보량(3분) 안에 모든 것을 보여주어야함

지원 동기 쓰자:

이 회사에만 적용되는 지원 동기를 쓰는게 어드벤티지가 될 수도 있다.

이력서 + 포트폴리오:

이력서로 최대한 자신이 한 일을 요약을 하고 포트폴리오를 같이 넣어서 심사하시는 분이 보고 싶으시다면 보게 하는게 좋음

이력서 하나로 서류 통과가 베스트

자신이 한 일이 드러나야 한다:

논문: 공저자 중에 몇 번째

학회 이름으로 가늠이 가능

대회 수상: 대회명으로는 가늠이 안됨

대회의 대한 정보(팀원 수, 몇 등, 대회 기간)
본인의 역할
캐글이 그나마 낫다

차별화:

회사 맞춤형
부서 맞춤형
같은 결과물에 대한 본인만의 해석
발표 능력, 문서 정리 능력

부스트캠프 17주차 학습 일지 - Product Serving

연두색연필 — Tue, 10 Jan 2023 12:34:41 +0900

사용한 기술 스택들:

1/10 월

학습한 것들:

We use cloud service so that the server is up 24 hours.

Serverless computing: the server is controlled by the cloud by uploading the code to the cloud

Stateless Container: docker image-based server

Object Storage: can store many types of files

Database: for web/app

Data Warehouse: database for data analysis

CI: automating build and testing

CD: automating deployment

Workflow: the topmost unit that controls GitHub Action

Job: a combination of steps that can run both in parallel and in order and they can have a dependency on each other

Step: operation running on the job, able to run shell command and execute an action, and the data is shared across the job

Action: a collection of step that is reusable

Runner: server that runs workflow, can be hosted by GitHub or own server

Monolithic Architecture: all things are done by one server

Microservice Architecture(MSA): make different servers do different jobs and communicate by request

HTTP(Hyper Text Transfer Protocol): a protocol that needs to be kept in order to exchange information

REST API: work by CRUD(Create, Read, Update, Delete)

client: a platform that requests action
resource: unique ID resource(URI)
- URL(Uniform Resource Locator): location of the resource on the internet
- URI(Uniform Resource Indicator): a string that is used to identify resources
  - URI contains URL
method: ways to request the server
- GET: 정보를 요청
  - by putting data in the URL and header
  - vulnerable because the data is in the URL and head
  - able to be cached
- POST: 정보를 입력
  - submit data to add or modify
  - data is not in the URL
  - data is in the body
  - safer compared to GET
  - Not able to be cached
    - need architecture to cache
- PUT: 정보를 업데이트
- PATCH: 정보를 업데이트
- DELETE: 정보를 삭제

HTTP protocol saves the information to a packet when sending or receiving

packet: header + body
- header: address, receiving address, time
- body: actual content that is to be sent

Status code: how the server reacts to the request

1xx: got request, continue process
2xx: got request, executing
3xx: need more jobs to be completed to complete the request
4xx: grammar wrong or cannot process request
5xx: the server failed in regard to the request

IP(Internet Protocol): the address of the PC that is connected to the network

IPv4 consists of 4 blocks of number
- can represent $2^{32}$ addresses
- IPv6 released to increase the number
127.0.0.1: localhost
0.0.0.0, 255.255.255.255: broadcast address that communicates with all the devices connected to the local network

Port: channel that can access the PC

cannot have duplicate port
0 to 65535
0~1024 is set for the communication protocol
- 22: SSH
- 80: HTTP
- 443: HTTPS

FastAPI: python web framework

fast, easy, and productive
built-in API documentation

Poetry: dependency management tool

dependency resolver to prevent dependency version error
virtualenv for an isolated environment
able to build and publish

Path Parameter: GET method with value directly on the path

Query Parameter: GET method that gives key-value pair to pass many data

Client to API: Request Body

API to Client: Response Body

By using response_model in the decorator, output data is modified with that description
- auto-documentation and data validation

There is a field in the Header called Content-Type that tells what type of data is passed

Form: allows to get Form data from the request

File Uploading: need to use python-multipart

Pydantic: data validation/settings management library

forces type hinting
validation for normal python types
faster than other libraries
config management

Event Handler: a function that is called when some event is happening

API Router: using multiple APIs together

Error Handling: the developer needs to collect a log of errors happening to the client

use HTTPExceptiojn to tell the client to recognize what is happening

Background Tasks: allows for an immediate response without waiting for full execution

use the GET method later to the stored task to find out if the task is completed

Types of data:

database data: data needed for service
user action log: data obtained from the user's action
- not necessarily needed for the service, but it is for analysis
infrastructure data: a metric that checks if the web server is working well
- number of requests and response
- DB overloading

Trace: log for development

Method of saving the data:

saving in the database(RDB): reusable in the service
- rows and columns
- define the relation between data and do data modeling
- important data related to the business
- use SQL to extract data
saving in the database(NoSQL): using elastic search, logstash or fluent, kibana
- loose schema
- fast read and write speed
saving in the object storage: saving as a file in S3 or Cloud Storage
- can save any type of data
- needs work to move to a separate database or data warehouse
saving in data warehouse: used for data analysis instantly
- save RDBMS, NoSQL, and Object Storage at once

DEBUG: logging information to solve a problem

INFO: working well

WARNING: potential problem

ERROR: cannot execute function

CRITICAL: the program does not work

Logger: a method for creating the log

Hander: send the log to a certain location, which could be saved or sent

Formatter: set the style of log

부스트캠프 14주차 학습 일지 - Semantic Segmentation

연두색연필 — Mon, 19 Dec 2022 13:46:38 +0900

사용한 기술 스택들:

12/19 월

학습한 것들:

mIOU: mean of IOU over classes

FCN: use the VGG network as the backbone and replace the FC layer with Convolution

allows using pretrained networks for better performance
pixel-wise prediction
convolution is irrelevant to image size
transposed convolution for upsampling
skip connection to have a sharp image
Small objects are often ignored

DeconvNet: make the encoder and decoder symmetrical by using unpooling and deconvolution

Unpooling: save the edge that was deleted during pooling
- fast as it does not need to be trained
- has a sparse activation map so it is required to use transposed convolution too
- unpooling captures "example-specific" structure
- transposed convolution captures a "class-specific" structure

SegNet: use convolution to turn the sparse matrix into a dense matrix

FC DenseNet: add skip connection inside a block and from the decoder to the encoder

DeepLab v1: mixing convolution and max pooling can increase the receptive field of a unit pixel of the feature map but is low in quality

use dilated convolution to be more efficient
use bilinear interpolation for upsampling
dense conditional random field to get pixel-wise segmentation

DilatedNet: DeepLab but only 2x2 max pool in the beginning

12/21 수

학습한 것들:

DeepLab v2: added ASPP which are branches that replaced the fully convolutional layer

branches act as an ensemble
ResNet backbone

PSPNet: use global average pooling to take surroundings into account

Accounts for mismatched relationship
- takes the surrounding into account
Confusion categories
- similar category can be confusing
Inconspicuous classes
- small objects can be detected using global contextual information

DeepLab v3: added global average pooling with 1x1 convolutional network

DeepLab v3+: use encoder-decoder structure again

use a decoder to restore the lost spatial information
modified Xception Backbone
- use depthwise + pointwise convolution

부스트캠프 12주차 학습 일지 - 데이터 제작

연두색연필 — Mon, 5 Dec 2022 15:31:30 +0900

사용한 기술 스택들:

12/5 월

학습한 것들:

성능 = 구조 + 데이터 + 최적화

Software 1.0

문제 정의
큰 문제를 작은 문제들의 집합으로 분해
개별 문제 별로 알고리즘 설계
솔루션들을 합쳐 하나의 시스템으로

Software 2.0

뉴럴넷 구조에 의해 검색을 한다
최적화를 통해 사람이 정한 목표에 가장 적합한 연산의 집합을 찾는다
경로와 목적지는 데이터와 최적화 방법에 의해서 정해진다

요즘 시대에는 인공지능이 솔루션을 찾게 설계를 한다

12/6 화

학습한 것들:

Production Process of AI Model:

모델 요구사항 확정
- 처리 시간
- 목표 정확도
- 목표 qps
- Serving 방식
- 장비 사양
데이터셋 준비
- 종류
- 수량
- 정답
모델 학습 및 디버깅
- 데이터 관련 피드백
- 요구사항 달성
설치 및 유지보수
- 성능 모니터링
- 이슈 해결

Data-centric: data만 수정하여 모델 성능 끌어올리기

서비스 출시 후의 성능 계선은 data를 늘리는 게 더 비용 절감도 되고 편하다

Model-centric: 데이터를 고정시키고 모델 성능 끌어올리기

학계에서 데이터를 다루기 힘든 이유:

좋은 데이터를 많이 모으기 힘들다
라벨링 비용이 크다
작업 기간이 오래 걸린다

라벨잉 노이즈를 상쇄할 정도로 깨끗한 라벨링 데이터가 많아야 한다

Best case: small data/clean labels/data balance

자주 보지 못하는 데이터 종류는 접해본 적이 많이 없기 때문에 라벨링 노이즈 세기가 늘어난다

Labeling is an iterative process

OCR: Optical Character Recognition

STR: Scene Text Recognition

글자 영역 다수 객체 검출: 글자 영역이냐 아니냐의 판별, 클래스 정보가 필요 없다

그냥 객체 검출과 다른 점

영역이 길고
밀도가 높다

OCR 순서:

Detector(글자 영역 검출) →

Recognizer(이미지를 글자로) →

Serializer(2D text to 1D text) →

Parser(understanding the text)

OCR services:

copy text from the image
Search image by word
move playlists to a new platform with screenshots
translate

Rectangle types:

RECT: (x1,y1,width,height)
RBOX: (x1,y1,width,height, θ)
QUAD: 4 x,y coordinates, x1,y1 is in top left and plot clockwise
Polygon: multiple coordinates to fit the arbitrary-shaped text

Regression-based: image to bbox directly using anchor box

downside: cannot work well with the arbitrary-shaped text, sometimes does not capture all the characters due to receptive field and anchor box

Segmentation-based: get the image as input to get pixel-wise data of whether that pixel is in the text area, along with 8 other probabilities for the border to divide those areas

downside: too slow post-processing, interference between different areas

Hybrid: get approximate bbox using regression and use segmentation to get pixel-wise data

EAST: An Efficient and Accurate Scene Text Detector

The network outputs two pieces of information about pixels:
- whether it is in the center of the text area (score map)
  - binary map
  - 30% less size of a ground truth bounding box
- if the pixel is a text area, where is the bbox (geometry map)
  - RBOX
    - 5 channel
  - QUAD
    - 8 channel
use U-Net
Consist of feature extractor stem, feature merging branch
use locality-aware NMS to merge the box from top to bottom as nearby pixels will predict the same text instance
class-balanced cross-entropy

Public dataset:

can acquire labeled images easily
data might not be what is needed
not many data

Synthetic image:

does not need to be labeled
fast acquirement
need to check if the data is similar to the real-world data

Crawled image:

fast at collecting images
not a lot of high-quality images
not a lot of samples
copyright

Crowd-sourced image:

expensive
high-quality

12/7 수

학습한 것들:

데이터 제작에서는 상세한 가이드라인 제작이 중요하다.

구글 검색을 통해 크롤링을 할 수가 있다

데이터 제작 순서:

가이드 작성
가이드 교육
라벨링
라벨링 검수
데이터 검수 by AI team

글자 검출 모델 평가방법:

두 영역 간의 매칭 판단 방법
- one-to-one match
- one-to-many match (split)
  - more prediction than ground truth
- may-to-one match (merge)
  - more ground truth than prediction
매칭 행렬에서 유사도 수치 계산 방법
- IOU
  - Only allow one-to-one matching
- Area recall, precision

DetEval: calculate for each cell in the matching matrix

One to one = 1
Many to one = 1
One to Many = 0.8
Recall = average by the ground truth
Precision = average by the prediction
Final score: F1-Score

TIoU: give a score for the area that is over or less than the ground truth

CLEval: score by how many characters the bbox got it right

Annotation tool:

LabelMe
- based on MIT open source
- easy to install
- cannot collaborate
CVAT
- made by intel
- multi-user
- various annotation
- the model inference is slow
Hasty Labeling tool
- multi-user
- not free
- cannot customize

DBNet: adaptive thresholding to give more threshold to the border

MOST: an improved version of EAST

TFAM: use deformable convolution to manage receptive field
PA-NMS(position-aware NMS): more weight to point that is predicted near the edge
Instance-wise IoU loss: IOU with normalization to give a scale-invariant characteristic

TextFuseNet: get global level feature along with character level feature

12/9 목

학습한 것들:

Synthetic data is cheap to create and has the correct label.

- use depth estimation to put the synthetic text in the right place

SynthText3D: use 3D virtual world to make a synthetic image

It is helpful to use synthetic data as a pretraining dataset

Use data augmentation: geometric transformation + style transformation ...

- use crop with no bbox cut so that it learns better

Multi-scale training can be helpful

부스트캠프 9주차 학습 일지 - Object Detection 1

연두색연필 — Mon, 14 Nov 2022 13:53:06 +0900

사용한 기술 스택들:

11/14 월

학습한 것들:

PR curve: calculated precision and recall from accumulated TP and FP sorted by confidence rate

Average precision: right rectangle estimation of PR curve

mAP(mean average precision): AP of classes/number of classes

- mAP50 means that it only regards IOU over 50 as True Positive

IOU(Intersection Over Union): $\frac{Overlapping\;region}{combined\;region}$

FPS is an important measure for live video object detection

FLOPs (floating point operations): count of the operation performed

MMDetection: object detection open source written in PyTorch

Detectron2: Meta ai research library for object detection and segmentation

YOLOv5: coco pretrained model that is well developed

EfficientDet: image detection model based on efficientnet made by google

R-CNN:

Extract Region proposals
1. Sliding Window: use a fix-sized box to move that across the image to get bounding boxes
2. Selective search: do an initial segmentation and add those together to get larger bounding boxes
  1. 2000 ROI
Compute CNN features
1. AlexNet
Classify
Adjust bounding box

R-CNN is not end-to-end

SPP-Net:

Forward the whole image through ConvNet
Extract ROI
Spatial Pyramid Pooling Layer
1. make the ROI the same size by passing through the layer instead of warping
FC layer
classify regions with SVM

Fast R-CNN:

Forward the whole image through VGG16
ROI projection to get ROI
1. project the selective search ROI to the output of VGG16
2. one batch only contains the ROI of an image
ROI pooling to get features with the same size
1. pyramid level 1 with 7x7 grid size
FC layer
Softmax classifier + bounding box regressor

R-CNN, SPP-Net, and Fast R-CNN are not end-to-end

Faster R-CNN:

Forward images through a network to get feature maps
Use Region Proposal Network(RPN) to get ROI
1. Replace selective search
2. Anchor box
  1. divide the image into cells that have different bound box sizes and numbers for each
  2. RPN predicts if there is an object in the cell and the transformation needed for the anchor boxes
  3. do 3x3 to make 512 channel
  4. 1x1x2 for binary classification of the existence of the object
  5. 1x1x4 for bounding box regression
3. NMS: remove the bounding box based on IoU and class score

11/15 화

학습한 것들:

mmdetection: 많은 프레임워크를 지원하고 빠름

- pytorch 기반 오픈소스 라이브러리

- Pipeline: Input, backbone, neck, dense prediction, prediction

- config 파일로 설정

- config 상속 받고 부분만 바꿈

Config 기본 구조:

dataset: coco, VOC, cityscape
model: faster_rcnn, RetinaNet, RPN
- 2stage model
  - type: type of model
  - backbone: a network that converts an image to feature map
    - can add a custom backbone
  - neck: connects backbone and head
  - rpn_head: region proposal network
  - RoI_head: region of interest
schedule
default_runtime

Detectron2: OD 말고 다른 알고리즘들도 지원함

- Pipeline: Setup config, setup trainer, start training

- 학습 방식은 mmdetection과 비슷함

Neck: Backbone과 RPN을 연결시켜주는 역할

- backbone의 중간 feature들도 사용하면서 다양한 크기의 객체를 더 잘 탐지할 수 있다

- 하위 level의 feature은 semantic이 약하므로 상대적으로 sematic이 강한 상위 feature와의 교환이 필요

- level당 feature을 섞어줌

featurized image pyramid: various resized image that is used to get the feature

single feature map: get output as the feature by passing an image

pyramidal feature hierarchy: pass through like a single feature map, but use the middle layer's feature too

feature pyramid network: give information from the high level to the low level by creating a top-down pathway

down-top and top-down features are added by doing 1x1 conv for the lateral connection and 2x upsampling convolution for the top-down pathway

Path Aggregation Network(PANet): add down-top pathway after top-down pathway for deep CNN

do RoI pooling for all the features

DetectoRS: looking and thinking twice

recursive feature pyramid: FPN that is done recursively
ASPP: give different dilation rates to increase the convolution receptive field size

EfficientDet: PANet that removes the node that is useless

weighted feature fusion: give weight to the layers to differentiate low level and high level
connect the lateral pathway to the down-top pathway too

NASFPN: find the FPN architecture by neural network search

Not generalizable

AugFPN: to solve the problem of loss of information on the highest feature map

Residual Feature Augmentation: give semantic information of a high level directly to the final pyramid
- ratio-invariant adaptive pooling
Soft RoI selection: use all features to get RoI by using weights

1-stage detectors: localization and classification at the same time

- fast and easy design

- taken into context

- YOLO, SSD, RetinaNet

You Only Look Once(YOLO): first 1-stage detector

- modified GoogLeNet

divide into the grid area
get b number of bounding boxes and a confidence score for each grid
1. confidence score: Prob(Object existing) * IOU of truth and pred
get the probability of class for each grid
1. conditional class probability: Pr(Class|Object)
The output contains 30 channels
1. 5 channels each for 2 bbox
  1. x coordinate of the center of the grid cell
  2. y coordinate of the center of the grid cell
  3. width of bbox
  4. height of bbox
  5. bbox confidence score
2. class maps
multiply the bbox confidence score by the class maps to get the probability of the bbox being the bbox for the object
make the probability zero if under a certain threshold and sort in descending order
use NMS to remove redundant bbox

SSD: to solve the problem of detecting small-sized objects and using only the last layer of the feature

- use 6 different scale feature maps: a big feature map predicts small objects while a small feature map predicts large objects

- use only the convolution layer

- use anchor box

- VGG-16 as the backbone

YOLO v2:

- higher resolution

- convolution with anchor boxes

- no FC layer

- batch normalization

- add early feature map to late feature map

- multi-scale training

- Darknet-19

- used WordTree which combined ImageNet and COCO to make a hierarchical dataset

YOLO v3:

- Darknet-53

- convolution stride 2

- use 3 different scales

- use Feature Pyramid Network

RetinaNet:

- to solve the problem of 1 stage detector having too many negative samples

- use new loss function (Focal Loss): cross-entropy loss + scaling factor (more importance on harder cases)

- Improvement in performance

11/16 수

학습한 것들:

Width scaling: used for a small model to get small details well

Depth scaling: used in many models to get complex and rich features but it has a problem of gradient vanishing

Resolution scaling: can get details very well

EfficientDet: efficiently scales the model

- match the width, depth, and resolution balance to achieve great performance with low computational cost

- idea from EfficientNet

- efficiency is needed for real-time

Efficient multi-scale feature fusion
1. remove the node with one edge only
2. add input to output by adding an edge
3. use repeated block
4. used a weighted sum of various resolutions
  1. BiFPN: weight passes through ReLU so that it does not become 0 and also add epsilon to make denominator non-zero, basically a weighted sum
model scaling: compound scaling like EfficientNet

Cascade RCNN: explored change when the threshold for the positive and negative sample is changed

- higher the input IoU, the better performance for a model that is trained with the higher threshold

- higher the threshold, it performs better when the AP IoU threshold is higher

- train multiple RoI heads, and set the IoU threshold differently for each head, the bounding box of the previous head is applied to the next head

- Iterative + Integral = Cascade

DCN(Deformable Convolutional Networks):

normal CNN is weak against geometric transformation
- traditional method: geometric augmentation, geometric invariant feature selection
when the convolution kernel is multiplied, give some geometric offset in the middle of convolutional operations
- has an offset field that contains an offset vector
- the model learns the offset of the feature
good performance in object detection and segmentation

The problem with ViT is that it has a high computational cost and needs a lot of data to train

DETR(End-to-End object detection with transformer:

replaces the need for NMS
use a high-level feature map because it needs a high computational cost
Pipeline
- Input
- CNN
- encoder + positional encoding
- decoder
- Feed forward Network
- N output
  - N> number of objects in the image
  - pad objects as no object by the amount of difference between N and the number of objects
    - this allows getting a precise amount of objects as output

Swin Transformer: use an architecture called window to reduce the computational cost

No class embedding
Two attention per transformer block
embedding is divided by the unit of the window, so the image is divided into many windows which decreases the computational cost of the model
- has a problem of not using other parts of the window as consideration, so Shifted Window Multi-Head Attention corrects that by different divisions of windows
trains well with a low amount of data

부스트캠프 8주차 학습 일지 - AI 서비스 개발 기초

연두색연필 — Mon, 7 Nov 2022 13:40:55 +0900

사용한 기술 스택들:

11/7 월

학습한 것들:

MLOps: ML +Ops(operations)

- 업무 자동화

- Machine Learning engineering + data engineering + cloud + infrastructure

- 빠른 시간 내에 가장 적은 위험을 부담하며 아이디어 단계부터 production 단계까지 진행할 수 있도록 기술적 마찰 줄이기

Research ML vs Production ML:

- static data vs dynamic data

- good performance vs fast inference with good performance

- SOTA vs stable

- offline vs online

MLOps components:

Model
Data, feature
CPU, GPU, Memory
scalability
cloud, server
Batch serving/online serving
experiment, model management
feature store
data validation
continuous training
monitoring
AutoML

Serving: 머신 러닝 모델을 앱이나 웹에서 사용할 수 있게 만드는 과정

Online serving: use HTTP protocol and API to handle requests

- servers need to be able to hold those requests

- API opens the request mechanism to the public

Single data point: serving a single data

There can be a server for preprocessing and a separate one for the ML model

Ways to make online serving:

make own API
use cloud service
use serving libraries

Batch serving: inference on every certain amount of time or every determined amount of data

Machine learning project flow:

define problem
- need to know what we are solving exactly
design the product
- check the validity of the value of the project
- look for existing data or model
- choose good lose function
- machine learning is good if there is a pattern and it is complex, repetitive
- gather data first if there is not one
- set the right goal and new objective
  - the goal needs to be ethical
  - the objective can be multiple so attention is needed
- get the constraint and the risk of the project
- make a baseline and prototype to start off
- set the right metric to evaluate
monitor after deployment
- performance
- which part went wrong

Business model: look for where the output can be used in the company

11/8 화

학습한 것들:

Voila: make a notebook to prototype web

- originally made for the dashboard

- easy to experiment with stuff

ipywidget: allows for interactive notebook

- slider allows for interactive control of value

- text allows for integer and string input

- checkbox

- dropdown

- file upload

- on_click

- observe

Streamlit: allows for web service in minor modifications of a python code

- no frontend needed

- many easy components

- runs every time when a change happens

11/9 수

학습한 것들:

virtualization: a template that is used for research and production environment

- to solve a different state of the environment in local, test, and production

virtual machine: use image to create an environment with OS

- it is heavy to run an OS on another OS

docker: use containers to lighten VM

- use docker image which is read-only to make a docker container that makes a copy of the image

- allows using other people's software instantly with the same setting and environment

container registry: like GitHub for container images

docker commands:

- pull: download image

- images: list of images

- run: run image to make container

- ps: current running container

- exec: go into the container

- container: stop running the container

- rm: remove the container

- volume mount allows connecting the file of the host and the container

- build: make the image

MLflow: allows for management of lifecycle in experiments and allows reproduce the experiment result

- experiment management & tracking

- model registry/versioning

- model serving

- project code versioning

MLflow commands:

- experiments create: make experiments that are like the theme of the project

- run: runs code 1 time: logs source, version, start&end time, parameters, metrics, tags, artifacts

- server: selects where to store the tracking data

실제 회사 환경에서는 어떤 서비스를 원하는지만 있기 때문에 어떤 데이터를 모아야 하는지 먼저 판단 해야한다.

서비스의 품질이 좋아야 하기 때문에 offline test 결과보다 online test가 더 잘 나오게 설계를 해야한다

- BY: 저작자 표시

- ND: 변경 금지

- NC: 비영리

- SA: 같은 조건의 CCL 적용의무

데이터의 bias가 결과에서도 반영이 된다

Proxies: unintentional discrimination

Masking: intentional discrimination

11/10 목

학습한 것들:

마스크 분류 모델을 streamlit과 streamlit cloud로 웹서비스를 만들어서 배포를 해봤다.

https://mask-classification.streamlit.app/

app · Streamlit

Check out this app I built with Streamlit!

mask-classification.streamlit.app

[백준] 6137번: 문자열 생성 풀이

연두색연필 — Sun, 6 Nov 2022 23:01:25 +0900

사용한 기술 스택들:

6137번: 문자열 생성 (acmicpc.net)

6137번: 문자열 생성

첫 번째 줄에 문자열 S의 길이 N이 주어진다. (N <= 2,000) 이후 N개의 줄에 S를 이루는 문자들이 주어진다.

www.acmicpc.net

코드:

import sys

input = lambda: sys.stdin.readline().rstrip()
n = int(input())
s=""
for _ in range(n):
    s+=input()
l=0
r=n-1
ans=""
while l<=r:
    if s[l]<s[r]:
        ans+=s[l]
        l+=1
    elif s[l]>s[r]:
        ans+=s[r]
        r-=1
    else:
        t_l=l+1
        t_r=r-1
        front=True
        while t_l<=t_r:
            if s[t_l]<s[t_r]:
                front=True
                break
            elif s[t_l]>s[t_r]:
                front=False
                break
            else:
                t_l+=1
                t_r-=1
        if front:
            ans+=s[l]
            l+=1
        else:
            ans+=s[r]
            r-=1
print(*[ ans[i:i+80] for i in range(0, n, 80) ],sep="\n")

풀이:

이 문제에서는 문자열 $s$로 사전적으로 제일 작은 문자열 $t$를 만들려고 한다. 이 문제를 그냥 s로 만들 수 있는 모든 조합을 찾으려고 하면 경우의 수가 $O(2^N)$이 되기 때문에 제한이 2000까지인 이 문제는 $2^{2000} = 1.148e+602$ 정도이기 때문에 절대 시간내에 돌수가 없다.

그렇다면 여기에서 가능한 풀이는 그리디적인 풀이라고 추측을 해볼 수 있다. PS에서는 제한을 아는 것이 참 중요한데, 왜냐하면 제한을 알면 어느정도의 시간복잡도를 예측할 수 있기 때문이다.

while l<=r:
    if s[l]<s[r]:
        ans+=s[l]
        l+=1
    elif s[l]>s[r]:
        ans+=s[r]
        r-=1

여기서 그리디적인 사고를 사용하자면, $s$의 앞이나 뒤에있는 문자를 $t$에 붙인다면, 사전적으로 제일 작은 문자열을 만든다면, 그냥 앞이나 뒤에서 제일 알파벳적으로 작은 것부터 꺼내오면 된다는 사실을 알게된다. 어짜피 앞에서부터 차근차근 $t$가 만들어지기 때문에 그냥 작은것들로 먼저 채워주는게 해답이라는 것을 알게 된다.

t_l=l+1
t_r=r-1
front=True
while t_l<=t_r:
    if s[t_l]<s[t_r]:
        front=True
        break
    elif s[t_l]>s[t_r]:
        front=False
        break
    else:
        t_l+=1
        t_r-=1
if front:
    ans+=s[l]
    l+=1
else:
    ans+=s[r]
    r-=1

하지만, 여기서 문제가 발생한다. $s$가 만약에 acba같은 상황이라면 어떻게 해야 하는가? 이를 위해 예외처리를 해줘야 한다. 이 예시에서의 해답은 aabc이다. 이와 같이 앞뒤가 다 같은 상황이라면 그 다음 문자를 확인해 주면 된다는 것이다. 다음 문자들에서 비교하고 그문자들 중에 앞에게 더 작으면 그쪽으로 가는게 최적이기 때문에 front를 True로 설정해주고 그 반대라면 False로 설정해준다. 하지만 다음 문자들도 같을 수가 있기 때문에 이는 반복문 처리를 해줘서 다른 점을 찾을때까지 돌리면 된다.

예시: s=ACDBCB

s=ACDBCB t=None
1. A가 B보다 작기 때문에 A를 붙여준다
s=CDBCB t=A
1. C가 B보다 크기 때문에 B를 붙여준다
s=CDBC t=AB
1. 앞뒤가 C로 같기 때문에 그 다음 문자를 확인 한다 D와 B 중에서는 B가 작기 때문에 뒤에 있는 C를 붙여준다
s=CDB t=ABC
1. 여기서부터는 크기대로 붙여주는 걸 반복한다
t=ABCBCD

현재 이 코드에선 $l$이 현재 s의 앞의 문자의 위치, $r$이 뒤의 문자의 위치로 설정이 되었다. $l$은 앞에 문자를 사용할 때마다 1씩 올려주면 되고 뒤에 문자를 사용하면 $r$을 하나씩 내려주면 될 것이다(투포인터 알고리즘). $t{\_}l$은 당연히 temporary한 변수로 그 다음 문자를 저장 할 것이고, $t{\_}r$도 마찬가지로 작동한다. 이 알고리즘을 그대로 적용하여 코드를 구현을 하면 정답을 받게 된다.

이 문제의 최악의 시간 복잡도는 $O(N^2)$이다. 이 사례는 aaaaaa같이 각 문자마다 안에 있는 반복문을 하나 더 돌려주어야 하기 때문이다.

소스코드:

baekjoonProblems/볼_모으기.py at main · LimePencil/baekjoonProblems (github.com)

GitHub - LimePencil/baekjoonProblems: 백준 코딩문제 자바&파이썬 해답

백준 코딩문제 자바&파이썬 해답 . Contribute to LimePencil/baekjoonProblems development by creating an account on GitHub.

github.com